[已解决]迷宫问题-栈-空指针

墨笠阳

需求：以一个m×n的长方阵表示迷宫，0和1分别表示迷宫中的通路和障碍。设计一个程序，对任意设定的迷宫，求出一条从入口到出口的通路，获得出没有通路的结论。

程序设计思路：定义一个position类型的结构体来储存迷宫元素，用栈来存储迷宫maze 和通路path ，定义了两个指针p、per，分别指向在迷宫中遍历的当前位置和下一位置，通过“FindPath“函数的返回值判断，是否有通路，若有，则用for循环，将通路坐标自path栈输出，若无，则输出无通路的结论。
“FindPath“函数

操作1.依照”上、左、下、右”顺序从当前起点位置 p 开始对迷宫进行深度遍历，当下一位置per 未越边界、无障碍 且未被访问时，使 *per入通路栈path，并对其进行标记，表示已访问，再以per为新起点，进行深度遍历，直到下一位置per不满足入path栈的条件，

操作2.此时判断栈顶元素是否是出口，若是，则return 1；若不是，则判断是否是入口，若是，则return 0，若不是，使path栈栈顶元素出栈，实现回退，以新栈顶元素为新起点，重复操作1，操作2

问题：初始化及构建maze栈完成后，将maze栈的首地址赋给指针p,经检验，赋值后，指针p仍为空指针，与预期不符，求各位大佬不吝赐教

1. InitStack_FindPath(path);//初始化通路栈
   
2. InitStack_maze(maze);//初始化迷宫栈
   
3. cout << "请输入行数：" ;
   
4. cin >> row;
   
5. cout << "\n请输入列数：";
   
6. cin >> col
   
7. cout << endl;
   
8. Creat_maze(maze,row,col);//创造迷宫
   
9. start = maze.base;//将迷宫入口的地址赋给指针start
   
10. end = maze.top - 1;//将迷宫出口的地址赋给指针end
    
11. p = maze.base;//将迷宫入口的地址赋给指针p
    
12. p->step = 1;
    
13. 
    
14. //验证指针p是否为空
    
15. if (p) {
    
16. cout << "NULL";
    
17. cout << "\tx= " << p->x << "\ty= " << p->y << "\tpos= " << p->pos << "\tstep= " << p->step << endl;
    
18. }
    
19. 
    

复制代码

输入：

5

5

0 1 0 1 1

0 0 1 1 1

1 0 1 0 1

1 0 0 0 1

1 0 1 0 0

输出：NULL    x= 0    y= 0    pos= 0  step= 0

1. <blockquote>

复制代码

最佳答案

月排行榜 / 总排行榜

isdkz

2023-7-9 22:33:01

我理解您正在使用一个栈结构和深度优先搜索算法来寻找一个迷宫的路径。在您提供的代码片段中，我看到您使用了一个栈类型的结构体来存储迷宫和路径，并定义了两个指针p和per来分别指向在迷宫中遍历的当前位置和下一个位置。您的问题似乎是在初始化迷宫栈并赋值给p指针后，发现p指针仍为空。

首先，对于问题的解决，这可能涉及到对栈的初始化和赋值的实现方式。你可能需要检查  InitStack_maze(maze) ，  Creat_maze(maze,row,col) ，以及  maze.base  的实现，以确保他们都在正确的位置初始化和分配内存，并确保  maze.base  正确地指向了栈底部的内存地址。

然后，你也需要注意的是，你的输出表示p是NULL，但是后面的字段显示x，y，pos，step有具体的值。这有可能是  if(p)  的逻辑判断有问题。如果  p  为空，那么  if(p)  的结果应该是false，所以应该不会执行下面的  cout  语句，这就产生了矛盾。你应该检查你的  if  条件判断的正确性，以确保它的逻辑是正确的。

最后，可以使用一些调试技巧，比如在创建迷宫后打印栈的情况，检查栈是否已经正确初始化和填充。同时，你也可以打印  maze.base  和  maze.top  的值，看看他们是否正确地指向了栈的底部和顶部。

如果你可以提供更多关于  InitStack_maze(maze) ，  Creat_maze(maze,row,col) ，以及  maze.base  的实现细节，我可能可以提供更具体的建议。

跳转到最佳答案楼层

墨笠阳

1. //struct.h
   
2. #include<malloc.h>
   
3. #define MAX_STACK_FindPath_SIZE 1275
   
4. #define MAX_ROW 50
   
5. #define MAX_COL 50
   
6. 
   
7. //位置
   
8. typedef struct  position {
   
9.     int x = 0;//横坐标
   
10.     int y = 0;//纵坐标
    
11.     int pos = 1;//1，有障碍        0 无障碍        
    
12.     int step = 0;//1 已访问 0 未访问，-1 回退时再次访问
    
13. }position;
    
14. 
    
15. typedef struct {
    
16.     position* base;
    
17.     position* top;
    
18.     int stacksize;
    
19. }Stack;
    
20. 
    
21. //初始化
    
22. int InitStack_FindPath(Stack& S) {
    
23.     S.base = new position[MAX_STACK_FindPath_SIZE];
    
24.     if (!S.base)
    
25.         return 0;
    
26.     else {
    
27.         S.top = S.base;
    
28.         S.stacksize = MAX_STACK_FindPath_SIZE;
    
29.         return 1;
    
30.     }
    
31. }
    
32. 
    
33. int InitStack_maze(Stack& S) {
    
34.     int max = MAX_ROW * MAX_COL;
    
35.     S.base = new position[max];
    
36.     if (!S.base)
    
37.         return 0;
    
38.     else {
    
39.         S.top = S.base;
    
40.         S.stacksize = max;
    
41.         return 1;
    
42.     }
    
43. }
    
44. 
    
45. //入栈
    
46. int Push(Stack& S, position p) {
    
47.     if (S.top - S.base == S.stacksize)//栈满
    
48.         return 0;
    
49.     else {
    
50.         *S.top = p;
    
51.         S.top++;
    
52.         return 1;
    
53.     }
    
54. }
    
55. 
    
56. //出栈
    
57. int Pop(Stack& S, position& p) {
    
58.     if (S.top == S.base)
    
59.         return 0;
    
60.     else {
    
61.         p = *(S.top - 1);
    
62.         S.top--;
    
63.         return 1;
    
64.     }
    
65. }

复制代码

墨笠阳

1. #include<iostream>
   
2. #include"struct.h"
   
3. using namespace std;
   
4. 
   
5. void Creat_maze(Stack& maze, int row,int col);
   
6. int FindPath(Stack& maze, Stack& path, position* p, position* start,position* end,int row,int col);
   
7. int main() {
   
8.         Stack maze;
   
9.         Stack path;
   
10.         position* p;
    
11.         position* start, * end;
    
12.         int row, col;
    
13.         InitStack_FindPath(path);
    
14.         InitStack_maze(maze);
    
15.         cout << "请输入行数：" ;
    
16.         cin >> row;
    
17.         cout << "\n请输入列数：";
    
18.         cin >> col;
    
19.         cout << endl;
    
20.         Creat_maze(maze,row,col);
    
21.         start = maze.base;
    
22.         end = maze.top - 1;
    
23.         p = maze.base;
    
24. 
    
25.         if (p) {
    
26.                 cout << "NULL";
    
27.                 cout << "\tx= " << p->x << "\ty= " << p->y << "\tpos= " << p->pos << "\tstep= " << p->step << endl;
    
28.         }
    
29. 
    
30.         p->step = 1;
    
31.         if (FindPath(maze, path, p, start,end,row, col)) {
    
32.                 p = path.base;
    
33.                 while (p!=path.top) {                       
    
34.                         cout << "(" << p->x << "," << p->y << ")" << endl;
    
35.                         p++;
    
36.                 }
    
37.                 return 1;
    
38.         }
    
39.         else {
    
40.                 cout << "此迷宫无通路！" << endl;               
    
41.                 return 0;
    
42.         }
    
43. }
    
44. void Creat_maze(Stack& maze, int row, int col) {
    
45.         int i, j;
    
46.         position p;
    
47.         for (i = 0; i < row; i++) {
    
48.                 p.x = i;
    
49.                 for (j = 0; j < col; j++) {
    
50.                         p.y = j;
    
51.                         cin >> p.pos;
    
52.                         Push(maze, p);
    
53.                 }
    
54.         }
    
55. }
    
56. int FindPath(Stack& maze, Stack& path, position* p,  position* start, position* end, int row, int col) {
    
57.         position* per;
    
58.          {
    
59.                 //向上
    
60.                 {
    
61.                         per = p - col;
    
62.                        
    
63.                         /* // 验证per是否空
    
64.                         if (per) {
    
65.                                 cout << "NULL";
    
66.                                 cout << "\tx= " << per->x << "\ty= " << per->y << "\tpos= " << per->pos << "\tstep= " << per->step<<endl;
    
67.                         }/**/
    
68.                         /**
    
69.                         if (p) {
    
70.                                 cout << "NULL";
    
71.                                 cout << "\tx= " << per->x << "\ty= " << per->y << "\tpos= " << per->pos << "\tstep= " << per->step << endl;
    
72.                         }/**/
    
73.                         if (!per && per->pos == 0 && per->step == 0) {
    
74.                                 //!per 未越上边界
    
75.                                 //per->pos == 0 无障碍
    
76.                                 //per->step == 0 未被访问
    
77.                                 Push(path, *per);
    
78.                                 per->step = 1;
    
79.                                 if (FindPath(maze, path, per, start, end, row, col)) {
    
80.                                         return 1;
    
81.                                 }
    
82.                                 else {
    
83.                                         return 0;
    
84.                                 }
    
85.                         }
    
86.                 }
    
87.                 //向左
    
88.                 {
    
89.                         per = p - 1;
    
90.                         /*
    
91.                         if (per) {
    
92.                                 cout << "NULL";
    
93.                                 cout << "\tx= " << per->x << "\ty= " << per->y << "\tpos= " << per->pos << "\tstep= " << per->step << endl;
    
94.                         }/**/
    
95.                         if (!per && p->x == per->x && per->pos == 0 && per->step == 0) {
    
96.                                 //!per && p->x == per->x 未越界
    
97.                                 Push(path, *per);
    
98.                                 per->step = 1;
    
99.                                 if (FindPath(maze, path, per, start, end, row, col)) {
    
100.                                         return 1;
     
101.                                 }
     
102.                                 else {
     
103.                                         return 0;
     
104.                                 }
     
105.                         }
     
106.                        
     
107.                 }
     
108.                 //向下
     
109.                 {
     
110.                         per = p + col;
     
111.                         if (!(per->x == 0 && per->y == 0 && per->pos == 1) && per->pos == 0 && per->step == 0) {
     
112.                                 //per->x == 0 && per->y == 0 && per->pos == 1 是position类型元素的默认值，表示maze栈外元素
     
113.                                 Push(path, *per);
     
114.                                 per->step = 1;
     
115.                                 if (FindPath(maze, path, per, start, end, row, col)) {
     
116.                                         return 1;
     
117.                                 }
     
118.                                 else {
     
119.                                         return 0;
     
120.                                 }
     
121.                         }
     
122.                 }
     
123.                 //向右
     
124.                 {
     
125.                         per = p + 1;
     
126.                         if (p->x == per->x && !(per->x == 0 && per->y == 0 && per->pos == 1) && per->pos == 0 && per->step == 0) {
     
127.                                 Push(path, *per);
     
128.                                 per->step = 1;
     
129.                                 if (FindPath(maze, path, per, start, end, row, col)) {
     
130.                                         return 1;
     
131.                                 }
     
132.                                 else {
     
133.                                         return 0;
     
134.                                 }
     
135.                         }
     
136.                 }
     
137. 
     
138.                 //判断，是出口,return 1
     
139.                 if (p == end) {
     
140.                         return 1;
     
141.                 }
     
142.                        
     
143.                 //不是出口
     
144.                 else{
     
145.                         //判断，是入口，return 0
     
146.                         if (p == start) {
     
147.                                 return 0;
     
148.                         }
     
149.                         //不是入口，回退，
     
150.                         else {
     
151.                                 position tem;
     
152.                                 Pop(path, tem);
     
153.                                 //以栈顶元素为新起点再遍历
     
154.                                 per = (maze.base + (path.top - 1)->x * col + (path.top - 1)->y);
     
155.                                 if (FindPath(maze, path, per, start, end, row, col)) {
     
156.                                         return 1;
     
157.                                 }
     
158.                                 else {
     
159.                                         return 0;
     
160.                                 }
     
161.                         }
     
162.                 }
     
163. 
     
164.         }
     
165. 
     
166. }
     

复制代码

isdkz

我理解您正在使用一个栈结构和深度优先搜索算法来寻找一个迷宫的路径。在您提供的代码片段中，我看到您使用了一个栈类型的结构体来存储迷宫和路径，并定义了两个指针p和per来分别指向在迷宫中遍历的当前位置和下一个位置。您的问题似乎是在初始化迷宫栈并赋值给p指针后，发现p指针仍为空。

首先，对于问题的解决，这可能涉及到对栈的初始化和赋值的实现方式。你可能需要检查  InitStack_maze(maze) ，  Creat_maze(maze,row,col) ，以及  maze.base  的实现，以确保他们都在正确的位置初始化和分配内存，并确保  maze.base  正确地指向了栈底部的内存地址。

然后，你也需要注意的是，你的输出表示p是NULL，但是后面的字段显示x，y，pos，step有具体的值。这有可能是  if(p)  的逻辑判断有问题。如果  p  为空，那么  if(p)  的结果应该是false，所以应该不会执行下面的  cout  语句，这就产生了矛盾。你应该检查你的  if  条件判断的正确性，以确保它的逻辑是正确的。

最后，可以使用一些调试技巧，比如在创建迷宫后打印栈的情况，检查栈是否已经正确初始化和填充。同时，你也可以打印  maze.base  和  maze.top  的值，看看他们是否正确地指向了栈的底部和顶部。

如果你可以提供更多关于  InitStack_maze(maze) ，  Creat_maze(maze,row,col) ，以及  maze.base  的实现细节，我可能可以提供更具体的建议。

墨笠阳

isdkz 发表于 2023-7-9 22:33
我理解您正在使用一个栈结构和深度优先搜索算法来寻找一个迷宫的路径。在您提供的代码片段中，我看到您使用 ...

谢谢您的回复，问题已解决，确实是if(p)的逻辑判断出了问题

sfqxx

墨笠阳 发表于 2023-7-9 22:49

怎么了？

墨笠阳

sfqxx 发表于 2023-7-9 22:50
怎么了？

报错了

墨笠阳

调试过后发现确实是if(p) 的逻辑判断出问题了，
//越边界时，per为空，if(per)==if(false)；未越界时,if(per)==if(true)，
问题已解决，谢谢大家