基于栈的c语言迷宫问题与实现 (2)

合集下载

用C语言解决迷宫问题

⽤C语⾔解决迷宫问题#include <stdio.h>#include <stdlib.h>#define ROW 10#define COL 10/*迷宫中位置信息*/typedef struct position{int x;int y;}position;/*在迷宫中的当前位置的信息，也是⼊栈的基本元素*/typedef struct SElem{int di;position seat;}SElem;/*链式栈中节点的定义*/typedef struct position_stack{SElem p;struct position_stack *next;}*Stack_pNode,Stack_Node;void InitStack(Stack_pNode *Link){*Link = NULL;}void push(Stack_pNode *Link,SElem e){Stack_pNode new_SElem = (Stack_pNode)calloc(1,sizeof(Stack_Node));new_SElem->p = e;new_SElem->next = NULL;if (*Link == NULL)*Link = new_SElem;else{new_SElem->next = *Link;*Link = new_SElem;}}int pop(Stack_pNode *Link,SElem *e){if (*Link == NULL)return 0;*e = (*Link)->p;Stack_pNode q = *Link;*Link = (*Link)->next;free(q);return 1;}int top(Stack_pNode Link, SElem *e){if (Link == NULL)return 0;*e = Link->p;return 1;}int empty(Stack_pNode Link){if (Link == NULL)return 1;elsereturn 0;}int reverse(Stack_pNode *Link){Stack_pNode p, q, r;if (*Link == NULL || (*Link)->next == NULL)return 0;r = *Link;p = (*Link)->next;q = NULL;while (p){r->next = q;q = r;r = p;p = p->next;}r->next = q;*Link = r;}void print(Stack_pNode Link){Stack_pNode r = Link;while (r){printf("(%d,%d) -> ",r->p.seat.x,r->p.seat.y);r = r->next;}printf("exit\n");}int curstep = 1;/*纪录当前的⾜迹，填写在探索前进的每⼀步正确的路上*//*迷宫地图。

C语言实现数据结构迷宫实验

C语⾔实现数据结构迷宫实验本⽂实例为⼤家分享了C语⾔实现简单的数据结构迷宫实验，供⼤家参考，具体内容如下分析：迷宫实验主要有两部分操作，其⼀是对迷宫的⽣成，其⼆是寻路使⽤栈的操作。

步骤：⼀、.h⽂件1、⾸先是迷宫的⽣成，可以使⽤随机数种⼦⽣成，但主要逻辑部分并不在此，所以在这⾥直接写死，固定下来。

定义⼀个坐标类型的结构体，和⼆维数组迷宫：typedef struct {int x;int y;}Pos;//迷宫类型typedef struct {int square[10][10] ={{1,1,1,1,1,1,1,1,1,1},{1,0,0,0,0,0,0,0,0,1},{1,1,1,1,0,1,1,1,0,1},{1,0,0,0,0,1,0,1,0,1},{1,0,1,1,1,1,0,1,1,1},{1,0,0,0,0,1,0,0,0,1},{1,0,1,1,0,0,0,1,0,1},{1,0,1,1,1,0,1,1,1,1},{1,0,0,0,1,0,0,0,0,1},{1,1,1,1,1,1,1,1,1,1},};}Maze;typedef Pos SElemType;2、然后是对栈的声明，栈⾥储存的元素为坐标类型//顺序栈#define MAXSIZE 50typedef struct {SElemType *base;SElemType *top; //栈顶指针int stacksize;}SqStack;3、栈操作函数声明typedef int Status;#define OK 1;#define ERROR 0;//栈的相关操作//初始化栈Status initStack(SqStack &s);//压栈Status push(SqStack &s, SElemType e);//出栈SElemType pop(SqStack &s);//清空栈Status clearStack(SqStack &s);//摧毁栈void destroyStack(SqStack &s);//遍历栈Status stackTravel(SqStack s);4、迷宫操作函数声明//初始化迷宫(同时⽣成起始点和终点)void initMaze(Maze &maze);//寻找出路；传⼊⼀个迷宫和栈找出出路void findWay(Maze &maze,SqStack &s);//判断该点的四个⽅向是否有通路，有就前进Pos isExit(Pos p, Maze maze);⼆、.cpp⽂件1、导⼊所需头⽂件#include "pch.h"#include <iostream>#include<time.h>#include<stdlib.h>using namespace std;2、栈操作实现//构造空栈Status initStack(SqStack &s) {s.base = new SElemType[MAXSIZE];if (!s.base){exit(OVERFLOW);//分配失败}s.top = s.base;s.stacksize = MAXSIZE;return OK;}//⼊栈Status push(SqStack &s, SElemType e) {//判断栈满if (s.top-s.base == s.stacksize){return ERROR;}//存⼊元素,*为取指针的值s.top++;*s.top = e;return OK;}//出栈,⽤e返回栈顶值SElemType pop(SqStack &s) {SElemType e;//判断栈为空if (s.top == s.base){//若为空则返回⼀个（-1，-1）的点，判断由外部调⽤时进⾏ e.x = -1;e.y = -1;return e;}e = *s.top;s.top--;return e;}Status clearStack(SqStack &s) {s.top = s.base;return OK;}void destroyStack(SqStack &s) {s.top = NULL;s.stacksize = 0;free(s.base);}Status stackTravel(SqStack s) {while (s.top != s.base){s.base++;Pos p = *s.base;if ( p.x == 0 || p.y == 0|| p.x == 9 ||p.y == 9){//终点输出为“End”cout << "End";}}cout << endl;return 0;}3、迷宫操作实现///////////////////////////////////////迷宫操作//////////////////////////////////初始化函数，传⼊⼀个迷宫，随机⽣成起点和终点，由于起点有⼀定限制，所以这⾥起点也固定为⼏个最合适的点void initMaze(Maze &maze) {//⽣成随机数srand((unsigned)time(NULL));int index = rand() % 36 + 1;int start = index % 6 + 1;//⽣成起始点数值为‘s'switch (start){case 1:maze.square[1][1] = 's';break;case 2:maze.square[3][8] = 's';break;case 3:maze.square[3][6] = 's';break;case 4:maze.square[6][8] = 's';break;case 5:maze.square[8][3] = 's';break;case 6:maze.square[8][8] = 's';break;}//随机⽣成终点'e'表⽰while (index = rand()%36+1){//出⼝在顶部if (index >1 &&index<10 && maze.square[1][index-1]!='s'){maze.square[0][index-1] = 'e';break;}//出⼝在右侧else if (index>10 &&index <19){if (maze.square[index-10][8] != 1 && maze.square[index-10][8]!='s') {maze.square[index-10][9] = 'e';break;}}//底部出⼝else if (index >19&&index<28){if (maze.square[8][index - 19] != 's' && maze.square[8][index - 19] != 1) {maze.square[9][index - 19] = 'e';break;}}//左侧出⼝else if (index >28 && index <=36){if (maze.square[index-28][1] != 1 &&maze.square[index-28][1] != 's'){maze.square[index - 28][0] = 'e';break;}}}void showMaze(Maze maze) {for (int i = 0; i < 10; i++){for (int j = 0; j < 10; j++){if (maze.square[i][j] == 1){cout << "* ";}else if (maze.square[i][j] == 0){cout << " ";}else{cout << (char)maze.square[i][j]<<" ";}}cout << endl;}}//寻找迷宫路径void findWay(Maze &maze,SqStack &s) {//⾸先遍历找出起始点和终点并保存下来Pos start,end;for (int i = 0; i < 10; i++){for (int j = 0; j < 10; j++) {if (maze.square[i][j] == 's'){ //起点压⼊栈内start.x = i;start.y = j;push(s, start);}else if (maze.square[i][j] == 'e'){ //出⼝end.x = i;end.y = j;}}}//寻找路径Pos go = start;//直到找到出⼝才结束while ( s.top->x != end.x || s.top->y != end.y){//获得下⼀步坐标Pos path = isExit(go, maze);if (path.x != go.x || path.y != go.y){//前进maze.square[path.x][path.y] = 'p';push(s, path);go = path;}//如果所有放向都⾛不通（即返回的点是传⼊的点），则将其标为“@”，出栈到上⼀个点，继续判断else{//⾛不通popmaze.square[path.x][path.y] = '@';pop(s);go = *s.top;}}maze.square[end.x][end.y] = 'e';}//判断返回下⼀步路径（顺序：右下左上），传⼊所处位置，从右边开始判断是否⼜通路或者出⼝，有就返回哪个⽅向上的点Pos isExit(Pos p,Maze maze) {Pos tempP = p;if (maze.square[tempP.x][tempP.y+1] == 0 || maze.square[tempP.x][tempP.y + 1] == 'e'){tempP.y++;else if(maze.square[tempP.x+1][tempP.y] == 0 || maze.square[tempP.x +1][tempP.y] == 'e'){tempP.x++;}else if (maze.square[tempP.x][tempP.y - 1] == 0 || maze.square[tempP.x][tempP.y - 1] == 'e'){tempP.y--;}else if (maze.square[tempP.x - 1][tempP.y] == 0 || maze.square[tempP.x - 1][tempP.y] == 'e'){tempP.x--;}return tempP;}三、main函数调⽤int main(){while (true){//创建⼀个迷宫Maze maze;initMaze(maze);//初始化⼀个栈SqStack S;initStack(S);cout << "*****************************" << endl;cout << "* 1、⽣成迷宫 2、退出 *" << endl;cout << "*****************************" << endl;cout << "请输⼊你的选择：";int select = 0;cin >> select;if (select == 1){cout << "⽣成随机起点和出⼝迷宫：" << endl;showMaze(maze);cout << "⽣成迷宫路径：" << endl;findWay(maze, S);stackTravel(S);showMaze(maze);cout << endl;}if (select == 2){clearStack(S);break;}}return 0;}四、评价这是个叫简易的迷宫，但基本实现了迷宫的寻路逻辑，可改进的地⽅有：1、因为很多地⽅写死了，所以复⽤性不⾼，可以⽤循环遍历来随机⽣成起点，同理迷宫的⽣成也是这样2、判断路径可以⽤递归调⽤实现前进逻辑以上就是本⽂的全部内容，希望对⼤家的学习有所帮助，也希望⼤家多多⽀持。

用栈方法、队列方法求解迷宫问题

目录1 前言 ................................................ 1.2 需求分析 ............................................ 1..2.1 课程设计目的 ................................. 1.2.2课程设计任务 ................................. 1.2.3 设计环境 ..................................... 1.. 3 概要设计 ............................................ 1..3.1数据结构设计 ................................. 1.3.2 模块设计 ..................................... 2.. 4 详细设计 ............................................ 3..5 测试分析6 课程设计总结参考文献 ............................................. 8 .........4．1 数据类型的定义 ................. 错误. ！未定义书签 4．2 主要模块的算法描述 ............ 错误！未定义书签 .6.. 7.. 附录（程序代码实现）............................................ 9 ....致谢................................................ 8......... 1前言设计一个简单迷宫程序，从入口出发，按某一方向向前探索，若能走通（未走过的），即某处可以到达，则到达新点，否则试探下一方向；若所有方向均没有通路，则沿原点返回前一点，换下一个方向在继续试探，直到所有可能的通路都探索到，或找到一条通路，或无路可走又返回到入口点。

C语言实验：迷宫问题（搜索，C语言实现栈、队列）

C语⾔实验：迷宫问题（搜索，C语⾔实现栈、队列）Description给定迷宫起点和终点，寻找⼀条从起点到终点的路径。

(0,1)(2,0)起点(1,1)(1,2)(1,3)(1,4)(2,0)(2,1)(2,4)(3,0)(3,1)(3,2)终点（3,4）(4,1)上图中黄⾊代表墙，⽩⾊代表通路，起点为(1,1)，终点为(3,4)。

要求搜寻策略是从起点开始按照“上、下、左、右”四个⽅向寻找终点，到下⼀个点继续按照“上、下、左、右”四个⽅⾯寻找，当该结点四个⽅向都搜寻完，但还没到终点时，退回到上⼀个点，直到找到终点或者没有路径。

⽐如上图从(1,1)开始，向上(0,1)不通，向下到(2,1)；到了(2,1)后继续按“上、下、左、右”四个⽅⾯寻找，上已经⾛过，向下到(3,1)；到(3,1)后上已经⾛过，下和左不通，向右到(3,2)；到(3,2)四个⽅⾯都不通，回到(3,1)四个⽅向都不通，再回到(2,1),(1,1)；到达(1,1)后下已经⾛过，左不通，继续向右⾛，重复这个过程最后到达(3,4)。

Input第⼀⾏两个数m和n表⽰迷宫的⾏数和列数。

迷宫⼤⼩不超过100×100第⼆⾏四个数x1,y1,x2,y2分别表⽰起点和终点的坐标。

接下来是m⾏n列的数，⽤来表⽰迷宫，1表⽰墙，0表⽰通路。

Output从起点到终点所经过的路径的坐标。

如果不存在这样的路径则输出“No Path!”。

Sample Input5 61 1 3 41 1 1 1 1 11 0 0 0 0 11 0 1 1 0 11 0 0 1 0 11 1 1 1 1 1Sample Output(1 1)(1 2)(1 3)(1 4)(2 4)(3 4)1.思路：（1）若当前点是终点，dfs函数返回1；（2）若不是终点，将此点标记为1，对该点4个⽅向进⾏搜索，实现⽅式为定义int dir[4][2] = { {-1, 0}, {1, 0}, {0, -1}, {0, 1} }; 通过⼀个⼩循环： for(int i = 0; i < 4; i++) {　 position nextp; nextp.x = dir[i][0] + now.x;nextp.y = dir[i][1] + now.y;...... }　进⾏搜索；若该点的下⼀个点nextp不是墙，未⾛，并且没有超界则将nextp压⼊栈中，递归调⽤dfs，若此过程经过（1）判断返回了1，说明最终找到了通往终点的路，便可以返回1，结束函数，此时栈中已储存了通往终点的路径，若没有通路，则弹出栈顶元素，根据递归原理该路径上的所有点都会弹出并标记未⾛，回溯到之前的点，继续向其他⽅向搜索，直到找到终点或遍历完整个图。

用栈解决迷宫问题

⽤栈解决迷宫问题⼀、因为栈是后进先出的特性，所以说⼀般⽤栈都是通过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。

基于栈的应用实现解决迷宫问题论文

基于栈的应用实现解决迷宫问题论文数据结构与算法姓名：赵庶林学院及专业：航天自动化班级：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、问题描述：在一个二维阵列构成的迷宫里, 数组元素仅有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)。

顺序栈和迷宫求解（C语言）

顺序栈和迷宫求解（C语⾔）顺序栈根据《数据结构》书中的讲解，对顺序栈的⼀个基本实现。

define.h1// define.h2 #ifndef __MENGQL_DEFINE__3#define __MENGQL_DEFINE__45#define C_LOG_DBG(format, ...)6//printf("[%s@%s,%d] " format ,__FUNCTION__, __FILE__, __LINE__, ##__VA_ARGS__);7#define C_LOG_ERR(format, ...) printf("[%s@%s,%d] " format ,__FUNCTION__, __FILE__, __LINE__, ##__VA_ARGS__);8 typedef enum EStatus {ERROR, OK} Status;910#endifSqStack.h1// SqStack.h2 #ifndef __SQ_STACK_H__3#define __SQ_STACK_H__4 #include "define.h"56 typedef struct7 {8int x;9int y;10 }PosType;1112 typedef struct13 {14int ord;15 PosType seat;16int di;17 }SElemType;1819#define STACK_INIT_SIZE 10020 typedef struct21 {22 SElemType* base;23 SElemType* top;24int stacksize;25 }SqStack;2627extern Status InitStack(SqStack *S);28extern Status GetTopStack(SqStack S, SElemType *e);29extern Status PushStack(SqStack *S, SElemType e);30extern Status PopStack(SqStack *S, SElemType *e);31extern Status StackEmpty(SqStack *S);32extern Status DestoryStack(SqStack *S);33#endifSqStack.c1// SqStack.c2 #include "define.h"3 #include "SqStack.h"4 #include <stdlib.h>5 #include <stdio.h>6 Status InitStack(SqStack *S)7 {8 S->stacksize = STACK_INIT_SIZE;9 S->base = (SElemType *)malloc(S->stacksize * sizeof(SElemType));10if(S->base == NULL)11 {12 C_LOG_ERR("%s\n","MALLOC OVERFLOW");13return ERROR;14 }15 S->top = S->base;1617return OK;18 }19 Status GetTopStack(SqStack S, SElemType *e)20 {21if(S.top == S.base)22 {23 C_LOG_ERR("%s\n","STACK IS EMPTY");24return ERROR;25 }26 *e = *(S.top-1);27return OK;28 }29 Status PushStack(SqStack *S, SElemType e)30 {31if(S->top - S->base >= S->stacksize)32 {33 S->base = (SElemType *)realloc(S->base, (S->stacksize * 2) * sizeof(SElemType)); 34if(S->base == NULL)35 {36 C_LOG_ERR("%s\n","REMALLOC OVERFLOW");37return ERROR;38 }39 S->stacksize *= 2;40 }41 *(S->top++) = e;42return OK;43 }44 Status PopStack(SqStack *S, SElemType *e)45 {46if(S->top == S->base)47 {48 C_LOG_ERR("%s\n","STACK IS EMPTY");49return ERROR;50 }51 *e = *(--S->top);52return OK;53 }54 Status StackEmpty(SqStack *S)55 {56if(S->top == S->base)57 {58return OK;59 }60return ERROR;61 }62 Status DestoryStack(SqStack *S)63 {64 S->stacksize = 0;65 free(S->base);66 S->top = S->base = NULL;67return OK;68 }迷宫求解顺序栈实现的迷宫求解是深度优先搜索，得出的路径是⾮最短路径。

3.3_栈的应用--迷宫求解

程序流程图
开始
构建迷宫迷宫求解
打印路径结束
迷宫算法
通畅,则记录该点到栈中,并判断是为终点,不为终点的话,继续前行探索判断当前结点是否通畅
设置访问东邻居开始,若其不通,换方向探路
邻居访问遍,均不通,退出此结点,取当前栈顶的未访问邻居探路
不通畅,则后退,换方向访问, 到栈空结束
总结:对于一个入栈的节点要记录其位置(x,y),同时记录其探索邻居的方向di(1,2,3,4)记录四个邻居同时对于已经退出的节点标记无需标记其”不通”,只要沿下一个方向转圈就可.
迷宫的分析

迷宫设置为一个2维数组，通路为1，不通为0，但是四周为屏障设置一个栈来存储迷宫的路径：记录每个位置的坐标值（x,y),同时将纳入栈中的路径，记录它来自何方，也就是记录它的探测方向编号（东，南，西，北类似于地图的指示，1，2，3，4）通的话就入栈操作：（x,y,di) 探测当前坐标位置的所有邻居均不通：出栈，打上脚印，此路不通，不再加入再对栈顶重新探测寻求新的邻居入栈直到达到迷宫出口（有解）或退回到原路的入口（无解）
注意问题
4．注意调试过程中的问题记录，以提高程序调试的能力 5．调试过程中遇到死循环可用Ctrl+C或 Ctrl+Break退出。
实验结果
不同的算法会产生不同的结果。
若栈不空但栈顶位置的四周均不可通，则｛删去栈顶位置；// 从路径中删去该通道块若栈不空，则重新测试新的栈顶位置，直至找到一个可通的相邻块或出栈至栈空；｝若栈空，则表明迷宫没有通路。
实验内容
一个m×n的迷宫，0：畅通，1：障碍，设计一个程序，对任意设定的迷宫，求出从入口到出口的通路。入口：1 1；出口：6 8 0 1 0 1 1 0 1 1 1 0 0 1 1 0 1 0 0 1 1 0 0 1 1 1 1 0 0 1 1 0 0 1 1 1 0 0 1 1 0 1 0 1 1 1 0 0 0 0

c语言实现迷宫问题

数据结构试验——迷宫问题（一）基本问题1.问题描述这是心理学中的一个经典问题。

心理学家把一只老鼠从一个无顶盖的大盒子的入口处放入，让老鼠自行找到出口出来。

迷宫中设置很多障碍阻止老鼠前行，迷宫唯一的出口处放有一块奶酪，吸引老鼠找到出口。

简而言之，迷宫问题是解决从布置了许多障碍的通道中寻找出路的问题。

本题设置的迷宫如图1所示。

入口出口图1 迷宫示意图迷宫四周设为墙；无填充处，为可通处。

设每个点有四个可通方向，分别为东、南、西、北(为了清晰，以下称“上下左右”)。

左上角为入口。

右下角为出口。

迷宫有一个入口，一个出口。

设计程序求解迷宫的一条通路。

2.数据结构设计以一个m×n的数组mg表示迷宫，每个元素表示一个方块状态，数组元素0和1分别表示迷宫中的通路和障碍。

迷宫四周为墙，对应的迷宫数组的边界元素均为1。

根据题目中的数据，设置一个数组mg如下int mg[M+2][N+2]={{1,1,1,1,1,1,1,1},{1,0,0,1,0,0,0,1},{1,1,0,0,0,1,1,1},{1,0,0,1,0,0,0,1},{1,0,0,0,0,0,0,1},{1,1,1,1,1,1,1,1}};在算法中用到的栈采用顺序存储结构，将栈定义为Struct{ int i; //当前方块的行号int j; //当前方块的列号int di; //di是下一个相邻的可走的方位号}st[MaxSize];// 定义栈int top=-1 //初始化栈3设计运算算法要寻找一条通过迷宫的路径，就必须进行试探性搜索，只要有路可走就前进一步，无路可进，换一个方向进行尝试；当所有方向均不可走时，则沿原路退回一步（称为回溯），重新选择未走过可走的路，如此继续，直至到达出口或返回入口（没有通路）。

在探索前进路径时，需要将搜索的踪迹记录下来，以便走不通时，可沿原路返回到前一个点换一个方向再进行新的探索。

后退的尝试路径与前进路径正好相反，因此可以借用一个栈来记录前进路径。

用栈求解迷宫问题所有路径及最短路径程序c语言

用栈求解迷宫问题所有路径及最短路径程序c语言
摘要：
1.迷宫问题的背景和意义
2.栈的基本概念和原理
3.用栈解决迷宫问题的方法
4.C 语言编程实现步骤
5.程序示例及运行结果
正文：
【1.迷宫问题的背景和意义】
迷宫问题是计算机科学中的一个经典问题，它涉及到图论、数据结构和算法等多个领域。

在迷宫问题中，给定一个有向图，目标是找到从起点到终点的所有路径以及最短路径。

这个问题在现实生活中也有很多应用，例如地图导航、物流路径规划等。

【2.栈的基本概念和原理】
栈是一种线性数据结构，它遵循后进先出（LIFO）的原则。

栈可以用来存储序列中的元素，也可以用来表示函数调用关系。

栈的操作通常包括入栈、出栈、获取栈顶元素等。

【3.用栈解决迷宫问题的方法】
为了解决迷宫问题，我们可以使用栈来记录遍历过程中的路径。

具体步骤如下：
1.创建一个栈，用于存储遍历过程中的路径；
2.从起点开始，将当前节点的编号入栈；
3.遍历当前节点的所有相邻节点，如果相邻节点未被访问过，则将其入栈；
4.当栈不为空时，继续执行步骤3；否则，说明已到达终点，开始回溯，找到最短路径；
5.从栈顶弹出节点，将其添加到结果路径列表中；
6.如果栈为空，说明没有找到从起点到终点的路径；否则，返回结果路径列表。

基于C语言实现简单的走迷宫游戏

基于C语⾔实现简单的⾛迷宫游戏本⽂实例讲述了C语⾔实现简单的⾛迷宫游戏的⽅法，代码完整，便于读者理解。

学数据结构时⽤“栈”写的⼀个⾛迷宫程序，实际上⽤到双向队列，⽅便在运⾏完毕后输出经过的点。

#include <cstdio>#include <deque>#include <windows.h>using namespace std;class node{public:int x,y;int lastOpt;};deque<node> sta;int x,y;int endx,endy;int mapW,mapH;int steps;int xopt[5]= {0,0,1,0,-1};int yopt[5]= {0,1,0,-1,0};int map[100][100]={};void init(){x = 1;y = 1;endx = 1;endy = 9;mapH = 10;mapW = 10;for(int i=0; i<=mapH; i++)for(int j=0; j<=mapW; j++){if(i==0 ||j==0 ||i==mapH||j==mapW)map[i][j]=-1;}steps=0;map[1][2]=-1;map[2][2]=-1;map[3][2]=-1;map[4][2]=-1;map[6][2]=-1;map[7][2]=-1;map[8][2]=-1;map[9][2]=-1;map[9][3]=-1;map[8][3]=-1;map[1][4]=-1;map[3][4]=-1;map[4][4]=-1;map[5][4]=-1;map[6][4]=-1;map[7][4]=-1;map[1][6]=-1;map[2][6]=-1;map[3][6]=-1;map[4][6]=-1;map[5][6]=-1;map[6][6]=-1;map[7][6]=-1;map[8][6]=-1;map[8][7]=-1;map[8][8]=-1;map[7][8]=-1;map[6][8]=-1;map[5][8]=-1;map[4][8]=-1;map[2][8]=-1;map[1][8]=-1;map[endx][endy]=5;}void dis(){system("cls");int ori = map[x][y];map[x][y]=1;for(int i=0; i<=mapH; ++i){for(int j=0; j<=mapW; ++j){if(map[i][j]==0)printf(" ");else if(map[i][j]==-1)printf(" #");else if(map[i][j]==1)printf(" @");else if(map[i][j]==2)printf(" .");else if(map[i][j]==5)printf(" !");}cout<<i<<endl;}for(int j=0; j<=mapW; ++j)cout<<j<<" ";printf("\n\n > steps:%d Exit:(%d,%d)\n",steps,endx,endy);map[x][y] = ori;}int can(int n){if(map[x+xopt[n]][y+yopt[n]] == 0 || map[x+xopt[n]][y+yopt[n]] == 5) return 1;return 0;}void visit(int n){map[x][y]=2;x+=xopt[n];y+=yopt[n];node tem;tem.x = x;tem.y = y;stOpt = n;sta.push_back(tem);steps++;}int main(){init();node tem;while( x != endx || y!=endy){int cans = 0;for(int i=1; i<=4; i++){if(can(i)){cans = 1;visit(i);break;}}if(!cans){if(!sta.empty()){tem = sta.back();map[tem.x][tem.y]=0;}else{map[x][y]=2;x+=xopt[stOpt];x+=yopt[stOpt];dis();break;}}dis();Sleep(500);}if(x==endx && y == endy)cout<<"\n > i am finished....\n";elsecout<<"\n > i am finished...but i can't find the right way\n";return 0;}效果图：以上就是本⽂的全部内容，希望对⼤家学习C语⾔有所帮助。

C语言数据结构中求解迷宫问题实现方法

C语⾔数据结构中求解迷宫问题实现⽅法C语⾔数据结构中求解迷宫问题实现⽅法在学习数据结构栈的这⼀节遇到了求迷宫这个问题，拿来分享⼀下~⾸先求迷宫问题通常⽤的是“穷举求解” 即从⼊⼝出发，顺某⼀⽅向试探，若能⾛通，则继续往前⾛，否则原路返回，换另⼀个⽅向继续试探，直⾄⾛出去。

我们可以先建⽴⼀个8*8的迷宫其中最外侧为1的是墙int mg[M+2][N+2]={{1,1,1,1,1,1,1,1,1,1},{1,0,0,1,0,0,0,1,0,1},{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},{1,0,1,1,1,0,1,1,0,1},{1,1,0,0,0,0,0,0,0,1},{1,1,1,1,1,1,1,1,1,1},}如上所⽰，0对应通道⽅块，1代表墙。

对于迷宫中的每个⽅块，有上下左右4个⽅块相邻，我们规定第i⾏第j列⽅块的位置为（i,j）规定上⽅⽅块⽅位为0，顺时针⽅向递增编号。

(i,j)上⽅的即为(i-1,j),下⽅(i+1,j)，左⽅(i,j-1)，右⽅(i,j+1). 为了⽅⾯回溯，我们需要有进栈出栈操作，所以我们来定义：struct {int i;//当前⽅位⾏int j;//当前⽅位列int di;//下⼀个可⾛⽅位号}St[MaxSize];//栈int top=-1;//初始化栈顶指针我们来看看⽂字过程~~⾸先将⼊⼝进栈（初始⽅位为-1），在栈不空的情况下循环：取栈顶⽅块（不退栈），若该⽅块是出⼝，则退栈。

若存在这样的⽅块，则将其⽅位保存到栈顶元素中，并将这个可⾛的相邻⽅块进栈。

对应的算法：void mgpath(int x1,int y1,int x2,int y2){int i.j,di,find,k;top++;St[top].i=x1; St[top].j=y1; St[top].di=-1; mg[x1][y1]=-1;while (top>-1){i=St[top].i; j=St[top].j; di=St[top].di;if (i==x2 && j==y2){printf("迷宫路径如下：\n");for (k=0;k<=top;k++){printf("\t(%d,%d)",St[k].i,S[k].j);if ((k+1)%5==0) printf("\n"); //输出5个换⼀⾏}printf("\n"); //找到⼀条路径后结束return ;}find=0;while (di<4 && find==0){di++;switch(di){case 0: i=St[top].i-1; j=S[top].j;break;case 1: i=St[top].i; j=St[top].j+1;break;case 2: i=St[top].i+1;j=St[top].j;break;case 3: i=St[top].i; j=St[top].j-1;break;}if(mg[i] [j]==0) find=1;}if (find==1){ //找到了下⼀个可⾛⽅块St[top].di=di;//修改原栈顶的值top++; //下⼀个可⾛⽅块进栈St [top].i=i; St[top].j=j;St[top].di=-1;mg[i] [j]=-1;//避免重复⾛到该⽅块}else{ //没有路径可⾛,进⾏退栈操作mg[St[top].i] [St[top].j]=0;//让该位置变为其他路径的可⾛⽅块top--;}}printf("没有路径可⾛!\n");}当然我们也可以⽤队列去求该迷宫的最优算法，这只是⼀个⽤来理解栈的例⼦~~~感谢阅读，希望能帮助到⼤家，谢谢⼤家对本站的⽀持！。

利用栈实现迷宫求解

迷宫求解数据结构迷宫求解求解迷宫问题栈的实现利用栈求表达式的值迷宫求解课程设计c语言实现栈结构力学求解器规划求解excel规划求解
利用栈实现迷宫的求解
一、要解决的四个问题：
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 (栈不空)

用栈方法解决迷宫问题

else
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;/*运动方向*/

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

数据结构与算法实验报告基于栈的C语言迷宫问题与实现一．问题描述多年以来，迷宫问题一直是令人感兴趣的题目。

实验心理学家训练老鼠在迷宫中寻找食物。

许多神秘主义小说家也曾经把英国乡村花园迷宫作为谋杀现场。

于是，老鼠过迷宫问题就此产生，这是一个很有趣的计算机问题，主要利用“栈”是老鼠通过尝试的办法从入口穿过迷宫走到出口。

迷宫只有两个门，一个叫做入口，另一个叫做出口。

把一只老鼠从一个无顶盖的大盒子的入口处赶进迷宫。

迷宫中设置很多隔壁，对前进方向形成了多处障碍，在迷宫的唯一出口处放置了一块奶酪，吸引老鼠在迷宫中寻找通路以到达出口。

求解迷宫问题，即找出从入口到出口的路径。

一个迷宫可用上图所示方阵[m,n]表示，0表示能通过，1 表示不能通过。

现假设耗子从左上角[1,1]进入迷宫，编写算法，寻求一条从右下角[m,n] 出去的路径。

下图是一个迷宫的示意图：入口出口迷宫示意图二．算法基本思想迷宫求解问题是栈的一个典型应用。

基本算法思想是：在某个点上，按照一定的顺序（在本程序中顺序为上、右、下、左）对周围的墙、路进行判断（在本程序中分别用1、0）代替，若周围某个位置为0，则移动到该点上，再进行下一次判断；若周围的位置都为1（即没有通路），则一步步原路返回并判断有无其他通路，然后再次进行相同的判断，直到走到终点为止，或者确认没有任何通路后终止程序。

要实现上述算法，需要用到栈的思想。

栈里面压的是走过的路径，若遇到死路，则将该位置（在栈的顶层）弹出，再进行下一次判断；若遇到通路，则将该位置压栈并进行下一次判断。

如此反复循环，直到程序结束。

此时，若迷宫有通路，则栈中存储的是迷宫通路坐标的倒序排列，再把所有坐标顺序打印后，即可得到正确的迷宫通路。

三．程序具体部分的说明1.迷宫的生成根据题目的要求，迷宫的大小是自定义输入的。

所以在程序中用malloc申请动态二维数组。

数组中的元素为随机生成的0、1。

数组周围一圈的元素全部定义为1，以表示边界。

2.栈的C语言实现为了实现栈的功能，即清空、压栈、弹出、返回栈顶元素，在程序中编写了相应的函数。

MakeNULL 清空栈Push 将横、纵坐标压栈Topx 返回栈顶存储的横坐标Topy 返回栈顶存储的纵坐标Pop 弹出栈顶元素3.具体的判断算法当位置坐标（程序中为X Y）移到某一位置时，将这个位置的值赋值为1并压栈，以说明该点已经走过。

接着依次判断该点的上、右、下、左是否为0，若有一方为0，则移动到该位置上，进行下次判断；若为周围位置全部是1，则将该点压栈后不断弹出，每次弹出时判断栈顶元素（即走过的路）周围有无其他通路。

如果有的话，则选择该方向继续走下去；如果栈已经为空仍然没有找到出路，则迷宫没有出口程序结束。

当X Y走到出口坐标时，程序判断部分结束。

栈里面存储的是每个走过的点的坐标，将这些横纵坐标分别存储在两个数组中，最后将数组中的坐标元素倒序输出，即得到了完整的路径。

四．程序源代码及注释// Maze.cpp : 定义控制台应用程序的入口点。

//#include"stdafx.h"#include<stdio.h>#include<string.h>#include<malloc.h>#include<stdlib.h>#include<time.h>typedef int Elementtype;struct node{Elementtype val1;Elementtype val2;node *next;};//定义结构体typedef node *MAZE;void MakeNull(MAZE &S);void Push(Elementtype x,Elementtype y, MAZE S); void Pop(MAZE S);Elementtype Topx(MAZE S);Elementtype Topy(MAZE S);//申明函数int _tmain(int argc, _TCHAR* argv[]){int **p,*q,*x1,*y1,i,j,k,n1,n2,m1,m2,l,w,max;int x,y;int a,b,c,d;printf("输入迷宫长度及宽度l和w\n");scanf("%d %d",&l,&w);getchar();n1=w+2;n2=l+2;//为迷宫加上边界max=n1*n2;p=(int**)malloc(n1*sizeof(int));for(i=0;i<n1;i++)p[i]=(int *)malloc(n2*sizeof(int));//生成二维动态数组srand(time(NULL));x1=(int*)malloc(max*sizeof(int));//生成动态数组用于存储路径y1=(int *)malloc(max*sizeof(int));//生成动态数组用于存储路径for(i=0;i<max;i++){x1[i]=0;}for(i=0;i<max;i++){y1[i]=0;}//先将存储路径的数组元素全赋值为0for(i=0;i<n1;i++){for(j=0;j<n2;j++){if(i==0 || j==0){p[i][j]=1;}else if(i==n1-1 || j==n2-1){p[i][j]=1;}elsep[i][j]=rand()%2+0;}}//生成二维1 0随机数组p[1][1]=0;p[n1-2][n2-2]=0;//定义迷宫的入口及出口printf("生成的迷宫如下（代表墙0代表路）：\n");for(i=0;i<n1;i++){{for(j=0;j<n2;j++)printf("%2d",p[i][j]);}printf("\n");}//打印迷宫MAZE S;MakeNull(S);//清空栈i=1;j=1;if(p[1][2]==1 && p[2][1]==1){printf("There is no way out");agetchar();return 0;}//判断入口是否就是死路else{do{if(p[i-1][j]==0){x=i;y=j;Push(x,y,S);p[i][j]=1;i=i-1;}//判断能否向上走else if(p[i-1][j]==1 && p[i][j+1]==0){x=i;y=j;Push(x,y,S);p[i][j]=1;j=j+1;}//判断能否向右走else if(p[i-1][j]==1 && p[i][j+1]==1 && p[i+1][j]==0) {x=i;y=j;Push(x,y,S);k=Topx(S);p[i][j]=1;i=i+1;}//判断能否向下走else if(p[i-1][j]==1 && p[i][j+1]==1 && p[i+1][j]==1 && p[i][j-1]==0){x=i;y=j;Push(x,y,S);p[i][j]=1;j=j-1;}//判断能否向左走else if(p[i-1][j]==1 && p[i][j+1]==1 && p[i+1][j]==1 && p[i][j-1]==1)//判断如果为死路{p[i][j]=1;x=i;y=j;Push(x,y,S);for(;;){Pop(S);//弹出栈顶元素x=Topx(S);y=Topy(S);//返回栈顶元素横纵坐标if( p[x-1][y]==0){i=x-1;j=y;p[i][j]=1;x=i;y=j;Push(x,y,S);break;}else if(p[x-1][y]==1 && p[x][y+1]==0){i=x;j=y+1;p[i][j]=1;x=i;y=j;Push(x,y,S);break;}else if(p[x-1][y]==1 && p[x][y+1]==1 && p[x+1][y]==0) {i=x+1;j=y;p[i][j]=1;x=i;y=j;Push(x,y,S);break;}else if(p[x-1][y]==1 && p[x][y+1]==1 && p[x+1][y]==1 && p[x][y-1]==0){i=x;j=y-1;p[i][j]=1;x=i;y=j;Push(x,y,S);break;}//判断弹出后栈顶元素周围有无通路else if(x==1 && y==1){printf("There is no way out");getchar();return 0;}//如果栈顶元素为入口则迷宫无出路}}}while(i!=n1-2 || j!=n2-2);//循环截止条件}printf("Success!\n The route is:\n");for(i=0;;i++){a=Topx(S);b=Topy(S);Pop(S);x1[i]=a;y1[i]=b;//将栈顶元素坐标存储在数组中if(a==1 && b==1){getchar();break;}}for(i=max-1;i>=0;){if(x1[i]!=0 && (x1[i]!=x1[i-1] || y1[i]!=y1[i-1])){printf("<%d ,%d> ",x1[i],y1[i]);i--;}else if(x1[i]!=0 && (x1[i]==x1[i-1] && y1[i]==y1[i-1])) {printf("<%d ,%d> ",x1[i],y1[i]);i=i-2;}elsei--;}//倒序打印数组得到顺序出路坐标printf("<%d ,%d>",n1-2,n2-2);//打印出口坐标getchar();return 0;}void MakeNull(MAZE &S) //清空栈的函数{S = new node;S->next = NULL;}void Push(Elementtype x,Elementtype y, MAZE S)//压栈函数{MAZE stk;stk = new node;stk->val1 = x;stk->val2 = y;stk->next = S->next;S->next = stk;}void Pop(MAZE S)//弹出函数{MAZE stk;if(S->next){stk = S->next;S->next = stk->next;delete stk;}}Elementtype Topx(MAZE S)//返回横坐标函数{if(S->next)return(S->next->val1);elsereturn NULL;}Elementtype Topy(MAZE S)//返回纵坐标函数{if(S->next)return(S->next->val2);elsereturn NULL;}五．程序运行结果运行程序后，首先输入迷宫的长度和宽度假设迷宫是8*8的（也可以为其他大小）。