[已解决]数据结构，回文数判断用C

向舒

问题在下面的那个*********处，我已经想了一点，但还是有点错误，我需要怎么改？？

思路：
将前len/2个字符放进栈中
设置标志
将栈顶元素与str中对称位置元素进行比较
  - 若相同，栈顶元素弹栈，进行下一次比较
  - 若不同，标志设为0，结束循环
我出现的错误：
判断不了


#include "stack_.h"

// 栈表操作实现文件
//////////////////////////////////////////////////////////////


Stack* Stack_Create(int maxlen)
// 创建栈
{
    Stack* stk = (Stack*)malloc(sizeof(Stack));
    stk->data = (T*)malloc(sizeof(T)*maxlen);
    stk->max = maxlen;
    stk->top = -1;
    return stk;
}

void Stack_Free(Stack* stk)
// 释放栈
{
    free(stk->data);
    free(stk);
}

void Stack_MakeEmpty(Stack* stk)
// 置为空栈
{
    stk->top = -1;
}

bool Stack_IsEmpty(Stack* stk)
// 判断栈是否空
{
    return -1 == stk->top;
}

bool Stack_IsFull(Stack* stk)
// 判断栈是否满
{
    return stk->top == stk->max-1;
}

T Stack_Top(Stack* stk)
// 获取当前栈顶元素
{
    return stk->data[stk->top];
}

T Stack_Push(Stack* stk, T e)
// 将元素e压入栈顶
// 返回栈顶点元素
{
    if(Stack_IsFull(stk)) {
        printf("Stack_IsFull(): stack full error when push element to the stack!\n");
        Stack_Free(stk);
        exit(0);
    }
    else{
        stk->top += 1;
        stk->data[stk->top] = e;
        return Stack_Top(stk);
    }
}

T Stack_Pop(Stack* stk)
// 将栈顶元素出栈
// 返回栈顶元素
{
    if(Stack_IsEmpty(stk)) {
        printf("Stack_IsEmpty(): stack empty error when pop element of the stack top!\n");
        Stack_Free(stk);
        exit(0);
    }
    else{
        T topE = Stack_Top(stk);
        stk->top -= 1;
        return topE;
    }
}

void Stack_Print(Stack* stk)
// 打印栈顶到栈低的元素
{
    if (Stack_IsEmpty(stk)) {
        printf("The stack is empty.\n");
        return;
    }
   
    //printf("The stack contains: ");
    for (int i=stk->top; i>=0; i--) {
        printf("%d", stk->data[i]);
    }
    printf("\n");
   
}

void Palindrome(T* str, int len)
//  利用stack栈判断字符串是否为回文串
//  输入参数：字符串序列，字符串长度
//  若是回文串输出YES，否则输出NO，末尾换行
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
    Stack *stk = Stack_Create(100);
    int i;
    for(i = 0;i<len/2;i++)
    Stack_Push(stk,str[i]);
    int state = i;
    if(len%2 == i)
    i++;
    for(;i<len&&state;i++)
    if(!Stack_IsEmpty(stk)&&Stack_Top(stk) == str[i])
    {
        Stack_Pop(stk);
    }
    else
    {
        state = 0;
    }
    if(Stack_IsEmpty(stk)&&state)
    {
        printf("YES");
    }
    else
    {
        printf("NO");
    }
    printf("\n");

    /********** End **********/
}

最佳答案

月排行榜 / 总排行榜

人造人

2021-11-6 19:33:48

为什么别人不理你？
你这代码要别人怎么看？
你发了问题都不检查一下的吗？
同样，你这代码我也没法看，但是作为练习，我自己写了一个，你可以看一下
你代码存在的问题
1. 你发的代码不完整
2. *********处的代码没法看
3. 感觉你的算法不对，仅仅只是感觉，因为你的代码***********处没法看，不知道对不对

stack.h

1. #ifndef _STACK_H_
   
2. #define _STACK_H_
   
3. 
   
4. #include <stddef.h>
   
5. #include <stdbool.h>
   
6. 
   
7. struct stack_node_tag {
   
8.     void *data;
   
9.     size_t size;
   
10.     struct stack_node_tag *next;
    
11. };
    
12. 
    
13. typedef struct {
    
14.     struct stack_node_tag *head;
    
15.     size_t size;
    
16. } stack_t;
    
17. 
    
18. stack_t *stack_init(void);
    
19. void stack_deinit(stack_t *stack);
    
20. bool stack_clean(stack_t *stack);
    
21. bool stack_push(stack_t *stack, const void *data, size_t size);
    
22. bool stack_pop(stack_t *stack);
    
23. bool stack_top(const stack_t *stack, void *data, size_t size);
    
24. size_t stack_size(const stack_t *stack);
    
25. bool stack_empty(const stack_t *stack);
    
26. 
    
27. #endif
    

复制代码

stack.c

1. #include "stack.h"
   
2. #include <stdlib.h>
   
3. #include <memory.h>
   
4. 
   
5. stack_t *stack_init(void) {
   
6.     stack_t *stack = malloc(sizeof(*stack));
   
7.     if(!stack) return NULL;
   
8.     stack->head = NULL;
   
9.     stack->size = 0;
   
10.     return stack;
    
11. }
    
12. 
    
13. void stack_deinit(stack_t *stack) {
    
14.     if(!stack) return;
    
15.     stack_clean(stack);
    
16.     free(stack);
    
17. }
    
18. 
    
19. bool stack_clean(stack_t *stack) {
    
20.     if(!stack) return false;
    
21.     while(!stack_empty(stack)) stack_pop(stack);
    
22.     return true;
    
23. }
    
24. 
    
25. bool stack_push(stack_t *stack, const void *data, size_t size) {
    
26.     if(!stack) return false;
    
27.     if(!data) return false;
    
28.     struct stack_node_tag *node = malloc(sizeof(*node));
    
29.     if(!node) return false;
    
30.     node->data = malloc(size);
    
31.     if(!node->data) {free(node); return false;}
    
32.     memcpy(node->data, data, size);
    
33.     node->size = size;
    
34.     node->next = stack->head;
    
35.     stack->head = node;
    
36.     ++stack->size;
    
37.     return true;
    
38. }
    
39. 
    
40. bool stack_pop(stack_t *stack) {
    
41.     if(!stack) return false;
    
42.     if(stack_empty(stack)) return false;
    
43.     struct stack_node_tag *temp = stack->head;
    
44.     stack->head = temp->next;
    
45.     free(temp->data); free(temp);
    
46.     --stack->size;
    
47.     return true;
    
48. }
    
49. 
    
50. bool stack_top(const stack_t *stack, void *data, size_t size) {
    
51.     if(!stack) return false;
    
52.     if(!data) return false;
    
53.     if(stack_empty(stack)) return false;
    
54.     struct stack_node_tag *temp = stack->head;
    
55.     if(temp->size > size) return false;
    
56.     memcpy(data, temp->data, temp->size);
    
57.     return true;
    
58. }
    
59. 
    
60. size_t stack_size(const stack_t *stack) {
    
61.     if(!stack) return 0;
    
62.     return stack->size;
    
63. }
    
64. 
    
65. bool stack_empty(const stack_t *stack) {
    
66.     if(!stack) return true;
    
67.     return stack_size(stack) == 0;
    
68. }
    

复制代码

main.c

1. #include "stack.h"
   
2. #include <stdio.h>
   
3. #include <stdbool.h>
   
4. 
   
5. int main(void) {
   
6.     char str[1024]; scanf("%s", str);
   
7.     stack_t *stack = stack_init();
   
8.     for(size_t i = 0; str[i]; ++i) {
   
9.         stack_push(stack, &str[i], sizeof(str[i]));
   
10.     }
    
11.     bool flag = true;
    
12.     for(size_t i = 0; str[i]; ++i) {
    
13.         char temp;
    
14.         stack_top(stack, &temp, sizeof(temp));
    
15.         stack_pop(stack);
    
16.         if(temp != str[i]) {
    
17.             flag = false; break;
    
18.         }
    
19.     }
    
20.     if(flag) printf("yes\n");
    
21.     else printf("no\n");
    
22.     stack_deinit(stack);
    
23.     return 0;
    
24. }
    

复制代码

跳转到最佳答案楼层

人造人

为什么别人不理你？
你这代码要别人怎么看？
你发了问题都不检查一下的吗？
同样，你这代码我也没法看，但是作为练习，我自己写了一个，你可以看一下
你代码存在的问题
1. 你发的代码不完整
2. *********处的代码没法看
3. 感觉你的算法不对，仅仅只是感觉，因为你的代码***********处没法看，不知道对不对

stack.h

1. #ifndef _STACK_H_
   
2. #define _STACK_H_
   
3. 
   
4. #include <stddef.h>
   
5. #include <stdbool.h>
   
6. 
   
7. struct stack_node_tag {
   
8.     void *data;
   
9.     size_t size;
   
10.     struct stack_node_tag *next;
    
11. };
    
12. 
    
13. typedef struct {
    
14.     struct stack_node_tag *head;
    
15.     size_t size;
    
16. } stack_t;
    
17. 
    
18. stack_t *stack_init(void);
    
19. void stack_deinit(stack_t *stack);
    
20. bool stack_clean(stack_t *stack);
    
21. bool stack_push(stack_t *stack, const void *data, size_t size);
    
22. bool stack_pop(stack_t *stack);
    
23. bool stack_top(const stack_t *stack, void *data, size_t size);
    
24. size_t stack_size(const stack_t *stack);
    
25. bool stack_empty(const stack_t *stack);
    
26. 
    
27. #endif
    

复制代码

stack.c

1. #include "stack.h"
   
2. #include <stdlib.h>
   
3. #include <memory.h>
   
4. 
   
5. stack_t *stack_init(void) {
   
6.     stack_t *stack = malloc(sizeof(*stack));
   
7.     if(!stack) return NULL;
   
8.     stack->head = NULL;
   
9.     stack->size = 0;
   
10.     return stack;
    
11. }
    
12. 
    
13. void stack_deinit(stack_t *stack) {
    
14.     if(!stack) return;
    
15.     stack_clean(stack);
    
16.     free(stack);
    
17. }
    
18. 
    
19. bool stack_clean(stack_t *stack) {
    
20.     if(!stack) return false;
    
21.     while(!stack_empty(stack)) stack_pop(stack);
    
22.     return true;
    
23. }
    
24. 
    
25. bool stack_push(stack_t *stack, const void *data, size_t size) {
    
26.     if(!stack) return false;
    
27.     if(!data) return false;
    
28.     struct stack_node_tag *node = malloc(sizeof(*node));
    
29.     if(!node) return false;
    
30.     node->data = malloc(size);
    
31.     if(!node->data) {free(node); return false;}
    
32.     memcpy(node->data, data, size);
    
33.     node->size = size;
    
34.     node->next = stack->head;
    
35.     stack->head = node;
    
36.     ++stack->size;
    
37.     return true;
    
38. }
    
39. 
    
40. bool stack_pop(stack_t *stack) {
    
41.     if(!stack) return false;
    
42.     if(stack_empty(stack)) return false;
    
43.     struct stack_node_tag *temp = stack->head;
    
44.     stack->head = temp->next;
    
45.     free(temp->data); free(temp);
    
46.     --stack->size;
    
47.     return true;
    
48. }
    
49. 
    
50. bool stack_top(const stack_t *stack, void *data, size_t size) {
    
51.     if(!stack) return false;
    
52.     if(!data) return false;
    
53.     if(stack_empty(stack)) return false;
    
54.     struct stack_node_tag *temp = stack->head;
    
55.     if(temp->size > size) return false;
    
56.     memcpy(data, temp->data, temp->size);
    
57.     return true;
    
58. }
    
59. 
    
60. size_t stack_size(const stack_t *stack) {
    
61.     if(!stack) return 0;
    
62.     return stack->size;
    
63. }
    
64. 
    
65. bool stack_empty(const stack_t *stack) {
    
66.     if(!stack) return true;
    
67.     return stack_size(stack) == 0;
    
68. }
    

复制代码

main.c

1. #include "stack.h"
   
2. #include <stdio.h>
   
3. #include <stdbool.h>
   
4. 
   
5. int main(void) {
   
6.     char str[1024]; scanf("%s", str);
   
7.     stack_t *stack = stack_init();
   
8.     for(size_t i = 0; str[i]; ++i) {
   
9.         stack_push(stack, &str[i], sizeof(str[i]));
   
10.     }
    
11.     bool flag = true;
    
12.     for(size_t i = 0; str[i]; ++i) {
    
13.         char temp;
    
14.         stack_top(stack, &temp, sizeof(temp));
    
15.         stack_pop(stack);
    
16.         if(temp != str[i]) {
    
17.             flag = false; break;
    
18.         }
    
19.     }
    
20.     if(flag) printf("yes\n");
    
21.     else printf("no\n");
    
22.     stack_deinit(stack);
    
23.     return 0;
    
24. }
    

复制代码

做最好的自己520