栈和队列--迷宫问题

合集下载

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，结束函数，此时栈中已储存了通往终点的路径，若没有通路，则弹出栈顶元素，根据递归原理该路径上的所有点都会弹出并标记未⾛，回溯到之前的点，继续向其他⽅向搜索，直到找到终点或遍历完整个图。

迷宫问题火车车厢重排问题实验报告

实验报告了便于从列车上卸掉相应的车厢，车厢的编号应与车站的编号相同，这样，在每个车站只要卸掉最后一节车厢。

所以，给定任意次序的车厢，必须重新排列它们。

车厢的重排工作可以通过转轨站完成。

在转轨站中有一个入轨、一个出轨和k个缓冲轨，缓冲轨位于入轨和出轨之间。

假定缓冲轨按先进先出的方式运作，设计算法解决火车车厢重排问题。

②基本要求●设计存储结构表示n个车厢、k个缓冲轨以及入轨和出轨；●设计并实现车厢重排算法；●分析算法的时间性能。

③思考●如果缓冲轨按后进先出的方式工作，即用栈表示缓冲轨，应如何解决火车车厢重排问题？二、数据结构设计迷宫问题和火车重排问题可以通过栈与队列实现的。

迷宫的进出和车厢的出入轨和缓冲轨主要是对栈与队列的判断和操作。

int empty( STLink top[],int n) /*判断是否为空*/{return (top[n]==NULL);}int push(STLink top[],int A,int m) /*入栈*/{STLink p;if(!(p=(STLink)malloc(LEN)))return 0;else{p->data=A;p->link=top[m];top[m]=p;return 1;}}int pop(STLink top[],int m) /*出栈*/{int A;STLink p;p=top[m];A=p->data;top[m]=top[m]->link;free(p);return A;}struct Node{ /定义队列int data;Node* next;};三、算法设计1.迷宫问题：进入格子后，需要判断此时格子位置周围障碍物的位置，对其进行压栈，判断，然后看是否满足条件，满足就进栈，不满足就弹出，然后输出不能通过建立迷宫：typedef struct LStack{Element elem;struct LStack *next;}*PLStack;int InitStack(PLStack &S){S=NULL;return 1;}int StackEmpty(PLStack S){if(S==NULL)return 1;elsereturn 0;}int Push(PLStack &S, Element e){PLStack p;p=(PLStack)malloc(sizeof(LStack));p->elem=e;p->next=S;S=p;return 1;}（2）.输出路径2.火车车厢排序六、实验收获与思考通过本次实验，进一步增强了对栈和队列的理解，明白的栈的先进后出和队列先进先出的方式，对压栈和出入栈与队列有了深刻认识。

栈和队列的应用函数调用栈迷宫求解等

栈和队列的应用函数调用栈迷宫求解等栈和队列的应用：函数调用栈、迷宫求解等栈(Stack)和队列(Queue)是常用的数据结构，在计算机科学中有广泛的应用。

本文将讨论它们的应用，包括函数调用栈和迷宫求解。

一、函数调用栈的应用函数调用栈是程序执行时用于管理函数调用的一种数据结构。

当一个函数被调用时，函数的执行现场（包括局部变量、函数参数等）需要被保存，以便在函数执行完毕后能够恢复到调用该函数之前的状态。

函数调用栈的应用之一是递归函数。

递归函数是指在函数的定义中调用函数本身。

在递归函数中，每一次的函数调用都会将其执行现场保存到栈中，以便能够在递归结束后正确返回。

例如，下面是一个计算斐波那契数列的递归函数：```pythondef fibonacci(n):if n <= 1:return nelse:return fibonacci(n-1) + fibonacci(n-2)```在调用`fibonacci(5)` 时，函数调用栈中会保存多个函数的执行现场，包括函数参数 `n` 的值以及函数返回地址。

通过不断弹出栈顶元素，递归函数可以依次返回上一层的结果，最终得到 `fibonacci(5)` 的值。

除了递归函数，函数调用栈还广泛应用于程序调试和异常处理。

当程序运行出错时，我们可以通过查看函数调用栈来确定错误发生的位置和调用关系，有助于快速定位和修复bug。

二、迷宫求解的应用迷宫求解是一个经典的问题，通过使用栈和队列作为辅助数据结构，可以高效地找到迷宫的路径。

在迷宫求解中，迷宫可以看做是一个二维网格，其中包括起点、终点以及墙壁。

我们需要找到一条从起点到终点的路径，路径可以通过上下左右移动。

使用栈或者队列来辅助求解迷宫问题。

当使用栈时，我们将当前位置的周围可行的下一个位置入栈，并继续向前搜索。

当使用队列时，我们将当前位置的周围可行的下一个位置入队，然后依次处理队列中的元素。

下面是一个使用栈求解迷宫的示例代码：```pythondef maze_solver(maze):stack = [(0, 0)] # 起点入栈visited = set() # 记录已访问的位置while stack:x, y = stack[-1] # 获取栈顶位置if (x, y) == (len(maze)-1, len(maze[0])-1):return True # 找到终点found = Falsefor dx, dy in [(0, 1), (0, -1), (1, 0), (-1, 0)]:nx, ny = x + dx, y + dy # 计算下一个位置if 0 <= nx < len(maze) and 0 <= ny < len(maze[0]) and (nx, ny) not in visited and maze[nx][ny] == 0:stack.append((nx, ny)) # 下一个位置入栈visited.add((nx, ny)) # 标记为已访问found = Truebreakif not found:stack.pop() # 无法继续前进，回溯return False # 未找到路径```在上述的代码中，我们使用栈来保存前进过程中的路径，并使用集合 `visited` 记录已经访问过的位置。

用栈解决迷宫问题

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

数据结构实验2栈和队列迷宫问题求解

（2）代码
栈构造函数：
void seqstack::Push(int x,int y,int d) //入栈
{
if(top>=StackSize-1)throw"上溢";
top++;
data[top].d=d;
data[top].x=x;
data[top].y=y;
}
寻找路径：
int seqstack::findpath(int a,int b)
x
y
0
0
1
1
1
0
2
0
-1
3
-1
0
增量move数组
（2）基本代码
structitem
{
intx; //行
inty; //列
};
item move[4];
2.寻找路径
（1）基本思想：
利用栈的结构，走过的路入栈，如果不能走出栈，采用遍历法，因此栈内存储的数据就是寻一条路径。
当到达了某点而无路可走时需返回前一点，再从前一点开始向下一个方向继续试探。因此，压入栈中的不仅是顺序到达的各点的坐标，而且还要有从前一点到达本点的方向，即每走一步栈中记下的内容为(行，列，来的方向)。
2.实验内容
利用栈结构实现迷宫求解问题。迷宫求解问题如下：
心理学家把一只老鼠从一个无顶盖的大盒子的入口赶进迷宫，迷宫中设置很多隔壁，对前进方向形成了多处障碍，心理学家在迷宫的唯一出口放置了一块奶酪，吸引老鼠在迷宫中寻找通路以到达出口，测试算法的迷宫如下图所示。
提示：
1、可以使用递归或非递归两种方法实现
2、老鼠能够记住已经走过的路，不会反复走重复的路径
3、可以自己任意设置迷宫的大小和障碍

栈和队列的应用——迷宫问题（深度、广度优先搜索）

栈和队列的应⽤——迷宫问题（深度、⼴度优先搜索）⼀、迷宫问题给⼀个⼆维列表，表⽰迷宫（0表⽰通道，1表⽰围墙）。

给出算法，求⼀条⾛出迷宫的路径。

maze = [[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]] 1代表墙，0代表路，图⽰如下：⼆、栈——深度优先搜索应⽤栈解决迷宫问题，叫做深度优先搜索（⼀条路⾛到⿊），也叫做回溯法。

1、⽤栈解决的思路思路：从上⼀个节点开始，任意找下⼀个能⾛的点，当找不到能⾛的点时，退回上⼀个点寻找是否有其他⽅向的点。

使⽤栈存储当前路径。

后进先出，⽅便回退到上⼀个点。

2、⽤栈代码实现maze = [[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]]# 四个移动⽅向dirs = [lambda x,y: (x+1, y), # 下lambda x,y: (x-1, y), # 上lambda x,y: (x, y-1), # 左lambda x,y: (x, y+1) # 右]def maze_path(x1, y1, x2, y2): # (x1,y1)代表起点；(x2,y2)代表终点stack = []stack.append((x1, y1))while(len(stack)>0):curNode = stack[-1] # 当前的节点(栈顶)if curNode[0] ==x2 and curNode[1] == y2: # 判断是否⾛到终点# ⾛到终点，遍历栈输出路线for p in stack:print(p)return True"""搜索四个⽅向"""for dir in dirs:nextNode = dir(curNode[0], curNode[1])# 如果下⼀个阶段能⾛if maze[nextNode[0]][nextNode[1]] == 0:stack.append(nextNode) # 将节点加⼊栈maze[nextNode[0]][nextNode[1]] = 2 # 将⾛过的这个节点标记为2表⽰已经⾛过了break # 找到⼀个能⾛的点就不再遍历四个⽅向else:# ⼀个都找不到，将该位置标记并该回退maze[nextNode[0]][nextNode[1]] = 2stack.pop()else:print("没有路")return Falsemaze_path(1,1,8,8)"""(1, 1) (2, 1) (3, 1) (4, 1) (5, 1) (5, 2) (5, 3) (6, 3) (6, 4)(6, 5) (7, 5) (8, 5) (8, 6) (8, 7) (8, 8)""" 总结算法就是：创建⼀个空栈，⾸先将⼊⼝位置进栈。

数据结构与算法课程的入门教学范例——迷宫问题

ｅｒｅｍｅｈｏｄ，ａｌｇｗｉｓｐａｒｅｌｂｅｄｏｓａｃａｎｑｘｐｓｓｔｏｎｔｈｅａｔｙａｓｎｔｋｄｕｅｕｏｅｆｄｔａｃｏｔｒｔｉｎ’ ｄｐｔａｎｓｕｃｏｓｅｈｆｉｔａｒｓｎｄ
访问的节点，标记它，并人栈。 ②在不能执行 ①时，若栈不空，则出栈一个元素。④如果不能执行 ①和 ②时，则完成了搜索。
正如算法名称那样，深度优先搜索所遵循的搜索策略是
尽可能“ 地搜索。深”
搜索算法，从而快速入门课程学习。这个典型实例就是迷宫
摘
一
要：完整地分析了作为数据结构与算法课程入门教学范例的迷宫问题的求解。迷宫问题包含两个完备的求解问题，求
个解与求最优解。问题的求解过程包含了问题的计算机表示方法，以及分别基于数据结构栈和队列的深度优先和广度优先关键词：宫问题；结构；迷数据算法
ｂｅｄｈｆｒｔｓａｃｉｇａｇｒｔｍ．ｒａｔｉｓｅｒｈｎｌｏｉｈＫｅｗｏｄｙｒｓ：ＬｂｒｎｈＱｅｔｏ；ＤｔｏｓｒｃｉｎＡｇｒｔｍａｙｉｔｕｓｉｎａａＣｎｔｕｔｏ：ｌｏｉｈ
（毕节学院信息化管理中心，贵州毕节
５１０）５７０
（ｎｏｍｔｏａａｅｅｔＣｎｅｆＢｊｅＣｌｅｅｕｚｏｉｉ５７０ＩｆｒａｉｎＭｎｇｍｎｅｔｒｏｉｉｏｌｇ，ＧｉｈｕＢｊｅ５１０）

数据结构设计——用队列实现迷宫问题的求解

数据结构设计——⽤队列实现迷宫问题的求解本篇⽂章中所有数据结构都是后期整理的，如有问题欢迎指正，转载请注明出处1，问题描述以⼀个m*n的长⽅阵表⽰迷宫，0和1分别表⽰迷宫中的通路和障碍。

迷宫问题要求求出从⼊⼝（1，1）到出⼝（m,n）的⼀条通路，或得出没有通路的结论。

基本要求：⾸先实现⼀个以链表作存储结构的栈类型，然后编写⼀个求迷宫问题的⾮递归程序，求得的通路，其中：（i，j）指⽰迷宫中的⼀个坐标， d表⽰⾛到下⼀坐标的⽅向。

左上⾓（1，1）为⼊⼝，右下⾓（m,n）为出⼝。

2.设计思路：⽤队列实现迷宫问题的求解；3．实验代码：队列实现:********************************************************************************************1//maze_queue.cpp2 #include<stdio.h>3 #include<stdlib.h>4 #include<windows.h>5 #include"seqqueue.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(void)26 {27int i, j;28 system("cls");29 printf("迷宫如下‘■’代表墙,数字或者‘☆’表⽰路径\n");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(int row, int col,PSeqQueue S)46 {47struct point visit_point = { row, col, S->front };48 maze[row][col] = 2;49 In_SeqQueue(S,visit_point);50 }5152int main()53 {54struct point p = { 1, 1, -1 };//第⼀个点前驱设为-1，以便后⾯打印迷宫55 maze[p.row][p.col] = 2;//遍历过的点设置为256 PSeqQueue S = Init_SeqQueue();57 In_SeqQueue(S,p);58while (!Empty_SeqQueue(S))59 {60 Out_SeqQueue(S,&p);61if (p.row == MAX_ROW - 2 && p.col == MAX_COL - 2)62break;63if (p.col + 1< MAX_COL-1 && maze[p.row][p.col + 1] == 0)64 visit(p.row, p.col + 1,S);65if (p.row + 1< MAX_ROW-1 && maze[p.row + 1][p.col] == 0)66 visit(p.row + 1, p.col,S);67if (p.col - 1 >= 1 && maze[p.row][p.col - 1] == 0)68 visit(p.row, p.col - 1,S);69if (p.row - 1 >= 1 && maze[p.row - 1][p.col] == 0)70 visit(p.row - 1, p.col,S); //以上是对迷宫的四个⽅向进⾏操作71 }72if (p.row == MAX_ROW - 2 && p.col == MAX_COL - 2)//是否为出⼝73 {74int count = 3;75struct point q = { p.row, p.col, p.pre };76while (q.pre != -1)//按照前驱进⾏查找77 {78 q = S->data[q.pre];79 count++;80 }81 printf("成功找到最短路径，路径倒序输出：\n");82 printf("(%d,%d)\n", p.row, p.col);83 maze[p.row][p.col] = count;84while (p.pre!=-1)//按照前驱进⾏查找85 {86 count--;87 p = S->data[p.pre];88 maze[p.row][p.col] = count;89 printf("(%d,%d)\n", p.row, p.col);90 }91 printf("三秒后打印路径......\n");92 Sleep(3000);93 print_line();94 }9596else {97 printf("没有出路\n");98 }99100 system("pause");101return0;102 }103//end maze_queue.cpp************************************************************************************************************ 1//seqqueue.h2 #include<stdio.h>3 #include<stdlib.h>4#define MAXSIZE 1005struct point{6int row, col, pre;7 };8 typedef struct point DataType;9 typedef struct {10 DataType data[MAXSIZE];11int front ,rear;12 }SeqQueue,*PSeqQueue;1314 PSeqQueue Init_SeqQueue()15 {16 PSeqQueue Q;17 Q = (PSeqQueue)malloc(sizeof(SeqQueue));18if(Q)19 {20 Q->front = 0;21 Q->rear = 0;22 }23return Q;24 }2526int Empty_SeqQueue(PSeqQueue Q)27 {28if(Q && Q->front == Q->rear)29return1;30else31return0;32 }3334int In_SeqQueue(PSeqQueue Q,DataType x)35 {36if((Q->rear + 1) % MAXSIZE == Q->front)37 {38 printf("队满\n");39return0;40 }41else42 {43 Q->rear = (Q->rear + 1) % MAXSIZE;44 Q->data[Q->rear] = x;45return1;46 }47 }4849int Out_SeqQueue(PSeqQueue Q,DataType *x)50 {51if(Empty_SeqQueue(Q))52 {53 printf("队空");54return0;55 }56else57 {58 Q->front = (Q->front + 1) % MAXSIZE;59 *x = Q->data[Q->front];60return1;61 }62 }6364int Front_SeqQueue(PSeqQueue Q,DataType *x)65 {66if(Q->front == Q->rear)67 {68 printf("队空\n");69return0;70 }71else72 {73 *x = Q->data[(Q->front + 1) % MAXSIZE];74return1;75 }76 }7778void Distroy_SeqQueue(PSeqQueue *Q)79 {80if(*Q)81free(*Q);82 *Q = NULL;83 }//end seqqueue.h4.运⾏结果：5.实验分析与总结：在求解迷宫问题中，⾸先是⽤栈的来实现操作，⼀步步⼊栈出栈，最后找到出路，虽然找到的路劲不是最佳路径，但是这是⼀种⼈⼯智能的算法，符合⼈的思维⽅式，是现实⽣活中⼈解决迷宫问题的⽅式；⽽⽤队列实现迷宫问题的求解时，依次探索路径放⼊队列中，并对每个元素设置好前驱标志，这样⼀直遍历到终点时，按照前驱进⾏探索，输出整个迷宫的倒序，并对这些坐标进⾏编码，再⼀次遍历迷宫输出路径，即队列实现迷宫的⽅法；实际操作中，我已开始设置了错误的结构，导致好了⼀天的时间都没有写完这个迷宫，我开始认为多分叉的树型结构可以很好地解决这个问题，但是在最后探索路劲并返回结果时出现了瓶颈，最后推翻了整个结构，正如⽼师所说，数据结构的精髓是设计好能更好解决问题的结构，是解决问题的关键所在。

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},

数据结构课程设计选题

数据结构课程设计选题数据结构课程设计选题题⽬选题⼀：迷宫与栈问题【问题描述】以⼀个mXn的长⽅阵表⽰迷宫，0和1分别表⽰迷宫中的通路和障碍。

设计⼀个程序，对任意设定的迷宫，求出⼀条从⼊⼝到出⼝的通路，或得出没有通路的结论。

【任务要求】1)⾸先实现⼀个以链表作存储结构的栈类型，然后编写⼀个求解迷宫的⾮递归程序。

求得的通路以三元组（i，j，d）的形式输出。

其中：（i，j）指⽰迷宫中的⼀个坐标，d表⽰⾛到下⼀坐标的⽅向。

如，对于下列数据的迷宫，输出⼀条通路为：（1，1，1），（1，2，2），（2，2，2），（3，2，3），（3，1，2），…。

2)编写递归形式的算法，求得迷宫中所有可能的通路。

3)以⽅阵形式输出迷宫及其通路。

【测试数据】迷宫的测试数据如下：左上⾓（0，1）为⼊⼝，右下⾓（8，9）为出⼝。

出⼝出⼝选题⼆：算术表达式与⼆叉树【问题描述】⼀个表达式和⼀棵⼆叉树之间，存在着⾃然的对应关系。

写⼀个程序，实现基于⼆叉树表⽰的算术表达式的操作。

【任务要求】假设算术表达式Expression内可以含有变量（a～z）、常量（0～9）和⼆元运算符（+，-，*，/，^(乘幂)）。

实现以下操作：1)ReadExpre(E)—以字符序列的形式输⼊语法正确的前缀表达式并构造表达式E。

2)WriteExpre(E)—⽤带括弧的中缀表达式输出表达式E。

3)Assign(V,c)—实现对变量V的赋值（V=c），变量的初值为0。

4)Value(E)—对算术表达式E求值。

5)CompoundExpr（P，E1，E2）--构造⼀个新的复合表达式（E1）P（E2）【测试数据】1)分别输⼊0；a；-91；+a*bc；+*5^x2*8x；+++*3^x3*2^x2x6并输出。

2)每当输⼊⼀个表达式后，对其中的变量赋值，然后对表达式求值。

选题三：银⾏业务模拟与离散事件模拟【问题描述】假设某银⾏有4个窗⼝对外接待客户，从早晨银⾏开门（开门9：00am，关门5：00pm）起不断有客户进⼊银⾏。

数据结构课程设计报告-迷宫问题(队列)

题目：迷宫问题（队列）以一个m*n的长方阵表示迷宫，0和1分别表示迷宫中的通路和障碍。

设计一个程序，对任意设定的迷宫，求出一条从入口到出口的通路，或得出没有通路的结论。

要求：首先实现一个以链表作存储结构的队列，然后编写一个求解迷宫的非递归程序。

求得的通路以三元组（i,j,d）的形式输出，其中：（i,j）指示迷宫中的一个坐标，d表示走到下一坐标的方向，如：对于下列数据的迷宫，输出的一条通路为：（1，1，1），（1,2,2）,(3,2,3),(3,1,2),…。

测试数据：迷宫的测试数据如下：左下角（1，1）为入口，右下角（8，9）为出口。

选做内容：（1）编写递归形式的算法，求得迷宫中所有可能的通路；（2）以方阵形式输出迷宫及其通路一、问题分析和任务定义：从题目可知，迷宫问题主要是考察队列操作和图的遍历算法。

可以分解成以下几个问题：1.迷宫的构建，若是一个个的将数据输入，那么一个m*n的二维数组要想快速的输入进去是很麻烦的，那么就应该让计算机自动生成一个这样的迷宫。

2.题目要求以链表作存储结构的对列来对访问过的通路结点进行存储，这样就会遇到一个比较大的问题。

那就是，在寻找的过程当中，当前队尾节点的其余三个方向上均都是墙，这样就无法再走下去了，必须要返回。

由于是用队列存储的，不能直接将队尾元素删除，那就应该让其他元素从队头出队构成另外一条队列。

这样，就可以将该结点从队列当中删除了。

3.在题目中提出，要输出经过结点的方向，对于任意的一个位置有四个方向，所以对于队列中的么每一个结点设置一个方向的标记量，表示走向下一结点的方向，当前加到队尾的元素的方向设置为0，一旦有新元素入队，就对队尾元素的方向进行修改。

4.确定没有通路的思路：因为当沿着每个方向前进到某一位置时，不再有通路之后，就会把该节点从队列中删除，同时会将该位置上的值修改，从而保证下次改位置上的结点不会再入队。

如果不存在通路，必然会一直返回到初始状态（队列为空）。

迷宫寻路游戏编程

迷宫寻路游戏编程迷宫寻路游戏是一种常见的益智游戏，在这种游戏中，玩家需要通过思考和推理找到从迷宫入口到出口的最短路径。

虽然看似简单，但实际上需要运用图论和搜索算法来实现。

本文将介绍迷宫寻路游戏的基本原理以及一种实现方法。

一、迷宫寻路游戏的基本原理迷宫可以看作是一个由格子组成的二维矩阵，每个格子可以是墙壁或通道。

其中，墙壁表示不可通过的障碍物，而通道表示可以通过的路径。

寻路游戏的目标是从迷宫的入口到出口找到一条尽可能短的路径。

二、迷宫寻路游戏的编程思路为了实现迷宫寻路游戏，我们可以采用深度优先搜索（DFS）或广度优先搜索（BFS）算法。

其中，DFS算法以堆栈（栈）为基础，BFS 算法以队列为基础。

1. 深度优先搜索（DFS）DFS算法可以简单描述为以下步骤：（1）将迷宫的入口状态（起点）加入堆栈。

（2）从堆栈中取出一个状态，并将其标记为已访问。

（3）检查当前状态是否为出口状态，如果是则返回路径，游戏结束。

（4）如果当前状态不是出口状态，则扩展当前状态的邻居状态，并将未访问的邻居状态加入堆栈。

（5）重复步骤（2）至（4），直到堆栈为空或找到出口状态。

2. 广度优先搜索（BFS）BFS算法可以简单描述为以下步骤：（1）将迷宫的入口状态（起点）加入队列。

（2）从队列中取出一个状态，并将其标记为已访问。

（3）检查当前状态是否为出口状态，如果是则返回路径，游戏结束。

（4）如果当前状态不是出口状态，则扩展当前状态的邻居状态，并将未访问的邻居状态加入队列。

（5）重复步骤（2）至（4），直到队列为空或找到出口状态。

三、迷宫寻路游戏的编程实现下面是一种基于Python语言的迷宫寻路游戏编程实现示例：```python# 导入必要的模块import queue# 迷宫地图，0表示墙壁，1表示通道maze = [[0, 1, 0, 0, 0],[0, 1, 1, 1, 0],[0, 0, 0, 1, 0],[0, 1, 1, 1, 0],[0, 0, 0, 0, 0]]# 定义迷宫的行数和列数rows = len(maze)cols = len(maze[0])# 定义起点和终点坐标start = (0, 0)end = (rows - 1, cols - 1)# 定义方向数组，用于控制上下左右移动dirs = [(-1, 0), (1, 0), (0, -1), (0, 1)]# 定义BFS算法函数def BFS(maze, start, end):q = queue.Queue()q.put(start)# 使用visited数组记录已经访问过的状态visited = [[False] * cols for _ in range(rows)]visited[start[0]][start[1]] = Truewhile not q.empty():cur_pos = q.get()if cur_pos == end:return Truefor dir in dirs:next_pos = (cur_pos[0] + dir[0], cur_pos[1] + dir[1])# 如果下一个状态合法且未访问过，则加入队列并标记为已访问if isValid(next_pos) and not visited[next_pos[0]][next_pos[1]]: q.put(next_pos)visited[next_pos[0]][next_pos[1]] = Truereturn False# 判断状态是否合法def isValid(pos):x, y = pos[0], pos[1]return 0 <= x < rows and 0 <= y < cols and maze[x][y] == 1# 测试迷宫寻路游戏if BFS(maze, start, end):print("找到了一条路径")else:print("未找到路径")```以上是一个简单的迷宫寻路游戏编程实现示例，通过运行代码，即可在命令行中得到游戏结果。

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

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

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

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

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

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

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

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

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

队列与栈解决迷宫问题（待补充）

队列与栈解决迷宫问题（待补充）内容概要⼀、迷宫问题介绍⼆、栈解决迷宫问题三、队列解决迷宫问题1、迷宫问题介绍迷宫问题简单的说，就是通过⼀种算法，让计算机找到出⼝迷宫可以通过⼆级列表实现，1表⽰路不允许通过；0表⽰路允许通过⽐如下⾯的⼆级列表表⽰的迷宫maze = [ # 横是y轴，纵是x轴[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, 0, 1, 1, 0, 1],[1, 1, 0, 1, 1, 1, 1, 0, 0, 1],[1, 0, 0, 0, 1, 1, 0, 0, 0, 1],[1, 0, 1, 0, 1, 0, 0, 0, 0, 1],[1, 0, 1, 0, 0, 0, 1, 1, 0, 1],[1, 0, 1, 1, 1, 0, 0, 0, 0, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1],] 解决迷宫问题有两种思路，⼀种是使⽤栈；另⼀种是使⽤队列2、栈解决迷宫问题栈解决迷宫问题，遵照深度优先。

也就是说⼀条路⾛到底，如果没能到达终点或者没有路⾛，那么就开始回溯，找到另外⼀条可以⾛的路。

栈解决迷宫问题代码实现思路（1）规定迷宫，迷宫的起点、终点（2）创建栈，栈⽤于存储相关的路径坐标（3）检查栈顶（所在迷宫的当前位置）的四个⽅向，只要有可通⾏的节点，将该节点进栈，重复步骤3 （4）如果四个⽅向都不能同⾏，并且没有到达终点，那么是死路，进⾏回退，栈顶出栈（5）重复步骤3（特别要注意的是，想办法识别之前去过的节点，使得不再重复死路）（6）找到终点需要注意的是：（1）如果不存在到达终点的路径，那么栈最终栈会变为空（2）回退时，要使锝不再重复去过的路径，可以将去过的路径进⾏标记，告诉计算机这条路不通（3）栈寻路是深度优先，找到的路径并⾮⼀定是最短的代码实现li = [lambda x, y: (x, y+1),lambda x, y: (x+1, y),lambda x, y: (x, y-1),lambda x, y: (x-1, y),]def search_path(maze, x1, y1, x2, y2): # x1, y1是起点坐标;x2, y2是终点坐标stack = [(x1, y1)] # 使⽤列表充当⼀个栈，初始存有起点while stack: # 栈空时，说明没有路径node = stack[-1]if node[0] == x2 and node[1] == y2: # 查看栈顶是否是终点for node in stack:print(node)breakfor func in li: # 检查4个⽅向是否可通过next_node = func(node[0], node[1])if maze[next_node[0]][next_node[1]] == 0:maze[node[0]][node[1]] = 2 # 将前⼀个节点标记为已⾛过，避免回到之前的节点，陷⼊死循环 stack.append(next_node) # 更新所在位置breakelse:maze[node[0]][node[1]] = 2 # 当四个⽅向都不可通⾏时，将所在位置设置为⽆法通⾏stack.pop() # 回到上⼀个位置else:print("没有路径!")search_path(maze, 1, 1, 8, 8)3、队列解决迷宫问题队列解决迷宫问题思路 **思路图解** ⾃⼰尝试写的代码（只实现了功能,并且似乎没有使⽤队列）func_li = [lambda x, y: (x, y+1),lambda x, y: (x+1, y),lambda x, y: (x, y-1),lambda x, y: (x-1, y),]def search_path(maze, x1, y1, x2, y2):nodes = [(x1, y1)]maze[x1][y1] = 2next_nodes = []count = 3n = 1while len(nodes):for node in nodes:for func in func_li:next_node = func(node[0], node[1])if next_node[0] == x2 and next_node[1] == y2:result_node = [next_node]node = next_node# while count > 2:while not (node[0] == x1 and node[1] == y1):for fu in func_li:previous_node = fu(node[0], node[1])if maze[previous_node[0]][previous_node[1]] == count-1:result_node.append(previous_node)node = previous_nodecount -= 1print(1)breakprint(result_node)else:# result_node.append((x1, y1))return result_nodeif maze[next_node[0]][next_node[1]] == 0:next_nodes.append(next_node)maze[next_node[0]][next_node[1]] = counttmp = nodesnodes = next_nodesnext_nodes = tmpnext_nodes.clear()count += 1for li in maze:print(li)print("=================={}===================".format(n))n += 1else:print("不存在路径!")re_li = search_path(maze, 1, 1, 8, 8)print(re_li)View Code 优化def search_path(maze, x1, y1, x2, y2):nodes = [(x1, y1)] # 定义⼀个列表⽤于存储本次需要探寻的节点next_nodes = [] # 将由nodes探寻得到的可通过节点存储到next_nodes中maze[x1][y1] = 2 # 将起点设置为已⾛mark = 3 # 动态标记已经⾛过的节点while len(nodes):for node in nodes:for func in li:next_node = func(node[0], node[1])# 判断终点和返回路径机制if next_node[0] == x2 and next_node[1] == y2: # 判断节点是否为终点result_node = [next_node] # 存储最终路径的列表，初始值为终点坐标node = next_nodewhile not (node[0] == x1 and node[1] == y1): # 这⾥最难了，找到终点后要进⾏回溯，从终点节点按照之前设置的动态标记找回起点for fu in li:previous_node = fu(node[0], node[1])if maze[previous_node[0]][previous_node[1]] == mark-1: # 根据标记找到正确的前⼀个节点result_node.append(previous_node)node = previous_nodemark -= 1 # 下⼀个标记的值⽐此次标记值⼩1breakelse:result_node.reverse() # 由于是从终点回退到起点，所以最终的列表循序是反的return result_nodeif maze[next_node[0]][next_node[1]] == 0: # 判断该节点是否可以通过next_nodes.append(next_node)maze[next_node[0]][next_node[1]] = marktmp = nodesnodes = next_nodesnext_nodes = tmpnext_nodes.clear()mark += 1 # 标记值⾃增，⽤于区分不同次的遍历# 查看标记# for line in maze:# print(line)# print()else:print("不存在路径!")View Code ⽜逼的清华⼤佬的⽜逼代码from collections import dequedef search_path_queue(maze, x1, y1, x2, y2):global cur_nodequeue = deque([(x1, y1, -1)]) # 与⾃⼰的思路不同的是，⼤佬将⽤于找到上⼀个节点的标记添加每个节点⾥ path = []while len(queue) > 0:node = queue.pop()path.append(node)for func in li:next_node = func(node[0], node[1])if maze[next_node[0]][next_node[1]] == 0:cur_node = (next_node[0], next_node[1], len(path) - 1)queue.append(cur_node)maze[next_node[0]][next_node[1]] = 2if next_node[0] == x2 and next_node[1] == y2:result_li = []node = queue.pop()while node[2] != -1:result_li.append((node[0], node[1]))node = path[node[2]]else:result_li.append((x1, y1))result_li.reverse()return result_lielse:print("没有路径!")***待补充***。

《数据结构》上机实验报告—利用栈实现迷宫求解

《数据结构》上机实验报告—利用栈实现迷宫求解实验目的：掌握栈的基本操作和迷宫求解的算法，并能够利用栈实现迷宫求解。

实验原理：迷宫求解是一个常见的路径问题，其中最常见的方法之一是采用栈来实现。

栈是一种先进后出的数据结构，适用于这种类型的问题。

实验步骤：1.创建一个迷宫对象，并初始化迷宫地图。

2.创建一个栈对象，用于存储待探索的路径。

3.将起点入栈。

4.循环执行以下步骤，直到找到一个通向终点的路径或栈为空：a)将栈顶元素出栈，并标记为已访问。

b)检查当前位置是否为终点，若是则路径已找到，结束。

c)检查当前位置的上、下、左、右四个方向的相邻位置，若未访问过且可以通行，则将其入栈。

5.若栈为空，则迷宫中不存在通向终点的路径。

实验结果：经过多次实验，发现利用栈实现迷宫求解的算法能够较快地找到一条通向终点的路径。

在实验中，迷宫的地图可通过一个二维数组表示，其中0表示可通行的路径，1表示墙壁。

实验结果显示，该算法能够正确地找出所有可行的路径，并找到最短路径。

实验结果还显示，该算法对于大型迷宫来说，解决速度相对较慢。

实验总结：通过本次实验，我掌握了利用栈实现迷宫求解的算法。

栈作为一种先进后出的数据结构，非常适合解决一些路径的问题。

通过实现迷宫求解算法，我深入了解了栈的基本操作，并学会运用栈来解决实际问题。

此外，我还了解到迷宫求解是一个复杂度较高的问题，对于大型迷宫来说，解决时间较长。

因此，在实际应用中需要权衡算法的速度和性能。

在今后的学习中，我将进一步加深对栈的理解，并掌握其他数据结构和算法。

我还将学习更多的路径算法，以便更好地解决迷宫类问题。

掌握这些知识将有助于我解决更加复杂的问题，并提升编程能力。

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

目录1 前言 (1)2 需求分析 (1)2.1课程设计目的 (1)2.2课程设计任务 (1)2.3设计环境 (1)3 概要设计 (1)3.1数据结构设计 (1)3.2模块设计 (2)4 详细设计 (3)4．1数据类型的定义........................................... 错误！未定义书签。

4．2主要模块的算法描述.................................. 错误！未定义书签。

5 测试分析 (6)6 课程设计总结 (7)参考文献 (8)致谢 (8)附录（程序代码实现） (9)1 前言设计一个简单迷宫程序，从入口出发，按某一方向向前探索，若能走通（未走过的），即某处可以到达，则到达新点，否则试探下一方向；若所有方向均没有通路，则沿原点返回前一点，换下一个方向在继续试探，直到所有可能的通路都探索到，或找到一条通路，或无路可走又返回到入口点。

并利用两种方法实现：一种用栈实现，另一种用队列实现。

2 需求分析2.1课程设计目的学生在教师指导下运用所学课程的知识来研究、解决一些具有一定综合性问题的专业课题。

通过课程设计（论文），提高学生综合运用所学知识来解决实际问题、使用文献资料、及进行科学实验或技术设计的初步能力，为毕业设计（论文）打基础。

2.2课程设计任务给出一个任意大小的迷宫数据，求出一条走出迷宫的路径，输出迷宫并将所求路径输出。

要求用两种方法实现：一种用栈实现，另一种用队列实现。

，我主要负责队列方面2.3设计环境（1）WINDOWS 2000/2003/XP/7/Vist a系统（2）Visual C++或TC集成开发环境3 概要设计3.1数据结构设计（1）迷宫类型设迷宫为M行N列，利用maze[M][N]来表示一个迷宫，maze=0或1，其中0表示通路，1表示不通。

当从某点试探是，中间点有8个不同点可以试探，而四个角有3个方向，其他边缘点有5个方向，为使问题更容易分析我们用maze[M+2][N+2]来表示迷宫，而迷宫四周的值全部为1。

数据结构实验报告-栈和队列(迷宫图最短路径)

目录一、实验要求（需求分析） (1)a. 实验目的 (1)b. 实验内容 (2)c．程序功能 (2)二、程序分析 (2)2.1 存储结构 (2)2.2 关键算法分析 (3)三、程序运行分析 (7)1.程序运行流程图： (7)2.程序运行结果截图： (8)四．总结 (10)五、附录 (11)一、实验要求（需求分析）a. 实验目的通过实验，掌握如下内容：➢进一步掌握指针、模板类、异常处理的使用➢掌握队列的操作的实现方法➢学习使用队列解决实际问题的能力➢学习使用图的广度优先搜索解决实际问题的能力b. 实验内容利用队的结构实现迷宫求解问题。

迷宫求解问题如下：心理学家把一只老鼠从一个无顶盖的大盒子的入口赶进迷宫，迷宫中设置很多隔壁，对前进方向形成了多处障碍，心理学家在迷宫的唯一出口放置了一块奶酪，吸引老鼠在迷宫中寻找通路以到达出口，测试算法的迷宫如下图所示。

c．程序功能输入起始点的坐标，输出走出迷宫最短路径的长度。

二、程序分析2.1 存储结构存储结构: 队列顺序存储结构示意图如下:2.2 关键算法分析核心算法思想：1.如果采用直接递归的方式，用栈很容易实现路径的输出，但是这条路径不一定是最短路径。

为了改进算法，达到输出最短路径的目标，采用队列的实现方式。

2.为查找最短路径，使用了“图”中的算法：广度优先搜索。

关键算法思想描述和实现：关键算法1：为寻求最短路径，采用广度优先搜索算法，使用队列实现路径存储，队列中每个元素用结构体存储系，包含迷宫坐标、队列中的序号、父节点的序号，实现了对路径的记录。

C++实现：struct Node{int parent_id; //保存父节点的位置int node_id; //当前节点的序号，以便传递给孩子节点int x,y; //当前结点对应的坐标}Q[10*10]; //每个节点包含迷宫坐标、队列中的序号、父节点的序号，多个节点形成队列关键算法2：遍历每个位置四周的位置，将没有走过的位置入队，形成树形的队列，通过出队操作就能找到最短路径。

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

void pushd( long int a ) /* 数字入栈 */
{
prd.dat[ prd.top++ ]=a; }
void pusht( char a )
/* 符号入栈 */
{
prt.dat[ prt.top++ ]=a; }
long int popd( )
/* 数字出栈 */
{
return prd.dat[ --prd.top ]; }
while ( *p!='#' || prt.dat[prt.top-1]!='#' )
{ if ( *p>='0' && *p<='9') { j = numble(); /* 如果是数字进行整理并入栈 */
pushd( j );
}
else /* 如果是符号与栈顶的符号比较并运算 */
{ if ( flag==1 && *p=='(' )
} }
int signswitch( char a )
/* 符号转换 */
{ switch( a )
{ case '+': return 0; case '-': return 1;
case '*': return 2; case '/': return 3;
case '%': return 4; case '^': return 5;
case '(': return 6; case ')': return 7;
case '#': return 8;
default: printf("Error No. 2\n"); exit(1);
}
}
char refusal ( char a,char b ) /* 判定优先级 */
{
return PRI[signswitch(a)][signswitch(b)];
}
void main( ) { int i,j,k,l, flag=0; /* flag=0前一个符号不是) */ char b; prt.dat[0]='#'; prt.top=1; prd.top=0; printf ("Enter Expression="); scanf("%s", chinput); /* 接收运算式 */ strcat ( chinput, "#"); /* 在运算式结尾加#号 */ p = chinput; .... printf("%d\n",prd.dat[prd.top-1]);/* 输出 */ }
{
case '<': pusht ( *p++ ); /* 高则入栈 */
break;
case '=': popt( ); /* 脱括号 */
p++;
break;
case '>': b = popt(); /* 低则进行栈顶计算 */
k = popd(); /* 第二操作数出栈 */
l = popd(); /* 第一操作数出栈 */
{ printf("Error No.1:%s\n", p); exit(0);
}
else if ( *p==')') flag=1;
else
flag=0;
switch ( refusal(prt.dat[prt.top-1], *p ) )
{ .... }
}
}
switch ( refusal(prt.dat[prt.top-1], *p ) )
return b; }
long operation ( long int x, long int y, char a ) { switch( a )
{ case '+': return x+y; case '-': return x-y; case '*': return x*y; case '/': if ( y ) return x/y; else { printf("Divide 0.\n"); exit(0); } case '%': return (long int) fmod(x,y); case '^': if (y>=0 ) return (long) pow(x,y); else return (0); default: printf("Error No. 3\n"); exit(1);
char popt( )
/* 符号出栈 */
{
rn prt.dat[ --prt.top ]; }
long int numble ( ) /* 数字整理 */
{
long int b=0;
do
{
b = b*10 + *p -'0';
p++;
}
while ( *p>='0' && *p<='9' ) ;
k = operation(l,k,b);
/* 计算 */
pushd(k); /* 计算结果入栈 */
break;
case Nul: printf("Error No. 4:%s\n", p);
exit(1);
}
3.2 栈的应用举例
• 迷宫求解
入口
如何走出迷宫？
出口
• 求迷宫路径算法
若当前位置“可通”，入
则纳入路径，继续前进；口
若当前位置“不可
1
4
通”，后退一个位置， 2
5
换方向继续探索；
若四周“均已探索”， 3
6
则后退一步，将当前位
置从路径中删除出去，
换方向继续探索。
1 2 335 864 9
7 8 9 出口