基于栈实现的迷宫问题
线性表、栈、队列的应用:C++实现迷宫问题

1. 问题描述:本实验假设迷宫是一个n 行n列的二维平面表格,左上角作为迷宫的入口,右下角作为迷宫的出口。
迷宫问题求解的目标是寻找一条从入口到出口的通路。
例如:可以用一个10×10的矩阵maze[10][10]来表示四周为墙的8×8迷宫,矩阵的元素为0或1,0表示通路,1表示墙(即无法穿越)。
左上角maze[1][1]=0作为迷宫的入口,右下角maze[8][8]=0作为迷宫的出口。
2.基本要求:本实验要求设计一个程序,能自动或手动生成这样一个n行n列的矩阵maze[n][n],即每个元素都为0或1的二维数组,然后判断该矩阵表示的迷宫是否存在一条从入口到出口的通路。
如果存在,将表示该通路的数组下标按顺序保存到文件path.txt,如:(1,1)(2,2)(1,3)(1,4)(1,5)(1,6)(2,6)(3,6)(4,7)(5,8)(6,8)(6,7)(7,6)(8,7)(8,8);如果不存在,则显示相关信息。
3. 实现提示:迷宫问题可以用深度优先搜索方法实现。
在迷宫内部的每一格都有4个方向可以走(走通或走不通)。
应用栈保存当前格的坐标(即数组下标),然后任意选取一个能走通的方向进行移动;移动后,到新一格,保存新格坐标,然后继续移动。
如果某格的3个方向都走不通,则返回上一格,选取另一个能走通的方向进行移动。
自动生成迷宫时,先用srand((unsigned)time(0))产生随机种子,然后再利用rand()%2来随机生成0或1,输出迷宫信息文件maze.txt;手动生成迷宫时,应当用读取文件的方式,例如创建包含迷宫信息的文件maze.txt。
//迷宫求解#include <iostream>#include <Windows.h>#include <stdio.h>#include <stdlib.h>#include <time.h>using namespace std;struct coordinate{int x, y;int direction;};class Maze{private:int i,j;int mark[10][10];coordinate stack[100];int point;int maze[10][10];coordinate temp,move;public:Maze();void existmaze(); //获得随机迷宫void displaymaze(); //显示迷宫void seekpath(); //试探获取路径void pushstack(coordinate&coor); //进栈void popstack(coordinate&coor); //出栈void movedirect(int n); //定义移动方向void setpoint(int x,int y); //光标控制void setcolor(unsigned short color); //选择颜色};void Maze::setpoint(int x,int y) //光标控制{COORD pos = {x,y};HANDLE hout = GetStdHandle(STD_OUTPUT_HANDLE);SetConsoleCursorPosition(hout,pos);}void Maze::setcolor(unsigned short color) //选择颜色{HANDLE hout = GetStdHandle(STD_OUTPUT_HANDLE);SetConsoleTextAttribute(hout,color);}void Maze::seekpath() //试探获取路径{int d,g,h;mark[1][1]=1;temp.x=1;temp.y=1;temp.direction=0;pushstack(temp);while(point!=0){i=temp.x;j=temp.y;d=temp.direction;while(d<4){movedirect(d);g=i+move.x;h=j+move.y;temp.x=i;temp.y=j;temp.direction=d;if(g==8&&h==8){pushstack(temp);setpoint(11,11);cout<<"find the way !"<<endl;return;}else if(maze[g][h]==0&&mark[g][h]==0){mark[g][h]=1;pushstack(temp);i=g;j=h;d=0;}else d++;}popstack(temp);}setpoint(20,13);cout<<"no path in maze"<<endl;}void Maze::movedirect(int n) //定义移动方向{switch(n){case 0:move.x=0;move.y=1;break;case 1:move.x=1;move.y=0;break;case 2:move.x=0;move.y=-1;break;case 3:move.x=-1;move.y=0;}}void Maze::pushstack(coordinate&coor) //进栈{stack[point]=coor;Sleep(200);setpoint(stack[point].y*2,stack[point].x);setcolor(2);cout<<"☆";point++;}void Maze::popstack(coordinate&coor) //出栈{point--;if(point!=0){temp.x=stack[point].x;temp.y=stack[point].y;temp.direction=stack[point].direction++;}Sleep(200);setpoint(coor.y*2,coor.x);setcolor(1);cout<<" ";}Maze::Maze(){point=0;for(i=0;i<10;i++)for(j=0;j<10;j++)mark[i][j]=0;}void Maze::existmaze() //获得随机迷宫{srand((unsigned) time(NULL));for (i=0;i<10;i++)for(j=0;j<10;j++)maze[i][j]=rand()%2;for(i=0;i<10;i++){maze[0][i]=1;maze[i][0]=1;maze[9][i]=1;maze[i][9]=1;}}void Maze::displaymaze() //显示迷宫{for (i=0;i<10;i++){for(j=0;j<10;j++)if(maze[i][j]==1)cout<<"□";elsecout<<" ";cout<<endl;}setpoint(16,8);setcolor(2);cout<<"◆";}int main(){Maze m;m.existmaze(); //获得随机迷宫m.displaymaze(); //显示迷宫m.seekpath(); //试探获取路径//cin.get();return 0;}。
迷宫问题栈算法c++代码

迷宫问题栈算法c++代码迷宫问题是一个经典的寻路问题,目标是从迷宫的入口找到出口的路径。
栈是一个常用的数据结构,可以用来实现迷宫问题的解决方法。
下面是使用栈算法解决迷宫问题的C++代码。
```cpp#include <iostream>#include <stack>#include <vector>using namespace std;// 定义迷宫的大小const int N = 5;const int M = 5;// 定义迷宫的地图,0 表示可通行的路径,1 表示墙壁int maze[N][M] = {{0, 1, 0, 0, 0},{0, 1, 0, 1, 0},{0, 0, 0, 0, 0},{0, 1, 1, 1, 0},{0, 0, 0, 1, 0}};// 定义方向数组,分别表示右、下、左、上四个方向移动int dx[] = {1, 0, -1, 0};int dy[] = {0, 1, 0, -1};// 定义迷宫中的点struct Point {int x, y;};// 判断某个点是否在迷宫内且可通行bool isValid(int x, int y) {return x >= 0 && x < N && y >= 0 && y < M && maze[x][y] == 0;}// 使用栈算法寻找迷宫路径vector<Point> findPath(int startX, int startY, int endX, int endY) {stack<Point> s;vector<Point> path;bool visited[N][M] = {false};// 将起点加入栈中s.push({startX, startY});visited[startX][startY] = true;while (!s.empty()) {// 获取栈顶点Point current = s.top();s.pop();// 判断是否到达终点if (current.x == endX && current.y == endY) { path.push_back(current);break;}// 遍历四个方向for (int i = 0; i < 4; i++) {int nextX = current.x + dx[i];int nextY = current.y + dy[i];// 判断下一个点是否合法且未访问过 if (isValid(nextX, nextY)&& !visited[nextX][nextY]) {s.push({nextX, nextY});visited[nextX][nextY] = true; }}// 如果栈为空,说明无法到达终点if (s.empty()) {cout << '无法找到路径!' << endl; return path;}}// 反向输出路径while (!s.empty()) {path.push_back(s.top());s.pop();}return path;}int main() {int startX, startY, endX, endY;cout << '请输入起点坐标(以空格分隔):';cin >> startX >> startY;cout << '请输入终点坐标(以空格分隔):';cin >> endX >> endY;vector<Point> path = findPath(startX, startY, endX, endY);if (!path.empty()) {cout << '找到路径!路径长度为:' << path.size() << endl; cout << '路径为:';for (int i = path.size() - 1; i >= 0; i--) {cout << '(' << path[i].x << ', ' << path[i].y << ')';if (i != 0) {cout << ' -> ';}}}return 0;}```以上代码通过栈算法实现了迷宫问题的解决方法。
用栈解决迷宫问题

⽤栈解决迷宫问题⼀、因为栈是后进先出的特性,所以说⼀般⽤栈都是通过dfs来解决迷宫问题。
如果⽤队列的话就是通过bfs来解决。
⼆、c++代码:1 #include<iostream>2 #include<cstdio>3 #include<stdio.h>4 #include<string.h>5 #include<windows.h>6using namespace std;7const int maxn=1005;8#define MaxSize 100005 //栈最多元素个数9int M=4,N=4;10int w[6][6]=11 {12 {1,1,1,1,1,1}13 ,{1,0,0,0,1,1}14 ,{1,0,1,0,0,1}15 ,{1,0,0,0,1,1}16 ,{1,1,0,0,0,1}17 ,{1,1,1,1,1,1}18 };19int mg[maxn][maxn];20char s[maxn][maxn];21struct migong22 {23int i; //路径横坐标24int j; //路径纵坐标25int di; //⽅向26 } Stack[MaxSize],Path[MaxSize]; //定义栈和存放最短路径的数组27int top=-1; //栈顶指针28int counts=1; //路径数计数29int minlen=MaxSize; //最短路径长度30void mgpath() //路径为:(1,1)->(M,N)31 {32int i,j,di,finds,k;33 top++;34 Stack[top].i=1;35 Stack[top].j=1;36 Stack[top].di=-1;37 mg[1][1]=-1; //初始结点进栈38while(top>-1) //栈不空时循环39 {40 i=Stack[top].i;41 j=Stack[top].j;42 di=Stack[top].di;43if(i==M && j==N) //找到了出⼝,输出路径44 {45// cout<<counts<<": ";46// counts++;47// for(k=0; k<=top; k++)48// {49// cout<<"("<<Stack[k].i<<","<<Stack[k].j<<")"<<" ";50//51// }52// cout<<endl;53if(top+1<minlen) //⽐较输出最短路径54 {55for(k=0; k<=top; k++)56 Path[k]=Stack[k];57 minlen=top+1;58 }59 mg[Stack[top].i][Stack[top].j]=0; //让该位置变为其他路径的可⾛结点60 top--;61 i=Stack[top].i;62 j=Stack[top].j;63 di=Stack[top].di;64 }65 finds=0;66while(di<4 && finds==0) //找下⼀个可⾛结点67 {68 di++;69switch(di)70 {71case0:72 i=Stack[top].i-1;73 j=Stack[top].j;74break; //上⾯75case1:76 i=Stack[top].i;77 j=Stack[top].j+1;78break; //右边79case2:80 i=Stack[top].i+1;82break; //下⾯83case3:84 i=Stack[top].i;85 j=Stack[top].j-1;86break; //左边87 }88if(mg[i][j]==0) //因为地图外边围了⼀层墙,所以不需要判断边界89 finds=1;90 }91if(finds == 1) //找到了下⼀个可⾛结点92 {93 Stack[top].di=di; //修改原栈顶元素的di值94 top++; //下⼀个可⾛结点进栈95 Stack[top].i=i;96 Stack[top].j=j;97 Stack[top].di=-1;98 mg[i][j]=-1; //避免重复⾛到该结点99 }100else101 {102 mg[Stack[top].i][Stack[top].j]=0; //让该位置变为其他路径的可⾛结点103 top--;104 }105 }106 cout<<"最短路径如下(输出结果以坐标显⽰)"<<endl;107 cout<<"长度: "<<minlen<<endl;108 cout<<"路径: "<<endl;109for(k=0; k<minlen; k++)110 {111 cout<<"("<<Path[k].i<<","<<Path[k].j<<")"<<"";112 }113 }114int main()115 {116int x;117while(1)118 {119 system("cls");120 printf ( " 迷宫系统 \n");121 printf ( " \n");122 printf ( " \n");123 printf ("-------------------------------------- \n");124 printf ("--------------------------------------\n");125 printf ("--------⼁[0]重构地图⼁---\n");126 printf ("--------⼁[1]使⽤默认地图⼁---\n");127 printf ("--------⼁[2]结束⼁---\n");128 printf ("----------输⼊相应数字----------------\n");129 printf ("--------------------------------------- \n");130 printf ( " \n");131 printf ( " \n");132 scanf("%d",&x);133if(x==0)134 {135 system("cls");136 printf(" 重构地图\n");137 printf("输⼊内容请以空格或者换⾏分隔开,且0代表此处可⾛,1代表此处不可⾏\n"); 138 printf("\n现在请输⼊地图是⼏⾏⼏列\n");139int n,m;140 memset(mg,0,sizeof(mg));141 scanf("%d%d",&n,&m);142int flag=0;143 printf("\n请输⼊地图,请保证左上⾓和右下⾓都为0\n");144for(int i=1; i<=n; ++i)145 {146147 scanf("%s",s[i]+1);148 mg[i][0]=mg[i][m+1]=1;149 }150for(int j=1; j<=m; ++j)151 {152 mg[0][j]=mg[n+1][j]=1;153 }154for(int i=1;i<=n;++i)155 {156for(int j=1;j<=m;++j)157 {158 mg[i][j]=s[i][j]-'0';159 }160 }161 M=n;162 N=m;163164//cout<<"迷宫所有路径如下:"<<endl;165 mgpath();166 system("pause");167 }168else if(x==1)169 {171 M=N=4;172for(int i=0; i<6; ++i) 173 {174for(int j=0; j<6; ++j) 175 {176 mg[i][j]=w[i][j]; 177 }178 }179 mgpath();180 system("pause"); 181 }182else break;183 }184return0;185 }View Code。
数组栈解决迷宫问题

数组栈解决迷宫问题/*[迷宫问题]分析:1.建立一个路径栈path_stack,其中栈内有x,y用来记录坐标东南西北4个方向,分用用east,south,west,north表示初始位置x,y入栈{如果坐标[x][y+1]东探测为0时,入栈并标记当前坐标为2表示已行走过否则坐标[x+1][y]南探测为0时,入栈.............................否则坐标[x][y-1]西探测为0时,入栈..............................否则坐标[x-1][y]北探测为0时,入栈..............................否则坐标都不为0,此时探测到死角,这时就须要返回走即出栈返回x,y新坐标......继续探测为0的出口每执行一次判断终点坐}!!!严重注意:本程序在Turboc C++中运行时没有异常,在Visual C++ 6.0中编译也成功,运行时全部正常,但是得不到正确答案,原因是Visual C++ 6.0 结构体类型返回有误,该变量虽返回,但值没有返回,所以只须按结构体指针类型返因即可,TMD从凌晨1点卡到凌晨2点半 *///程序编写:#include<stdio.h>#define MAX 100struct node //栈的内容{int x;int y;}path_stack[MAX];int path_top=-1;int path_isEmpty() //栈的方法函数{if (path_top==-1) return 1; else return 0;}int path_push(int x,int y){if (path_top>=MAX){printf("Stack go beyond!\n"); return 0;}else{path_top++;path_stack[path_top].x=x;path_stack[path_top].y=y;return 1;}}node path_pop(){node null;null.x=0;null.y=0;if (path_isEmpty()) return null;else return path_stack[path_top--];}void main(){int maze[12][12]={{1,1,1,1,1,1,1,1,1,1,1,1}, {1,0,0,0,1,1,1,1,1,1,1,1},{1,1,1,0,1,1,0,0,0,0,1,1},{1,1,1,0,1,1,0,1,1,0,1,1},{1,1,1,0,0,0,0,1,1,0,1,1},{1,1,1,0,1,1,0,1,1,0,1,1},{1,1,1,0,1,1,0,1,1,0,1,1},{1,1,1,0,1,1,0,1,1,0,1,1},{1,1,1,0,1,1,0,1,1,0,1,1},{1,1,1,1,1,1,0,1,1,0,1,1},{1,1,0,0,0,0,0,0,1,0,0,1},{1,1,1,1,1,1,1,1,1,1,1,1}};int x=1,y=1; //起始点坐标int xx=10,yy=10; //终点坐标maze[x][y]=2; //起点已记录path_push(x,y); //存入栈while (x!=xx || y!=yy) //进行迷宫路径探测{if (maze[x][y+1]==0){y++;maze[x][y]=2;path_push(x,y);}else if (maze[x+1][y]==0){x++;maze[x][y]=2;path_push(x,y);}else if (maze[x][y-1]==0){y--;maze[x][y]=2;path_push(x,y);}else if (maze[x-1][y]==0){x--;maze[x][y]=2;path_push(x,y);}else //即为死角时{node temp=path_pop();x=temp.x;y=temp.y;}}for (int i=0; i<12; i++) //已探测的图{for (int j=0; j<12; j++)printf("%d ",maze[i][j]);putchar('\n');}while (!path_isEmpty()) //退栈输出记录所经过的路径坐标{node temp=path_pop();printf("Path X:%2d Y:%2d\n",temp.x,temp.y);}putchar('\n');}。
基于栈的应用实现解决迷宫问题论文

基于栈的应用实现解决迷宫问题论文数据结构与算法姓名:赵庶林学院及专业:航天自动化班级:0804102学号:H080410235一,问题重述:迷宫是一个矩形区域,它有一个入口和出口。
在迷宫的内部包含不能穿越的墙或障碍。
假定用n*m的矩形来描述迷宫,位置(0,0)代表入口,(n,m)表示出口,n和m分别代表迷宫的行数和列数。
迷宫中的每个位置都可用其行号和列号来指定。
在矩形中,当且仅当在位置(i,j)处有一个障碍时其值是0,否则为1,如一个迷宫对应的矩阵描述如下:1,1,0,1,1,1,0,1,1,1,0,1,1,1,0,1,1,1,1,1,0,0,1,1,1,0,0,0,1,1,1,1,1,1,1,0,1,1,1,1,1,0,1,1,1,0,1,1,1,0,0,0,1,0,0,1,0,1,1,1,1,1,1,1设计一个程序,对于此迷宫,求出一条从入口到出口的通道,或得出没有通路的结论。
二,算法的基本思想:走迷宫的过程可以模拟为一个搜索的过程:每到一处,总让它按东、南、西、北4个方向顺序试探下一个位置;如果某方向可以通过,并且不曾到达,则前进一步,在新位置上继续进行搜索;如果4个方向都走不通或曾经到达过,则退回一步,在原来的位置上继续试探下一位置。
每前进或后退一步,都要进行判断:若前进到了出口处,则说明找到了一条通路;若退回到了入口处,则说明不存在通路。
用一个字符类型的二维数组表示迷宫,数组中每个元素取值“1”(表示通路)或“0”(表示墙壁)。
迷宫的入口点在位置(0,0)处,出口点在位置(8,8)处。
设计一个模拟走迷宫的算法,为其寻找一条从入口点到出口点的通路。
构造两个栈,一个用来保存探索中的全部路径,一个用来保存有效路径。
首先把迷宫的入口作为当前位置。
如果当前位置是迷宫出口,那么已经找到了一条路径,搜索工作结束。
如果当前位置不是迷宫出口,则在当前位置上放置障碍物,以便阻止搜索过程又绕回到这个位置。
接下来检查相邻的位置中是否有空闲的(即没有障碍物),如果有,就移动到这个新的相邻位置,然后从这个位置开始搜索通往出口的路径。
迷宫问题实验报告用栈解决迷宫问题

数据结构实验报告题目:用栈解决迷宫问题一.需求分析1.以结构体Maze表示迷宫,其中pos表示该位置是否有障碍; freq记录该位置被经过的次数;数组move表示下一步的方向。
2.本程序自动随机生成一个12×12大小的迷宫,字符“H”表示有障碍,空符表示通路。
3.迷宫的入口为左上角,出口为右下角。
4.本程序只求出一条成功的通路。
二.概要设计为了实现上述操作,以栈为存储结构。
本程序包含三个模块:(1)主程序模块:实现人机交互。
(2)迷宫生产模块:随机产生一个12×12的迷宫。
(3)路径查找模块:实现通路的查找。
(4)求解迷宫中一条通路的伪代码:do{若当前位置可同,则{将当前位置插入栈顶;若该位置是出口位置,则结束;否则切换当前位置的东临方块为新的当前位置;}否则{若栈不空且栈顶位置尚有其他方向未被探索,则设定新的的当前位置为沿顺时针方向旋转找到的栈顶位置的下一相邻块若栈不空但栈顶位置的四周均不可通,则{删去栈顶位置;若栈不空,则重新测试新的栈顶位置,直至找到一个可通的相邻块或出栈至栈空。
}}} while(栈不空)三.详细设计栈的设计:typedef struct{Node *base,*top;int length;}Stack;Stack *initstack(); //初始化栈void printstack(Stack *s); //打印栈Status destroy(Stack *); //销毁整个栈Status deltop(Stack *s); //出栈Status pushelem(Stack *,ElemType ,ElemType); //进栈1. 主程序模块:int main(){printf("随机产生一个12×12的迷宫,X字符表示障碍,空符表示通路:\n");Maze a[N][N];makemaze(a);printf("输入回车键显示路径,*字符表示路径。
02-第4周栈和队列第5讲-栈和队列求解迷宫问题.pdf

while (qu.front!=qu.rear && !find)
//队列不空循环
{ qu.front++;
//出队
i=qu.data[qu.front].i; j=qu.data[qu.front].j;
if (i==xe && j==ye)
//找到了出口,输出路径
{ find=1;
print(qu,qu.front);
显然,这个解不是最优解,即不是最短路径。
2、用队列求解迷宫问题
使用一个队列qu记录走过的方块,该队列的结构如下:
typedef struct
{ int i,j;
//方块的位置
int pre
//本路径中上一方块在队列中的下标
} Box;
//方块类型
typedef struct
{ Box data[MaxSize];
StType st;st.top=-1;
//定义栈st并初始化
st.top++;
//初始方块进栈
st.data[st.top].i=xi; st.data[st.top].j=yi;
st.data[st.top].di=-1; mg[xi][yi]=-1;
012 345
0
1
●
2
3
4
●
5
1 1 -1 i j di
{1, 0,0,1,0,0,0,1,0, 1},
{1, 0,0,0,0,1,1,0,0, 1},
{1, 0,1,1,1,0,0,0,0, 1},
{1, 0,0,0,1,0,0,0,0, 1},
{1, 0,1,0,0,0,1,0,0, 1},
应用栈解决迷宫问题的C语言实现

应⽤栈解决迷宫问题的C语⾔实现题⽬来⾃于严蔚敏《数据结构》,参考伪代码实现的程序:1 #include <stdio.h>2 #include <malloc.h>3//记录通道块在迷宫矩阵当中的横、纵坐标4struct Position{5int x;6int y;7 };8//放⼊栈当中的通道块元素9struct SElement {10int ord;//记录此通道块在整个通道当中的次序11 Position p;//记录此通道块在矩阵当中的位置12int di;//记录下⼀次测试这⼀路径的临近路径的位置13 };14//创建栈数据结构15#define STACK_INIT_SIZE 10016#define STACKINCREMENT 1017struct MyStack{18 SElement* base;19 SElement* top;20int stacksize;21 };22//创建⼀个栈如果创建成功则返回1,否则就返回023int InitStack(MyStack* s)24 {25 s->base=(SElement*)malloc(STACK_INIT_SIZE*sizeof(SElement));//为栈分配初始空间26if(!s->base) return0;27 s->top=s->base;//设定为空栈28 s->stacksize=STACK_INIT_SIZE;29return1;30 }31//判断栈是否为空,如果是空的就返回0,否则就返回132int IsStackEmpty(MyStack* s)33 {34if(s->top==s->base) return true;35return false;36 }37//获取栈顶元素,如果栈为空就返回0 否则就返回138int GetTop(MyStack* s,SElement* e)39 {40if(IsStackEmpty(s)) return0;41 e=s->top-1;42return1;43 }44//获取栈的长度,并且通过程序返回45int StackLength(MyStack* s)46 {47return s->top-s->base;48 }49//插⼊元素e为新的栈顶元素,插⼊成功则返回1,否则返回050int Push(MyStack* s,SElement e)51 {52if(s->top-s->base>=STACK_INIT_SIZE)53 {54 s->base=(SElement*)realloc(s->base,(s->stacksize+STACKINCREMENT)*sizeof(SElement));55if(!s->base) return0;56 s->top=s->base+s->stacksize;57 s->stacksize+=STACKINCREMENT;58 }59 *(s->top)=e;60 s->top++;61return1;62 }63//弹出栈顶元素赋值给e弹出成功返回1,弹出失败返回064int Pop(MyStack* s,SElement* e)65 {66if(IsStackEmpty(s)) return0;67 *e=*(s->top-1);68 s->top--;69return1;70 }71//定义墙元素为2 可⾛路径为0 已知路径为curStep 不能够通过的路径为-172#define MazeScale 1073int Maze[MazeScale][MazeScale]={{2,2,2,2,2,2,2,2,2,2},{2,0,0,2,0,0,0,2,0,2},{2,0,0,2,0,0,0,2,0,2},{2,0,0,0,0,2,2,0,0,2},74 {2,0,2,2,2,0,0,0,0,2},{2,0,0,0,2,0,0,0,0,2},{2,0,2,0,0,0,2,0,0,2},{2,0,2,2,2,0,2,2,0,2},{2,2,0,0,0,0,0,0,0,2},{2,2,2,2,2,2,2,2,2,2}}; 75//辅助函数考察当前路径能否通过76bool Pass(Position posi)77 {78//只有路径所在位置的数字为0的是可以⾛的79if(Maze[posi.x][posi.y]==0)80 {81return true;82 }83return false;84 }85//按顺时针⽅向从东开始寻找矩阵当中某⼀个位置的临近位置86 Position NextPosition(Position now,int direction)87 {88 Position next;89int x=now.x;90int y=now.y;91switch(direction)92 {93//东94case1:{95 next.x=x;96 next.y=y+1;97break;98 }99//南100case2:{101 next.x=x+1;102 next.y=y;103break;104 }105//西106case3:{107 next.x=x;108 next.y=y-1;109break;110 }111//北112case4:113 {114 next.x=x-1;115 next.y=y;116break;117 }118default:break;119 }120return next;121 }122//留下⾜迹123void FootPrint(Position p,int step)124 {125 Maze[p.x][p.y]=step;126 }127//路径不可⾛的话就留下-1的标记128void MarkPrint(Position p)129 {130 Maze[p.x][p.y]=-1;131 }132int main()133 {134//打印出迷宫矩阵135for(int i=0;i<MazeScale;i++)136 {137for(int j=0;j<MazeScale;j++)138 {139 printf("%d ",Maze[i][j]);140 }141 printf("\n");142 }143//迷宫程序主体144 MyStack path;//记录路径的栈145 InitStack(&path);//初始化路径数组146 Position curp;//当前被试位置147//初始化当前位置为矩阵⼊⼝148 curp.x=1;149 curp.y=1;150int curStep=1;//被探索的步数151do152 {153if(Pass(curp))154 {155 FootPrint(curp,curStep);//可⾛就在迷宫⾥⾯留下⾜迹156//创建⼀个栈元素,存储可⾏路径的相关值,将这个元素存储到栈当中157 SElement e;158 e.di=1;//意味着下⼀个被试路块为这⼀个路块的正上⽅的路块159 e.ord=curStep;160 e.p.x=curp.x;161 e.p.y=curp.y;162 Push(&path,e);//将路径块⼊栈163if(curp.x==MazeScale-2 && curp.y==MazeScale-2) break; //如果被压⼊的路径块到了迷宫的终点就退出循环164//找到下⼀个被试块165 curp=NextPosition(curp,1);//找到前⼀个被试块东⾯的路径块作为被试块166 curStep++;//被探索的步数加⼀167 }else//如果当前被试路径不能够通过的话168 {169if(!IsStackEmpty(&path))170 {171 SElement e;172 Pop(&path,&e);173 curStep--;174//将这⼀段所有的周围路径都已经被测试过的路径从栈中清除175while(e.di==4 && !IsStackEmpty(&path)){176 MarkPrint(e.p);177 Pop(&path,&e);178 curStep--;179 }180//如果当前栈顶还有未被测试的路径就测试剩余的周围路径181if(e.di<4)182 {183 curp=NextPosition(e.p,e.di+1);184 e.di++;185 curStep++;186 Push(&path,e);187 }188 }189 }190 }while(!IsStackEmpty(&path));191 printf("\n");192//打印出结果迷宫矩阵193for(int i=0;i<MazeScale;i++)194 {195for(int j=0;j<MazeScale;j++)196 {197 printf("%d ",Maze[i][j]);198 }199 printf("\n");200 }201return0;202 }。
用栈求解迷宫问题所有路径及最短路径程序c语言

用栈求解迷宫问题所有路径及最短路径程序c语言
摘要:
1.迷宫问题的背景和意义
2.栈的基本概念和原理
3.用栈解决迷宫问题的方法
4.C 语言编程实现步骤
5.程序示例及运行结果
正文:
【1.迷宫问题的背景和意义】
迷宫问题是计算机科学中的一个经典问题,它涉及到图论、数据结构和算法等多个领域。
在迷宫问题中,给定一个有向图,目标是找到从起点到终点的所有路径以及最短路径。
这个问题在现实生活中也有很多应用,例如地图导航、物流路径规划等。
【2.栈的基本概念和原理】
栈是一种线性数据结构,它遵循后进先出(LIFO)的原则。
栈可以用来存储序列中的元素,也可以用来表示函数调用关系。
栈的操作通常包括入栈、出栈、获取栈顶元素等。
【3.用栈解决迷宫问题的方法】
为了解决迷宫问题,我们可以使用栈来记录遍历过程中的路径。
具体步骤如下:
1.创建一个栈,用于存储遍历过程中的路径;
2.从起点开始,将当前节点的编号入栈;
3.遍历当前节点的所有相邻节点,如果相邻节点未被访问过,则将其入栈;
4.当栈不为空时,继续执行步骤3;否则,说明已到达终点,开始回溯,找到最短路径;
5.从栈顶弹出节点,将其添加到结果路径列表中;
6.如果栈为空,说明没有找到从起点到终点的路径;否则,返回结果路径列表。
《数据结构》上机实验报告—利用栈实现迷宫求解

《数据结构》上机实验报告—利用栈实现迷宫求解实验目的:掌握栈的基本操作和迷宫求解的算法,并能够利用栈实现迷宫求解。
实验原理:迷宫求解是一个常见的路径问题,其中最常见的方法之一是采用栈来实现。
栈是一种先进后出的数据结构,适用于这种类型的问题。
实验步骤:1.创建一个迷宫对象,并初始化迷宫地图。
2.创建一个栈对象,用于存储待探索的路径。
3.将起点入栈。
4.循环执行以下步骤,直到找到一个通向终点的路径或栈为空:a)将栈顶元素出栈,并标记为已访问。
b)检查当前位置是否为终点,若是则路径已找到,结束。
c)检查当前位置的上、下、左、右四个方向的相邻位置,若未访问过且可以通行,则将其入栈。
5.若栈为空,则迷宫中不存在通向终点的路径。
实验结果:经过多次实验,发现利用栈实现迷宫求解的算法能够较快地找到一条通向终点的路径。
在实验中,迷宫的地图可通过一个二维数组表示,其中0表示可通行的路径,1表示墙壁。
实验结果显示,该算法能够正确地找出所有可行的路径,并找到最短路径。
实验结果还显示,该算法对于大型迷宫来说,解决速度相对较慢。
实验总结:通过本次实验,我掌握了利用栈实现迷宫求解的算法。
栈作为一种先进后出的数据结构,非常适合解决一些路径的问题。
通过实现迷宫求解算法,我深入了解了栈的基本操作,并学会运用栈来解决实际问题。
此外,我还了解到迷宫求解是一个复杂度较高的问题,对于大型迷宫来说,解决时间较长。
因此,在实际应用中需要权衡算法的速度和性能。
在今后的学习中,我将进一步加深对栈的理解,并掌握其他数据结构和算法。
我还将学习更多的路径算法,以便更好地解决迷宫类问题。
掌握这些知识将有助于我解决更加复杂的问题,并提升编程能力。
数据结构设计——用栈实现迷宫问题的求解

数据结构设计——⽤栈实现迷宫问题的求解求解迷宫问题1,问题描述以⼀个m*n的长⽅阵表⽰迷宫,0和1分别表⽰迷宫中的通路和障碍。
迷宫问题要求求出从⼊⼝(1,1)到出⼝(m,n)的⼀条通路,或得出没有通路的结论。
基本要求:⾸先实现⼀个以链表作存储结构的栈类型,然后编写⼀个求迷宫问题的⾮递归程序,求得的通路,其中:(i,j)指⽰迷宫中的⼀个坐标, d表⽰⾛到下⼀坐标的⽅向。
左上⾓(1,1)为⼊⼝,右下⾓(m,n)为出⼝。
2.设计思路: ⽤栈实现迷宫问题的求解;3.实验代码:栈实现迷宫求解问题:************************************************************************************************************1//maze_stack.cpp2 #include<stdio.h>3 #include<stdlib.h>4 #include<windows.h>5 #include"seqstack.h"67#define MAX_ROW 128#define MAX_COL 14910int maze[12][14] = {111, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,121, 0, 1, 0, 0, 0, 1, 0, 1, 1, 0, 1, 1, 1,131, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 1,141, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 1,151, 0, 1, 1, 1, 0, 1, 0, 0, 0, 1, 0, 1, 1,161, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1,171, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1,181, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1,191, 0, 0, 0, 0, 1 ,0 ,0, 0 ,0 ,1 ,0 ,1 ,1,201, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 0, 1,211, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1,221, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 123 };2425void print_line()26 {27 system("cls");28 printf("迷宫如下‘■’代表墙,数字或者‘☆’表⽰路径\n");29int i, j;30for (i = 0; i < MAX_ROW; i++){31for (j = 0; j < MAX_COL; j++)32if (maze[i][j] == 1) printf("■");33else if (maze[i][j] >= 3){34 printf("%2d", maze[i][j] - 2);35/*if (i == MAX_ROW-2 && j == MAX_COL-2) printf("★");36 else printf("☆");*/37 }38else printf("");39 printf("\n");40 }41 printf("已到达出⼝...\n");42 printf("可见使⽤栈求出的路径并⾮最优路径,根据我依次探索的⽅向不同,结果也将不同\n");43 }4445void visit(mark p,int sign, PSeqStack S)46 {47 Push_SeqStack(S,p);48switch (sign)49 {50case1: p.col++; Push_SeqStack(S, p); maze[p.row][p.col] = 2; break;//向右51case2: p.row++; Push_SeqStack(S, p); maze[p.row][p.col] = 2; break;//向下52case3: p.col--; Push_SeqStack(S, p); maze[p.row][p.col] = 2; break;//向左53case4: p.row--; Push_SeqStack(S, p); maze[p.row][p.col] = 2; break;//向上54 }55 }5657int main()59struct point p = { 1, 1 };60 maze[p.row][p.col] = 2;//遍历过的点设置为261 PSeqStack S = Init_SeqStack();62 Push_SeqStack(S,p);63while (!Empty_SeqStack(S))64 {65 Pop_SeqStack(S, &p);66if (p.row == MAX_ROW - 2 && p.col == MAX_COL - 2)67break;68if (p.col + 1 < MAX_COL - 1 && maze[p.row][p.col + 1] == 0)//向右69 {70 visit(p, 1, S);71continue;72 }73if (p.row + 1 < MAX_ROW - 1 && maze[p.row + 1][p.col] == 0)//向下74 {75 visit(p, 2, S);76continue;77 }78if (p.col - 1 >= 1 && maze[p.row][p.col - 1] == 0)//向左79 {80 visit(p, 3, S);81continue;82 }83if (p.row - 1 >= 1 && maze[p.row - 1][p.col] == 0)//向上84 {85 visit(p, 4, S);86continue;87 }//以上是对迷宫的四个⽅向进⾏操作88 }89if (p.row == MAX_ROW - 2 && p.col == MAX_COL - 2)//是否为出⼝90 {91int count = GetLength_SeqStack(S)+3;//为了与迷宫0,1,2的区别所以基数要以3开始92 printf("成功找到出⼝,路径倒序输出:\n");93 printf("(%d,%d)\n", p.row, p.col);94 maze[p.row][p.col] = count;95while (!Empty_SeqStack(S))//按照前驱进⾏查找96 {97 count--;98 Pop_SeqStack(S, &p);99 maze[p.row][p.col] = count;100 printf("(%d,%d)\n", p.row, p.col);101 }102 printf("3秒后打印路径......");103 Sleep(3000);104 print_line();105 }106else {107 printf("没有出路\n");108 }109 system("pause");110return0;111 }112//end maze_stack.cpp************************************************************************************************************* 1//seqstack.h2 #include<stdio.h>3 #include<stdlib.h>4#define MAXSIZE 10056 typedef struct point{7int row, col;8 }mark;910 typedef mark DataType;1112 typedef struct {13 DataType data[MAXSIZE];14int top;15 }SeqStack, * PSeqStack;1617 PSeqStack Init_SeqStack (void)18 {19 PSeqStack S;20 S = (PSeqStack)malloc(sizeof(SeqStack));21if (S)22 S->top = -1;23else24 exit(-1);25return S;26 }28int Empty_SeqStack(PSeqStack S)29 {30//return (S->top==-1);31if (S->top == -1)32return1;33else34return0;35 }3637int Push_SeqStack(PSeqStack S,DataType x)38 {39if (S->top == MAXSIZE - 1)40 {41 printf("栈满不能⼊栈\n");42return0;43 }44else45 {46 S->top++;47 S->data[S->top] = x;48return1;49 }50 }5152int Pop_SeqStack(PSeqStack S,DataType *x)53 {54if(Empty_SeqStack(S))55return0;56else57 {58 *x = S->data[S->top];59 S->top--;60return1;61 }62 }6364int GetTop_SeqStack(PSeqStack S ,DataType *x) 65 {66if(Empty_SeqStack(S))67return0;68else69 {70 *x = S->data[S->top];71return1;72 }73 }74int GetLength_SeqStack(PSeqStack S)75 {76return S->top + 1;77 }7879void Distory_SeqStack(PSeqStack *S)80 {81if(*S)82free(*S);83 *S = NULL;84 }//end seqstack.h4.运⾏结果:栈求解迷宫:。
利用栈实现迷宫求解

利用栈实现迷宫的求解
一、要解决的四个问题:
1、表示迷宫的数据结构:
设迷宫为 m 行 n 列,利用 maze[m][n]来表示一个迷宫,maze[i][j]=0 或 1; 其中:0 表示 通路,1 表示不通,当从某点向下试探时,中间点有 4 个方向可以试探,(见图)而四个角 点有 2 个方向,其它边缘点有 3 个方向,为使问题简单化我们用 maze[m+2][n+2]来表示迷 宫,而迷宫的四周的值全部为 1。这样做使问题简单了,每个点的试探方向全部为 4,不用 再判断当前点的试探方向有几个,同时与迷宫周围是墙壁这一实际问题相一致。
Push_SeqStack ( s, temp ) ; x=i ; y=j ; maze[x][y]= -1 ; if (x= =m&&y= =n) return 1 ; /*迷宫有路*/ else d=0 ; } else d++ ; } /*while (d<4)*/ } /*while (! Empty_SeqStack (s ) )*/ return 0 ;/*迷宫无路*/ } 栈中保存的就是一条迷宫的通路。
素有两个域组成,x:横坐标增量,y:纵坐标增量。Move 数组如图 3 所示。 move 数组定义如下: typedef struct { int x ; //行 int y ; //列 } item ; item move[4] ; 这样对 move 的设计会很方便地求出从某点 (x,y) 按某一方法思想如下:
(1) 栈初始化; (2) 将入口点坐标及到达该点的方向(设为-1)入栈 (3) while (栈不空)
用栈方法解决迷宫问题

pastack->t--;
}
/*当pastack所指的栈不为空栈时,求栈顶元素的值*/
DataType top_seq( PSeqStack pastack ) {
return (pastack->s[pastack->t]);
}
void pushtostack(PSeqStack st, int x, int y, int d) {
1,0,0,0,0,0,1,0,0,1,1,
1,0,1,1,1,0,0,0,1,1,1,
1,0,0,0,1,0,1,1,0,1,1,
1,1,0,0,1,0,1,1,0,0,1,
1,1,1,0,0,0,0,0,0,0,1,
1,1,1,1,1,1,1,1,1,1,1
};
mazePath(maze,direction,1,1,6,9);
getchar();
return 0;
}
while(!isEmptyStack_seq(st)) {
element = top_seq(Leabharlann t);pop_seq(st);
printf("the node is: %d %d \n", element.x, element.y);
}
}
/*迷宫maze[M][N]中求从入口maze[x1][y1]到出口maze[x2][y2]的一条路径*/
#include <stdio.h>
#include <stdlib.h>
typedef struct {
int x;/*行下标*/
int y;/*列下标*/
int d;/*运动方向*/
栈和队列的应用――迷宫问题 实验样本

南昌航空工业学院实验报告课程名称:数据结构实验名称:实验三、四:栈和队列的应用――迷宫问题班级: 080611 学生姓名:赖凌学号: 08061101指导教师评定:签名:题目:假设迷宫由m行n列构成,有一个入口和一个出口,入口坐标为(1,1),出口坐标为(m,n),试找出一条从入口通往出口的最短路径。
设计算法并编程输出一条通过迷宫的最短路径或报告一个“无法通过”的信息。
要求:用栈和队列实现,不允许使用递归算法。
一、需求分析⒈用栈的基本操作完成迷宫问题的求解,其中栈的基本操作作为一个独立的模块存在。
⒉以二维数组b[m][n]表示迷宫,b[i][j] 表示迷宫中相应(i,j)位置的通行状态(0:表示可以通行,1:表示有墙,不可通行),完成迷宫的抽象数据类型,包括出口、入口位置等。
⒊程序中完成对应迷宫的初始化。
⒋迷宫的入口位置和出口位置在合法范围内由用户而定。
⒌程序完成对迷宫路径的搜索,如果存在路径,则输出走出迷宫的路径。
⒍程序执行的命令:⑴创建初始化迷宫;⑵搜索迷宫;⑶输出搜索结果。
二、概要设计⒈设计栈的抽象数据类型定义:ADT Stack {数据对象:D={a i:|a i∈PositionSet,i=1…n,n≥0}数据关系:R1={<a i-1,a i>|a i-1,a i∈d,i=2,…n}基本操作:操作结果InitStack(&S) 构造一个空栈,完成栈的初始化SDestoryStack(&S) 撤消一个已经存在的栈SClearStack(&S) 将栈S重新置空StackLength(S) 返回栈的长度GetTop(S,&e) 用e返回栈S的栈顶元素StackEmpty(S) 若S为空返回1,否则返回0Push(&S,e) 将新的元素e压入栈顶Pop(&S,e) 删除栈顶元素,并用e返回其值StackTraverse(s) 将栈S的所有元素输出}ADT Stack;⒉迷宫的抽象数据类型定义:ADT Maze{数据对象:D:={a ij,Start,end|a ij,Start,end∈{} 0≤i≤m+2,0≤j≤n+2,m,n≥0}数据关系:R={ROW.COL}Row={<a i-1j,a ij>|a i-1,a ij∈D i=1,…,m+2,j=1,…,n+2}Col={<a ij-1,a ij>|a ij a ij-1∈D}基本操作:SetMaze(&Maze)初始条件:Maze已经定义,Maze的下属单元二维数组Maze.M[row+2][d+2]已存在,Maze.start,Maze.end也已作为下属存储单元存在操作结果:构成数据迷宫,用数值标识迷宫的物理状态,以0表示通路,以1表示障碍,由终端读取迷宫空间大小,各点处的具体物理状态及Start和End点位置,完成迷宫构建Pass(&Mazem,&Nposition,Position,di)初始条件:已知目前迷宫状态及当前位置、下一步探索方向di操作结果:完成相应的搜索任务,如果可行,则用Nposition返回下一步位置,并将Maze状态改变为相应点已走过情况PrintMaze(Maze)操作结果:输出字符标示的迷宫FindWay(Maze,&way)操作结果:利用Pass搜索迷宫,用way返回搜索所得路径。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
基于栈实现的迷宫问题1、问题描述:在一个二维阵列构成的迷宫里, 数组元素仅有0和1构成,其中0表示可通行的路径, 1代表障碍。
另外,定义左上角是迷宫的入口, 右下角是迷宫的出口, 在迷宫里面只允许上下左右四个方向行走,请找出一条通路。
2、算法基本思想:由于计算机解迷宫时,通常用的是“穷举求解”的方法,即从入口出发,顺某一方向向前探索,若能走通,则继续往前走;否则沿原路退回,换一个方向再继续探索,直至所有可能的通路都探索到为止。
为了保证在任何位置上都能沿原路退回,显然需要用一个后进先出的结构来保存从入口到当前位置的路径。
因此,在求迷宫通路的算法中采用“栈”进行求解。
2.1、迷宫构建:为了避免每走一步便需判断是否走出迷宫的麻烦,将所创建的迷宫用1包围起来。
2.2、位置搜索:每到一处,总让它按上、下、左、右4个方向试探下一个位置;如果某方向可以通过,即该方向上的元素为0,则前进一步,并在新位置上继续进行搜索;如果4个方向都走不通或曾经走过,则后退一步,在原来的位置上继续试探下一位置。
每前进一步,都要进行判断:若前进到了出口处,则说明找到了一条通路;若退回到了入口处,则说明不存在通路。
3、算法运行环境:VC++6.04、主要函数:Mazepath函数:求解迷宫maze中,从入口start到出口end的一条路径若存在,返回TRUE,否则返回FALSEInitMaze函数:创建初始矩阵按照用户输入的数据构建0/1矩阵,并在矩阵四周添加一圈1作为围墙。
Pass函数:判断当前节点能否通过。
FootPrint函数:对于走过的节点用'*' 进行标记。
MarkPrint函数:对于不能通过的节点用'#' 进行标记。
Nextpos函数;返回当前节点的下一结点,对应东、西、南、北四个方向。
Printmaze 函数:打印迷宫信息,存在的通路用'*' 表示。
5、算法举例:5.1、输入的矩阵:运行结果:5.2、输入的矩阵:运行结果:没有找到通路6、算法复杂度分析:(n为迷宫的行数,m为迷宫的列数)走迷宫的时间复杂度:O(n*m*2)。
附迷宫问题源程序//base.h#include<stdio.h>#include <malloc.h>#include <stdlib.h>#include <string.h>//函数结果状态代码#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2//函数的返回值typedef int Status;//下一个通道方向typedef int DirectiveType;//stack.h//迷宫大小#define RANGE 100#define STACK_INIT_SIZE 100#define STACKINCREMENT 10//------------ 栈的顺序存储实现------------------------------typedef struct{int row;int col;}PosType;typedef struct{int step; //当前位置在路径上的\"序号\"PosType seat; //当前的坐标位置DirectiveType di; //往下一个坐标位置的方向}SElemType;typedef struct{ SElemType *base;SElemType *top;int stacksize;}SqStack;//----------------- 栈的基本操作的算法实现-------------------------------- Status InitStack(SqStack &s){s.base = (SElemType * ) malloc(STACK_INIT_SIZE * sizeof(SElemType)); if(!s.base)exit(OVERFLOW);s.top=s.base;s.stacksize=STACK_INIT_SIZE;return OK;}Status GetTop(SqStack s, SElemType &e ){if( s.top == s.base)return ERROR;e = *(s.top-1);return OK;}Status Push(SqStack &s, SElemType e){if(s.top-s.base >= s.stacksize){ //栈满,追加存储空间s.base = (SElemType*)realloc(s.base,(s.stacksize+STACKINCREMENT)*sizeof(SElemType));if(!s.base)exit(OVERFLOW);s.top = s.base + s.stacksize;s.stacksize += STACKINCREMENT;}*s.top++ = e;return OK;}Status Pop(SqStack &s, SElemType &e){if(s.top==s.base)return ERROR;e = * --s.top;return OK;}int StackEmpty(SqStack s){return s.base == s.top;}Status ClearStack(SqStack &s){s.top = s.base;return OK;}//maze.h#define ROW 9 //迷宫的行数#define COL 8 //迷宫的列数typedef struct{int m,n;int arr[RANGE][RANGE];}MazeType; //迷宫类型Status InitMaze(MazeType &maze, int a[][COL], int row, int col) {//按照用户输入的row行和col列的二维数组(0/1)//设置迷宫maze的初值,包括加上边缘一圈的值for(int i=1;i<=row;i++){for(int j=1;j<=col;j++){maze.arr[i][j] = a[i-1][j-1];}}//加上围墙for(int j=0;j<=col+1;j++){maze.arr[0][j] = maze.arr[row+1][j]=1;}for(i=0;i<=row+1;i++){maze.arr[i][0] = maze.arr[i][col+1]=1;}maze.m = row, maze.n = col;return OK;}Status Pass(MazeType maze,PosType curpos){//判断当前节点是否通过return maze.arr[curpos.row][curpos.col] == 0;}Status FootPrint(MazeType &maze,PosType curpos) {//留下足迹maze.arr[curpos.row][curpos.col]='*';return OK;}Status MarkPrint(MazeType &maze,PosType curpos) {//留下不能通过的标记maze.arr[curpos.row][curpos.col]='#';return OK;}SElemType CreateSElem(int step, PosType pos, int di) {SElemType e;e.step = step;e.seat = pos;e.di = di;return e;}PosType NextPos(PosType curpos, DirectiveType di) { //返回当前节点的下一节点PosType pos = curpos;switch(di){case 1: //东pos.col++; break;case 2: //南pos.row++; break;case 3: //西pos.col--; break;case 4: //北pos.row--; break;}return pos;}void PrintMaze(MazeType maze,int row,int col){//打印迷宫信息for(int i=1;i<=row;i++){for(int j=1;j<=col;j++){switch(maze.arr[i][j]){case 0:printf(" "); break;case '*':printf("*"); break;case '#':printf("#"); break;case 1:printf("#"); break;}}printf("\n");}}Status MazePath(MazeType &maze,PosType start, PosType end,PosType *a,int *m) { //求解迷宫maze中,从入口start到出口end的一条路径//若存在,返回TRUE,否则返回FALSESqStack s;SElemType e;InitStack(s);PosType curpos = start;int curstep = 1;//探索第一部do{if( Pass(maze,curpos) ){//如果当前位置可以通过,即是未曾走到的通道块FootPrint(maze,curpos); //留下足迹e = CreateSElem(curstep,curpos,1); //创建元素Push(s,e);a[*m].row=curpos.row;a[*m].col=curpos.col;++(*m); //将该元素的的行号和列号存入数组中,并通过指针path返回if( curpos.row==end.row && curpos.col==end.col )return TRUE;else{curpos =NextPos(curpos,1); //获得下一节点:当前位置的东邻curstep++; //探索下一步}}else{//当前位置不能通过if(!StackEmpty(s)){Pop(s,e);while(e.di==4 && !StackEmpty(s) ){MarkPrint(maze,e.seat);Pop(s,e);curstep--; //留下不能通过的标记,并退回一步--(*m); //数组序号减1,该元素被删除。