c语言板跑迷宫

kno

1. #include<stdio.h>
   
2. #include<stdlib.h>
   
3. #include <stdbool.h>
   
4. #include <assert.h>
   
5. 
   
6. 
   
7. 
   
8. 
   
9. typedef struct stack{
   
10.     int capacity;//最大容量
    
11.     int top;//栈顶
    
12.     int *pst;
    
13. }stack;
    
14. 
    
15. 
    
16. // 初始化栈
    
17. void stackinit(stack* ps);
    
18. // 入栈
    
19. void stackpush(stack* ps, int data);
    
20. // 出栈
    
21. void stackpop(stack* ps);
    
22. // 获取栈顶元素
    
23. int stacktop(stack* ps);
    
24. // 获取栈中有效元素个数
    
25. int stacksize(stack* ps);
    
26. // 检测栈是否为空，如果为空返回非零结果，如果不为空返回0
    
27. bool stackempty(stack* ps);
    
28. // 销毁栈
    
29. void stackdestroy(stack *ps);
    
30. 
    
31. int maze[8][8]={1,1,0,1,1,1,0,1,
    
32.                 1,1,0,1,1,1,0,1,
    
33.                 1,1,1,1,0,0,1,1,
    
34.                 1,0,0,0,1,1,1,1,
    
35.                 1,1,1,0,1,1,1,1,
    
36.                 1,0,1,1,1,0,1,1,
    
37.                 1,0,0,0,1,0,0,1,
    
38.                 0,1,1,1,1,1,1,1,};//1表示通,0表示不通，表示迷宫
    
39. 
    
40. int map[8][8]={0,0,0,0,0,0,0,0,
    
41.                0,0,0,0,0,0,0,0,
    
42.                0,0,0,0,0,0,0,0,
    
43.                0,0,0,0,0,0,0,0,
    
44.                0,0,0,0,0,0,0,0,
    
45.                0,0,0,0,0,0,0,0,
    
46.                0,0,0,0,0,0,0,0,
    
47.                0,0,0,0,0,0,0,0,};//地图用于表示迷宫位置是否已走过
    
48. 
    
49. 
    
50. void stackinit(stack *ps){
    
51.     ps->pst=NULL;
    
52.     ps->top=0;
    
53.     ps->capacity=0;//栈总的容量
    
54. }
    
55. 
    
56. void stackpush(stack *ps,int data){
    
57.     assert(ps); //断言ps是否存在
    
58. 
    
59.     if(ps->top == ps->capacity)
    
60.     {
    
61.         int newcapacity=ps->capacity==0?4 : ps->capacity*2;
    
62.         int *tmp=(int *)realloc(ps->pst,newcapacity*sizeof(int));
    
63.         if(tmp==NULL)
    
64.         {
    
65.             perror("realloc fail");
    
66.             return;
    
67.         }
    
68.         ps->pst=tmp;
    
69.         ps->capacity=newcapacity;
    
70.     }
    
71.     ps->pst[ps->top]=data;
    
72.     ps->top++;
    
73. }
    
74. 
    
75. void stackpop(stack *ps){
    
76.     assert(ps);
    
77.     assert(!stackempty(ps));
    
78.     ps->top--;
    
79. }
    
80. 
    
81. int stacktop(stack *ps)
    
82. {
    
83.     assert(ps);
    
84.     int top=ps->top;
    
85.     return (ps->pst)[top-1];
    
86. }
    
87. 
    
88. int stacksize(stack *ps){
    
89.     assert(ps);
    
90.     return ps->top;
    
91. }
    
92. 
    
93. bool stackempty(stack *ps){
    
94.     assert(ps);
    
95.     if(ps->top==0)
    
96.     {
    
97.         return true;
    
98.     }
    
99.     return false;
    
100. }
     
101. 
     
102. void stackdestroy(stack *ps){
     
103.     assert(ps);
     
104.     free(ps->pst);
     
105. }
     
106. 
     
107. int main()
     
108. {
     
109.     int currentpoint=1,finalpoint=64;
     
110. 
     
111. 
     
112.     stack people;
     
113.     stack * p=&people;
     
114.     stackinit(p);
     
115.     stackpush(p,currentpoint);
     
116.     map[0][0]=1;//
     
117. 
     
118.     while(currentpoint!=finalpoint)//直到终点停止
     
119.     {
     
120.         int i,j;//标记地图
     
121.         //判断能否上
     
122.         j=((currentpoint-8)%8)-1;
     
123.         i=((currentpoint-8)/8);
     
124.         if(currentpoint-8>1 && maze[i][j]==1 && map[i][j]==0)
     
125.         {
     
126. 
     
127.             currentpoint=currentpoint-8;
     
128.             stackpush(p,currentpoint);
     
129.             map[i][j]=1; //标记已走
     
130.             printf("w ");
     
131.             continue;
     
132.         }
     
133.             //能否右走
     
134.              j=((currentpoint+1)%8)-1;
     
135.              i=((currentpoint+1)/8);
     
136.             if(currentpoint%8!=0 && maze[i][j]==1 && map[i][j]==0){
     
137. 
     
138. 
     
139.                 currentpoint=currentpoint+1;
     
140.                 stackpush(p,currentpoint);
     
141.                 map[i][j]=1;
     
142.                 printf("d ");
     
143.                 continue;
     
144.             }
     
145. 
     
146.             //能否下走
     
147.             j=((currentpoint+8)%8)-1;
     
148.             i=((currentpoint+8)/8);
     
149.              if(currentpoint+8<=64 && maze[i][j]==1 && map[i][j]==0){
     
150.                 currentpoint=currentpoint+8;
     
151.                 stackpush(p,currentpoint);
     
152.                 map[i][j]=1;
     
153.                 printf("s ");
     
154.                 continue;
     
155.             }
     
156.             //能否左走
     
157.             j=((currentpoint-1)%8)-1;
     
158.             i=((currentpoint-1)/8);
     
159.             if((currentpoint-1)%8!=0 && maze[i][j]==1 && map[i][j]==0){
     
160. 
     
161.                 currentpoint=currentpoint-1;
     
162.                 stackpush(p,currentpoint);
     
163.                 map[i][j]=1;
     
164.                 printf("a ");
     
165.                 continue;
     
166.             }
     
167.             //都不能走
     
168.             stackpop(p);
     
169.             currentpoint=stacktop(p);
     
170.             printf("返回位置%d\n",currentpoint);
     
171.     }
     
172.         printf("well");
     
173. 
     
174. 
     
175. }
     
176. 
     
177. 
     
178. 
     
179. 
     
180. 
     
181. 
     
182. 
     

复制代码

希望能对栈有更深刻的认识

FishC

这段代码有一些错误。首先，`#include`的语句不完整，应该添加`<stdbool.h>`用于定义布尔类型。其次，`assert`函数需要`<assert.h>`头文件的支持。此外，你在声明`maze`和`map`时使用了大括号`{ }`，这是错误的。应该使用方括号`[ ]`来表示数组。

以下是修改后的代码：

1. #include <stdio.h>
   
2. #include <stdbool.h>
   
3. #include <assert.h>
   
4. #include <stdlib.h>
   
5. 
   
6. typedef struct stack {
   
7.     int capacity;
   
8.     int top;
   
9.     int *pst;
   
10. } stack;
    
11. 
    
12. void stackinit(stack *ps);
    
13. void stackpush(stack *ps, int data);
    
14. void stackpop(stack *ps);
    
15. int stacktop(stack *ps);
    
16. int stacksize(stack *ps);
    
17. bool stackempty(stack *ps);
    
18. void stackdestroy(stack *ps);
    
19. 
    
20. int maze[] = {1, 1, 0, 1, 1, 1, 0, 1,
    
21.               1, 1, 0, 1, 1, 1, 0, 1,
    
22.               1, 1, 1, 1, 0, 0, 1, 1,
    
23.               1, 0, 0, 0, 1, 1, 1, 1,
    
24.               1, 1, 1, 0, 1, 1, 1, 1,
    
25.               1, 0, 1, 1, 1, 0, 1, 1,
    
26.               1, 0, 0, 0, 1, 0, 0, 1,
    
27.               0, 1, 1, 1, 1, 1, 1, 1}; // 1表示通, 0表示不通
    
28. 
    
29. int map[] = {0, 0, 0, 0, 0, 0, 0, 0,
    
30.              0, 0, 0, 0, 0, 0, 0, 0,
    
31.              0, 0, 0, 0, 0, 0, 0, 0,
    
32.              0, 0, 0, 0, 0, 0, 0, 0,
    
33.              0, 0, 0, 0, 0, 0, 0, 0,
    
34.              0, 0, 0, 0, 0, 0, 0, 0,
    
35.              0, 0, 0, 0, 0, 0, 0, 0,
    
36.              0, 0, 0, 0, 0, 0, 0, 0}; // 地图用于表示迷宫位置是否已走过
    
37. 
    
38. void stackinit(stack *ps) {
    
39.     ps->pst = NULL;
    
40.     ps->top = 0;
    
41.     ps->capacity = 0;
    
42. }
    
43. 
    
44. void stackpush(stack *ps, int data) {
    
45.     assert(ps);
    
46. 
    
47.     if (ps->top == ps->capacity) {
    
48.         int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
    
49.         int *tmp = (int *)realloc(ps->pst, newcapacity * sizeof(int));
    
50.         if (tmp == NULL) {
    
51.             perror("realloc fail");
    
52.             return;
    
53.         }
    
54.         ps->pst = tmp;
    
55.         ps->capacity = newcapacity;
    
56.     }
    
57.     ps->pst[ps->top] = data;
    
58.     ps->top++;
    
59. }
    
60. 
    
61. void stackpop(stack *ps) {
    
62.     assert(ps);
    
63.     assert(!stackempty(ps));
    
64.     ps->top--;
    
65. }
    
66. 
    
67. int stacktop(stack *ps) {
    
68.     assert(ps);
    
69.     return ps->pst[ps->top - 1];
    
70. }
    
71. 
    
72. int stacksize(stack *ps) {
    
73.     assert(ps);
    
74.     return ps->top;
    
75. }
    
76. 
    
77. bool stackempty(stack *ps) {
    
78.     assert(ps);
    
79.     return ps->top == 0;
    
80. }
    
81. 
    
82. void stackdestroy(stack *ps) {
    
83.     assert(ps);
    
84.     free(ps->pst);
    
85. }
    
86. 
    
87. int main() {
    
88.     int currentpoint = 1, finalpoint = 64;
    
89.    
    
90.     stack people;
    
91.     stack *p = &people;
    
92.     stackinit(p);
    
93.     stackpush(p, currentpoint);
    
94.     map[currentpoint - 1] = 1;
    
95. 
    
96.     while (currentpoint != finalpoint) {
    
97.         int i, j;
    
98.         
    
99.         // 判断能否上走
    
100.         j = ((currentpoint - 8) % 8);
     
101.         i = ((currentpoint - 8) / 8);
     
102.         if (currentpoint - 8 >= 1 && maze[currentpoint - 9] == 1 && map[currentpoint - 9] == 0) {
     
103.             currentpoint -= 8;
     
104.             stackpush(p, currentpoint);
     
105.             map[currentpoint - 1] = 1;
     
106.             printf("W ");
     
107.             continue;
     
108.         }
     
109. 
     
110.         // 判断能否右走
     
111.         j = ((currentpoint + 1) % 8);
     
112.         i = ((currentpoint + 1) / 8);
     
113.         if (currentpoint % 8 != 0 && maze[currentpoint] == 1 && map[currentpoint] == 0){
     
114.             currentpoint += 1;
     
115.             stackpush(p, currentpoint);
     
116.             map[currentpoint - 1] = 1;
     
117.             printf("D ");
     
118.             continue;
     
119.         }
     
120. 
     
121.         // 判断能否下走
     
122.         j = ((currentpoint + 8) % 8);
     
123.         i = ((currentpoint + 8) / 8);
     
124.         if (currentpoint + 8 <= 64 && maze[currentpoint + 7] == 1 && map[currentpoint + 7] == 0){
     
125.             currentpoint += 8;
     
126.             stackpush(p, currentpoint);
     
127.             map[currentpoint - 1] = 1;
     
128.             printf("S ");
     
129.             continue;
     
130.         }
     
131. 
     
132.         // 判断能否左走
     
133.         j = ((currentpoint - 1) % 8);
     
134.         i = ((currentpoint - 1) / 8);
     
135.         if (currentpoint % 8 != 1 && maze[currentpoint - 2] == 1 && map[currentpoint - 2] == 0){
     
136.             currentpoint -= 1;
     
137.             stackpush(p, currentpoint);
     
138.             map[currentpoint - 1] = 1;
     
139.             printf("A ");
     
140.             continue;
     
141.         }
     
142. 
     
143.         stackpop(p);
     
144.         currentpoint = stacktop(p);
     
145.         printf("B ");
     
146.     }
     
147. 
     
148.     stackdestroy(p);
     
149.    
     
150.     return 0;
     
151. }

复制代码

这里只是简单展示了迷宫的求解过程，没有进行任何输出结果的判断。运行程序后，会输出当前移动的方向（W、D、S、A）以及在退回之后的移动（B）。你可以根据自己的需要进行适当的调整和修改。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。