[已解决]C语言栈

434773632

怎么才能做到图片上的输入效果，比如push 56为入栈，pop为出栈，end表示结束

最佳答案

月排行榜 / 总排行榜

人造人

2021-11-3 22:41:34

1. /*
   
2. #include "stdio.h"
   
3. #include "stdlib.h"
   
4. #include "string.h"
   
5. */
   
6. #include <stdio.h>
   
7. #include <stdlib.h>
   
8. #include <string.h>
   
9. 
   
10. #define true 1
    
11. #define false 0
    
12. #define Status int
    
13. 
    
14. typedef struct {
    
15.     int *base;
    
16.     int *top;
    
17.     int stacksize;
    
18. } SqStack;
    
19. 
    
20. /*
    
21. Status SS_Init(SqStack *S, int max);
    
22. Status SS_IsFull(SqStack S);
    
23. Status SS_IsEmpty(SqStack S);
    
24. void SS_Length(SqStack S);
    
25. Status SS_push(SqStack *S, int e);
    
26. Status SS_pop(SqStack *S, int *e);
    
27. */
    
28. 
    
29. Status SS_Init(SqStack *S, int max) {
    
30.     //S->base = (int *)malloc(max * sizeof(int));
    
31.     S->base = malloc(max * sizeof(int));
    
32.     //if(!(S->base)) exit(1);
    
33.     if(!S->base) exit(1);
    
34.     S->top = S->base;
    
35.     S->stacksize = max;
    
36.     return true;
    
37. }
    
38. 
    
39. // 为什么不写释放函数？
    
40. void stack_deinit(SqStack *s) {
    
41.     free(s->base);
    
42. }
    
43. 
    
44. //Status SS_IsFull(SqStack S) {
    
45. Status SS_IsFull(SqStack *S) {
    
46.     //if(S.top - S.base == S.stacksize) {
    
47.     if(S->top - S->base == S->stacksize) {
    
48.         return true;
    
49.     } else {
    
50.         return false;
    
51.     }
    
52. }
    
53. 
    
54. //Status SS_IsEmpty(SqStack S) {
    
55. Status SS_IsEmpty(SqStack *S) {
    
56.     //if(S.top == S.base) {
    
57.     if(S->top == S->base) {
    
58.         return true;
    
59.     } else {
    
60.         return false;
    
61.     }
    
62. }
    
63. 
    
64. //void SS_Length(SqStack S) { printf("Stack length:%d\n", S.top - S.base); }
    
65. //void SS_Length(SqStack S) { printf("Stack length:%ld\n", S.top - S.base); }
    
66. void SS_Length(SqStack *S) { printf("Stack length:%ld\n", S->top - S->base); }
    
67. 
    
68. Status SS_push(SqStack *S, int e) {
    
69.     /*
    
70.     int m;
    
71.     m = SS_IsFull(*S);
    
72.     */
    
73.     //int m = SS_IsFull(*S);
    
74.     int m = SS_IsFull(S);
    
75.     //if(!m) {
    
76.     if(m) {
    
77.         return false;
    
78.     } else {
    
79.         *(S->top) = e;
    
80.         S->top++;
    
81.         return true;
    
82.     }
    
83. }
    
84. 
    
85. Status SS_pop(SqStack *S, int *e) {
    
86.     /*
    
87.     int m;
    
88.     m = SS_IsEmpty(*S);
    
89.     */
    
90.     //int m = SS_IsEmpty(*S);
    
91.     int m = SS_IsEmpty(S);
    
92.     //if(!m) {
    
93.     if(m) {
    
94.         return false;
    
95.     } else {
    
96.         (S->top)--;
    
97.         *e = *(S->top);
    
98.     }
    
99.     return true;
    
100. }
     
101. 
     
102. //Status SS_print(SqStack S) {
     
103. Status SS_print(SqStack *S) {
     
104.     /*
     
105.     int m;
     
106.     m = SS_IsEmpty(S);
     
107.     */
     
108.     int m = SS_IsEmpty(S);
     
109.     //if(!m) {
     
110.     if(m) {
     
111.         printf("stack data: Empty!\n");
     
112.         return false;
     
113.     } else {
     
114.         //printf("stack data (from bottom to top):");
     
115.         printf("stack data (from top to bottom): ");
     
116.         //while(S.top != S.base) {
     
117.         while(S->top != S->base) {
     
118.             S->top--;
     
119.             //printf("%d ", *(S->top));
     
120.             printf("%d ", *S->top);
     
121.         }
     
122.         //printf("%d", S.base);
     
123.         //printf("%d", *S.base);
     
124.         //printf("%d", *S->base);
     
125.     }
     
126. 
     
127.     printf("\n");
     
128. 
     
129.     return true;
     
130. }
     
131. 
     
132. int main() {
     
133.     SqStack S;
     
134.     //int max, b, i = 0;
     
135.     //int b, i = 0;
     
136.     int b;
     
137.     //char ch;
     
138.     char a[10];
     
139.     /*
     
140.     scanf("%d", &max);
     
141.     SS_Init(&S, max);
     
142.     */
     
143.     int temp;
     
144.     scanf("%d", &temp);
     
145.     SS_Init(&S, 1024);
     
146.     while(1) {
     
147.         scanf("%s", a);
     
148.         /*
     
149.         while((ch = getchar()) != ' ') {
     
150.             a[i] = ch;
     
151.             i++;
     
152.         }
     
153.         */
     
154.         if(strcmp(a, "push") == 0) {
     
155.             scanf("%d", &b);
     
156.             SS_push(&S, b);
     
157.         }
     
158.         if(strcmp(a, "pop") == 0) {
     
159.             //SS_push(&S, b);
     
160.             SS_pop(&S, &b);
     
161.         }
     
162.         if(strcmp(a, "end") == 0) {
     
163.             break;
     
164.         }
     
165.     }
     
166.     //SS_Length(S);
     
167.     SS_Length(&S);
     
168.     //SS_print(S);
     
169.     SS_print(&S);
     
170.     stack_deinit(&S);
     
171.     return 0;
     
172. }
     

复制代码

跳转到最佳答案楼层

人造人

这问题有意思，帮你写了
不过还是建议自己动手写，自己在写的过程中遇到了问题再提问，而不是直接要一个答案，直接看答案对你自己没有什么好处

stack.h

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

复制代码

stack.c

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

复制代码

main.c

1. #include "stack.h"
   
2. #include <stdio.h>
   
3. #include <string.h>
   
4. 
   
5. enum {ERR, PUSH, POP, END};
   
6. 
   
7. typedef struct {
   
8.     int type;
   
9.     int value;
   
10. } instruction_t;
    
11. 
    
12. instruction_t get_instruction(void) {
    
13.     char buff[1024]; scanf("%s", buff);
    
14.     instruction_t ins;
    
15.     if(!strcmp(buff, "end")) {
    
16.         ins.type = END;
    
17.     } else if(!strcmp(buff, "push")) {
    
18.         ins.type = PUSH;
    
19.         scanf("%d", &ins.value);
    
20.     } else if(!strcmp(buff, "pop")) {
    
21.         ins.type = POP;
    
22.     } else ins.type = ERR;
    
23.     return ins;
    
24. }
    
25. 
    
26. void output(stack_t *stack) {
    
27.     size_t length; stack_size(stack, &length);
    
28.     printf("Stack length: %lu\n", length);
    
29.     printf("stack data (from bottom to top): ");
    
30.     stack_t *temp = stack_init();
    
31.     while(!stack_empty(stack)) {
    
32.         int data; stack_pop(stack, &data);
    
33.         stack_push(temp, data);
    
34.     }
    
35.     while(!stack_empty(temp)) {
    
36.         int data; stack_pop(temp, &data);
    
37.         printf("%d ", data);
    
38.     }
    
39.     printf("\n");
    
40.     stack_deinit(temp);
    
41. }
    
42. 
    
43. int main(void) {
    
44.     int temp; scanf("%d", &temp);   // 完全不需要这个 6
    
45.     stack_t *stack = stack_init();
    
46.     while(1) {
    
47.         instruction_t ins = get_instruction();
    
48.         if(ins.type == END) break;
    
49.         switch(ins.type) {
    
50.             case PUSH: stack_push(stack, ins.value); break;
    
51.             case POP: stack_pop(stack, NULL); break;
    
52.         }
    
53.     }
    
54.     output(stack);
    
55.     stack_deinit(stack);
    
56.     return 0;
    
57. }
    

复制代码

人造人

c++ ?

我竟然写代码不看题目要求，还写了半天 stack
我服了，^_^

434773632

人造人 发表于 2021-11-3 21:41
c++ ?

我竟然写代码不看题目要求，还写了半天 stack

那个输入格式是怎么实现的，比如push 65

人造人

这题目对于 C语言来说有意思，对于 C++ 来说没意思

1. #include <iostream>
   
2. #include <string>
   
3. #include <stack>
   
4. 
   
5. enum {ERR, PUSH, POP, END};
   
6. 
   
7. typedef struct {
   
8.     int type;
   
9.     int value;
   
10. } instruction_t;
    
11. 
    
12. instruction_t get_instruction(void) {
    
13.     std::string str; std::cin >> str;
    
14.     instruction_t ins;
    
15.     if(str == "end") {
    
16.         ins.type = END;
    
17.     } else if(str == "push") {
    
18.         ins.type = PUSH;
    
19.         std::cin >> ins.value;
    
20.     } else if(str == "pop") {
    
21.         ins.type = POP;
    
22.     } else ins.type = ERR;
    
23.     return ins;
    
24. }
    
25. 
    
26. int main() {
    
27.     {int temp; std::cin >> temp;}
    
28.     std::stack<int> stack;
    
29.     while(1) {
    
30.         instruction_t ins = get_instruction();
    
31.         if(ins.type == END) break;
    
32.         switch(ins.type) {
    
33.             case PUSH: stack.push(ins.value); break;
    
34.             case POP: stack.pop(); break;
    
35.         }
    
36.     }
    
37.     size_t length = stack.size();
    
38.     printf("Stack length: %lu\n", length);
    
39.     printf("stack data (from bottom to top): ");
    
40.     std::stack<int> temp;
    
41.     while(!stack.empty()) {
    
42.         int data = stack.top(); stack.pop();
    
43.         temp.push(data);
    
44.     }
    
45.     while(!temp.empty()) {
    
46.         int data = temp.top(); temp.pop();
    
47.         std::cout << data << " ";
    
48.     }
    
49.     std::cout << std::endl;
    
50.     return 0;
    
51. }
    

复制代码

人造人

434773632 发表于 2021-11-3 21:52
那个输入格式是怎么实现的，比如push 65

输入交给 get_instruction 函数

434773632

434773632 发表于 2021-11-3 21:52
那个输入格式是怎么实现的，比如push 65

push后面没有回车，直接加空格和数字

434773632

434773632 发表于 2021-11-3 21:56
push后面没有回车，直接加空格和数字

怎么实现

人造人

434773632 发表于 2021-11-3 21:57
怎么实现

什么？

人造人

1. #include <iostream>
   
2. #include <string>
   
3. #include <stack>
   
4. 
   
5. enum {ERR, PUSH, POP, END};
   
6. 
   
7. typedef struct {
   
8.     int type;
   
9.     int value;
   
10. } instruction_t;
    
11. 
    
12. instruction_t get_instruction(void) {
    
13.     std::string str; std::cin >> str;
    
14.     instruction_t ins;
    
15.     if(str == "end") {
    
16.         ins.type = END;
    
17.     } else if(str == "push") {
    
18.         ins.type = PUSH;
    
19.         std::cin >> ins.value;
    
20.     } else if(str == "pop") {
    
21.         ins.type = POP;
    
22.     } else ins.type = ERR;
    
23.     return ins;
    
24. }
    
25. 
    
26. int main() {
    
27.     {int temp; std::cin >> temp;}
    
28.     std::stack<int> stack;
    
29.     while(1) {
    
30.         instruction_t ins = get_instruction();
    
31.         if(ins.type == END) break;
    
32.         switch(ins.type) {
    
33.             case PUSH: stack.push(ins.value); break;
    
34.             case POP: stack.pop(); break;
    
35.         }
    
36.     }
    
37.     std::cout << "Stack length: " << stack.size() << std::endl;
    
38.     std::cout << "stack data (from bottom to top): ";
    
39.     std::stack<int> temp;
    
40.     while(!stack.empty()) {
    
41.         int data = stack.top(); stack.pop();
    
42.         temp.push(data);
    
43.     }
    
44.     while(!temp.empty()) {
    
45.         int data = temp.top(); temp.pop();
    
46.         std::cout << data << " ";
    
47.     }
    
48.     std::cout << std::endl;
    
49.     return 0;
    
50. }
    

复制代码

人造人

?
究竟是 C语言还是 C++

434773632

人造人 发表于 2021-11-3 22:02
什么？

就是你要入栈的话，输入'push 56', push后面不能加回车

人造人

后缀 cpp，明显是 C++ 没问题

434773632

人造人 发表于 2021-11-3 22:10
?
究竟是 C语言还是 C++

都行

人造人

434773632 发表于 2021-11-3 22:11
就是你要入栈的话，输入'push 56', push后面不能加回车

对呀，你看我的 get_instruction 函数
这个函数要求加回车了？

434773632

人造人 发表于 2021-11-3 22:13
对呀，你看我的 get_instruction 函数
这个函数要求加回车了？

我看不懂c++，我只学过c语言，你把那个函数改成c语言的吧，感谢

人造人

434773632 发表于 2021-11-3 22:15
我看不懂c++，我只学过c语言，你把那个函数改成c语言的吧，感谢

给你第 0 次发的代码就是 C语言的

434773632

人造人 发表于 2021-11-3 22:13
对呀，你看我的 get_instruction 函数
这个函数要求加回车了？

1. #include"stdio.h"
   
2. #include"stdlib.h"
   
3. #include"string.h"
   
4. #define true 1
   
5. #define false 0
   
6. #define Status int
   
7. 
   
8. typedef struct
   
9. {
   
10.         int *base;
    
11.         int *top;
    
12.         int stacksize;
    
13. }SqStack;
    
14. 
    
15. Status SS_Init(SqStack *S, int max);
    
16. Status SS_IsFull(SqStack S);
    
17. Status SS_IsEmpty(SqStack S);
    
18. void SS_Length(SqStack S);
    
19. Status SS_push(SqStack *S, int e);
    
20. Status SS_pop(SqStack *S, int *e);
    
21. 
    
22. 
    
23. Status SS_Init(SqStack *S, int max)
    
24. {
    
25.         S->base = (int *)malloc(max * sizeof(int));
    
26.         if(!(S->base)) exit(1);
    
27.         S->top = S->base;
    
28.         S->stacksize = max;
    
29.         return true;
    
30. }
    
31. 
    
32. Status SS_IsFull(SqStack S)
    
33. {
    
34.         if(S.top - S.base == S.stacksize)
    
35.         {
    
36.                 return true;
    
37.         }
    
38.         else
    
39.         {
    
40.                 return false;
    
41.         }
    
42. }
    
43. 
    
44. Status SS_IsEmpty(SqStack S)
    
45. {
    
46.         if(S.top == S.base)
    
47.         {
    
48.                 return true;
    
49.         }
    
50.         else
    
51.         {
    
52.                 return false;
    
53.         }
    
54. }
    
55. 
    
56. void SS_Length(SqStack S)
    
57. {
    
58.         printf("Stack length:%d\n", S.top - S.base);
    
59. }
    
60. 
    
61. Status SS_push(SqStack *S, int e)
    
62. {
    
63.         int m;
    
64.         m = SS_IsFull(*S);
    
65.         if(!m)
    
66.         {
    
67.                 return false;
    
68.         }
    
69.         else
    
70.         {
    
71.                 *(S->top) = e;
    
72.                 S->top++;
    
73.                 return true;
    
74.         }
    
75. }
    
76. 
    
77. Status SS_pop(SqStack *S, int *e)
    
78. {
    
79.         int m;
    
80.         m = SS_IsEmpty(*S);
    
81.         if(!m)
    
82.         {
    
83.                 return false;
    
84.         }
    
85.         else
    
86.         {
    
87.                 (S->top)--;
    
88.                 *e = *(S->top);
    
89.         }
    
90. }
    
91. 
    
92. Status SS_print(SqStack S)
    
93. {
    
94.         int m;
    
95.         m = SS_IsEmpty(S);
    
96.         if(!m)
    
97.         {
    
98.                 printf("stack data: Empty!\n");
    
99.                 return false;
    
100.         }
     
101.         else
     
102.         {
     
103.                 printf("stack data (from bottom to top):");
     
104.                 while(S.top != S.base)
     
105.                 {
     
106.                         S.top--;
     
107.                         printf("%d ", *(S.top));
     
108.                 }
     
109.                 printf("%d", S.base);
     
110.         }
     
111. }
     
112. 
     
113. int main()
     
114. {
     
115.         SqStack S;
     
116.         int max, b, i = 0;
     
117.         char ch;
     
118.         char a[10];
     
119.         scanf("%d", &max);
     
120.         SS_Init(&S, max);
     
121.         while(1)
     
122.         {
     
123.                 while((ch = getchar()) != ' ')
     
124.                 {
     
125.                         a[i] = ch;
     
126.                         i++;
     
127.                 }
     
128.                 if(strcmp(a, "push") == 0)
     
129.                 {
     
130.                         scanf("%d", &b);
     
131.                         SS_push(&S, b);
     
132.                 }
     
133.                 if(strcmp(a, "pop") == 0)
     
134.                 {
     
135.                         SS_push(&S, b);
     
136.                 }
     
137.                 if(strcmp(a, "end") == 0)
     
138.                 {
     
139.                         break;
     
140.                 }
     
141.         }
     
142.         SS_Length(S);
     
143.         SS_print(S);
     
144.        
     
145. }

复制代码

你在我这个基础上改改，改成’push 56‘就入栈的形式

人造人

434773632 发表于 2021-11-3 22:15
我看不懂c++，我只学过c语言，你把那个函数改成c语言的吧，感谢

1. instruction_t get_instruction(void) {
   
2.     char buff[1024]; scanf("%s", buff);
   
3.     instruction_t ins;
   
4.     if(!strcmp(buff, "end")) {
   
5.         ins.type = END;
   
6.     } else if(!strcmp(buff, "push")) {
   
7.         ins.type = PUSH;
   
8.         scanf("%d", &ins.value);
   
9.     } else if(!strcmp(buff, "pop")) {
   
10.         ins.type = POP;
    
11.     } else ins.type = ERR;
    
12.     return ins;
    
13. }

复制代码

人造人

434773632 发表于 2021-11-3 22:16
你在我这个基础上改改，改成’push 56‘就入栈的形式

我看看