实验三 栈和队列的综合应用迷宫问题

最新推荐文章于 2022-01-22 11:35:00 发布
最新推荐文章于 2022-01-22 11:35:00 发布
阅读量2.8k 收藏 68
点赞数 13
分类专栏： 数据结构 文章标签： 多多训练
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43310774/article/details/102863428
版权

迷宫问题。假设迷宫由m行n列构成，有一个入口和一个出口，入口坐标为（1，1），出口坐标为（m，n），试设计并验证以下算法：找出一条从入口通往出口的路径，或报告一个“无法通过”的信息。
(1) 用C语言实现顺序存储结构上队列的基本操作，然后利用该队列的基本操作找出迷宫的一条最短路径。
(2) 设计一个二维数组MAZE[m+2][n+2]表示迷宫，数组元素为0表示该位置可以通过，数组元素为1表示该位置不可以通行。MAZE[1][1]、MAZE[m][n]分别为迷宫的入口和出口。
(3) 输入迷宫的大小m行和n列，动态生成二维数组；由随机数产生0或1，建立迷宫，注意m*n的迷宫需要进行扩展，扩展部分的元素设置为1，相当于在迷宫周围布上一圈不准通过的墙。
(4) 要求输出模拟迷宫的二维数组；若存在最短路经，则由出口回溯到入口（出队列并利用栈实现），再打印从入口到出口的这条路径，例如(1,1)，……，(i,j)，……，(m,n)；若没有路径，则打印“No path!”。
(5) 迷宫的任一位置(i,j)上均有八个可以移动的方向，用二维数组Direction存放八个方向上的位置偏移量。
Direction[8][2]={{0,1},{1,1},{0,-1},{-1,-1},{1,1},{0,-1},{-1,-1},{0,1}};
(6) 为避免出现原地踏步的情况为了标志已经通过的位置，采用一个标志数组MARK[m+2][n+2]，初值均为0，在寻找路径的过程中，若通过了位置(i,j)，则将MARK[i][j]置为1。
(7) 为了记录查找过程中到达位置(i,j)及首次到达(i,j)的前一位置(i_pre,j_pre)，需要记住前一位置(i_pre,j_pre)在队列中的序号pre，即队列中数据元素应该是一个三元组(i,j,pre)。
(8) 搜索过程简单描述如下：将入口MAZE[1][1]作为第一个出发点，依次在八个方向上搜索可通行的位置，将可通行位置(i,j,pre)入队，形成第一层新的出发点，然后依次出队，即对第一层中各个位置分别搜索它所在八个方向上的可通行位置，形成第二层新的出发点，…，如此进行下去，直至达到出口MAZE[m][n]或者迷宫所有位置都搜索完毕为止。

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<malloc.h>
#include<conio.h>
#include<ctype.h>
#include<windows.h>
#include<time.h>

#define TURE 1
#define FLASE 0
#define ERROR 0
#define OVERFLOW -2
#define OK 1
#define INFLASEBLE -1
#define MaxSize 2500
#define Size 50
typedef int ElemType;
typedef int Status;
typedef struct {
	ElemType i;
	ElemType j;
	ElemType pre;
} LNode;
typedef struct {
	LNode data[MaxSize];
	ElemType front,rear;
} SqQueue;
Status InitQueue(SqQueue *Q) { //建立队列，使front，rear都指向0
	Q->front=0;
	Q->rear=0;
	return OK;
}
Status EnQueue(SqQueue *Q,ElemType x,ElemType y) { //坐标进队列
	(Q->data[Q->rear]).i=x;
	(Q->data[Q->rear]).j=y;
	(Q->data[Q->rear]).pre=Q->front;
	Q->rear++;
	return OK;
}
Status QueueEmpty(SqQueue Q) { //判断是否为空，空为假，不空为真
	if(Q.front==Q.rear) return FLASE;
	else return TURE;
}
//以上为队列
typedef struct {
	ElemType data[Size];
	ElemType top;
} SqStack;
Status InitStack(SqStack *S) { //使top的指针指向-1
	S->top=-1;
	return OK;
}
Status Push(SqStack *S,ElemType e) { //使栈顶的元素为e
	S->top++;
	S->data[S->top]=e;
	return OK;
}
ElemType Pop(SqStack *S,ElemType *e) { //使栈顶的元素出栈，且返回值为e
	*e=S->data[S->top];
	S->top--;
	return *e;
}
//以上为栈
Status PrintMigong(ElemType (*MAZE)[Size],ElemType m,ElemType n) {//打印迷宫
	ElemType i,j;
	printf("迷宫如下:\n");
	for(j=0; j<n+2; j++) {
		for(i=0; i<m+2; i++) {
			if(j==0) printf("%d ",i);
			else if(i==0) printf("%d",-j);
			else if(MAZE[i][j]==0)
				printf("□",MAZE[i][j]);
			else printf("■",MAZE[i][j]);
		}
		printf("\n");
	}
	return OK;
}
Status CreatMigong(ElemType (*MAZE)[Size],ElemType (*MARK)[Size],ElemType m,ElemType n) { //构造迷宫
	srand(time(NULL));
	ElemType i,j;
	for(i=0; i<m+2; i++)
		for(j=0; j<n+2; j++) {
			if(i==0||i==m+1||j==0||j==n+1)MAZE[i][j]=1;//建立围墙
			else MAZE[i][j]=rand()%2;//给迷宫的内部赋予随机数0或1
		}
	MAZE[1][1]=0,MAZE[m][n]=0;
	MARK[1][1]=1;//标记第一个点已经走
	return OK;
}
Status PrintPath(SqStack S,SqQueue Q,ElemType m,ElemType n) {//显示路径
	ElemType l,e;
	for(l=S.top; l>=0; l--) {
		Pop(&S,&e);
		printf("(%-2d,%-2d) -> ",Q.data[e].i,-Q.data[e].j);
	}
	printf("(%-2d,%-2d)\n",m,-n);
	return OK;
}
Status Sloution() {
	ElemType k,p,flag=0;
	ElemType nexti=1,nextj=1;
	//建立了队列Q，栈S
	SqQueue Q;
	SqStack S;
	InitQueue(&Q);
	InitStack(&S);
	ElemType Direction[8][2]= {{1,1},{0,1},{1,0},{-1,1},{1,-1},{0,-1},{-1,0},{-1,-1}};
	//用二维数组Direction存放八个方向上的位置偏移量
	ElemType MAZE[Size][Size]= {0}; //建立一个数组用于容纳迷宫
	ElemType MARK[Size][Size]= {0}; //建立一个标记是否走过的数组
	ElemType m,n;
	printf("请输入迷宫的行和列:");
	scanf("%d%d",&m,&n);//输入迷宫的行和列
	CreatMigong(MAZE,MARK,m,n);
	//打印迷宫
	PrintMigong(MAZE,m,n);
	//把起始点进入队列
	EnQueue(&Q,1,1);
	while(QueueEmpty(Q)) {
		for(k=0; k<8; k++) {//判断八个方向是否有可以走的，有就压进队列
			nexti=Q.data[Q.front].i+Direction[k][0];
			nextj=Q.data[Q.front].j+Direction[k][1];
			if(MAZE[nexti][nextj]||MARK[nexti][nextj]);
			else {
				MARK[nexti][nextj]=1;
				EnQueue(&Q,nexti,nextj);
				if(nexti==m&&nextj==n) { //一旦发现了出口，就退出循环
					flag=1;
					break;
				}
			}
		}
		Q.front++;//每判断完之后，头指针要加一
		if(flag==1) {//如果找到出口就压进栈中
			p=Q.rear-1;
			while(p) {
				p=Q.data[p].pre;
				Push(&S,p) ;
			}
			break;
		}
	}
	//输出迷宫路径
	printf("走出迷宫最短路经如下:\n");
	if(QueueEmpty(Q)) { //如果不是因为队列退出循环的，就把栈中的元素输出
		PrintPath(S,Q,m,n);
	} else printf("No path!\n");
	return OK;
}
int main() {
	while(1) {
		Sloution();
	}
	return 0;
}

2019年11月7日 11:55:58改版

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<malloc.h>
#include<conio.h>
#include<ctype.h>
#include<windows.h>
#include<time.h>

#define TURE 1
#define FLASE 0
#define ERROR 0
#define OVERFLOW -2
#define OK 1
#define INFLASEBLE -1
#define MaxSize 2510

typedef int ElemType;
typedef int Status;
typedef struct {
	ElemType i;
	ElemType j;
	ElemType pre;
} LNode;
typedef struct {
	ElemType m;
	ElemType n;
	ElemType **MAZE;
	ElemType **MARK;
} M;
typedef struct {
	LNode data[MaxSize];
	LNode *front,*rear;
} SqQueue;
Status InitQueue(SqQueue *Q) { //初始化队列，使front，rear都指向基准
	Q->front=Q->data;
	Q->rear=Q->data;
	Q->front->pre=0;
	return OK;
}
Status EnQueue(SqQueue *Q,ElemType x,ElemType y) {//坐标进队列
	Q->rear->i=x;
	Q->rear->j=y;
	Q->rear++;
	Q->rear->pre=(Q->rear-1)->pre+1;
	return OK;
}
Status QueueEmpty(SqQueue Q) { //判断队列是否为空
	if(Q.front==Q.rear) return FLASE;
	else return TURE;
}
//以上为队列
typedef struct {
	LNode data[MaxSize];
	LNode *top,*base;
} SqStack;
Status InitStack(SqStack *S) {//初始化 
	S->top=NULL;
	S->base=S->data;
	return OK;
}
Status emptyStack(SqStack S) {//初始化 
	if(S.top==S.data) return FLASE;
	else return TURE;
}
Status Push(SqStack *S,LNode e) {//使栈顶的元素结点为e
	if(S->top==NULL)
		S->top=S->data;
	else S->top++;
	S->top=&e;
	return OK;
}
Status Pop(SqStack *S,LNode *e) { //使栈顶的元素出栈，且返回值为e
	e=S->top;
	S->top--;
	return OK;
}
//以上为栈
Status CreatMigong(M *mg) ; //构造迷宫
Status PrintMigong(M *mg) ;//打印迷宫
Status Sloution(SqQueue *Q,SqStack *S,M *mg) ;//找最短路径
Status PrintPath(SqStack S,ElemType n) ;//打印最短路径
Status seek(SqQueue *Q,SqStack *S,M *mg) ;//找最短路径非递归写法
int main() {//主函数
	M mg;
	SqQueue Q;
	SqStack S;
	while(1) {
		CreatMigong(&mg);
		PrintMigong(&mg);
		Sloution(&Q,&S,&mg);
		PrintPath(S,(Q.rear-1)->pre);
	}
	return 0;
}
Status CreatMigong(M *mg) { //构造迷宫
	srand(time(NULL));
	ElemType i,j;
	do {
		printf("请输入迷宫的行和列:");
		scanf("%d%d",&(mg->m),&(mg->n));
	} while(mg->m<1&&mg->n<1||mg->m>=50||mg->n>=50);
	mg->MAZE = (ElemType**)malloc((mg->m+2)*sizeof(ElemType*));
	for(int i=0; i<(mg->m+2); i++)
		mg->MAZE[i] = (ElemType*)malloc((mg->n+2)*sizeof(ElemType));
	for(i=0; i<mg->m+2; i++)
		for(j=0; j<mg->n+2; j++) {
			if(i==0||i==mg->m+1||j==0||j==mg->n+1) mg->MAZE[i][j]=1;//建立围墙
			else mg->MAZE[i][j]=rand()%2;//给迷宫的内部赋予随机数0或1
		}
	mg->MAZE[1][1]=0,mg->MAZE[mg->m][mg->n]=0;
	return OK;
}
Status PrintMigong(M *mg) {//打印迷宫
	ElemType i,j;
	printf("迷宫如下:\n");
	for(j=0; j<mg->n+2; j++) {
		for(i=0; i<mg->m+2; i++) {
			if(i==0) printf("%3d",-j);
			else if(j==0) printf("%-2d",i);
			else if(mg->MAZE[i][j]==0) printf("□",mg->MAZE[i][j]);
			else printf("■",mg->MAZE[i][j]);
		}
		printf("\n");
	}
	return OK;
}
Status Sloution(SqQueue *Q,SqStack *S,M *mg) {//找最短路径
	ElemType i,flag=0;
	ElemType nexti=1,nextj=1;
	LNode *t;
	InitQueue(Q);
	InitStack(S);
	ElemType Direction[8][2]= {{1,1},{0,1},{1,0},{-1,1},{1,-1},{0,-1},{-1,0},{-1,-1}};
	mg->MARK = (ElemType**)malloc((mg->m+2)*sizeof(ElemType*));
	for(int i=0; i<(mg->m+2); i++)
		mg->MARK[i] = (ElemType*)calloc((mg->n+2),sizeof(ElemType));
	mg->MARK[1][1]=1;
	EnQueue(Q,1,1);
	while(QueueEmpty(*Q)) {
		for(i=0; i<8; i++) {
			nexti=Q->rear->i+Direction[i][0],nextj=Q->rear->j+Direction[i][1];
			if(mg->MAZE[nexti][nextj]||mg->MARK[nexti][nextj]);
			else {
				mg->MARK[nexti][nextj]=1;
				EnQueue(Q,nexti,nextj);
				if(nexti==mg->m&&nextj==mg->n) {
					flag=1;
					break;
				}
			}
		}
		if(flag==1) {
			t=Q->rear-1;
			while(t->pre) {
				Push(S,*t);
				t--;
			}
			break;
		}
	}
	return OK;
}
Status seek(SqQueue *Q,SqStack *S,M *mg) {//找最短路径非递归写法
	ElemType i;
	ElemType nexti=1,nextj=1;
	ElemType Direction[8][2]= {{1,1},{0,1},{1,0},{-1,1},{1,-1},{0,-1},{-1,0},{-1,-1}};
	while(QueueEmpty(*Q)) {
		for(i=0; i<8; i++) {
			nexti=Q->rear->i+Direction[i][0],nextj=Q->rear->j+Direction[i][1];
			if(mg->MAZE[nexti][nextj]||mg->MARK[nexti][nextj]);
			else {
				mg->MARK[nexti][nextj]=1;
				EnQueue(Q,nexti,nextj);
				Push(S,*(Q->rear-1));
				if(nexti==mg->m&&nextj==mg->n) {
					Push(S,*(Q->rear-1));
					return OK;
				}
			}
		}
		if(QueueEmpty(*Q)) {
			Pop(S,*(Q->rear-1));
			seek(Q,S,mg);
		} else return ERROR;
	}
}
Status PrintPath(SqStack S,ElemType n) {//打印最短路径
	ElemType i;
	LNode e;
	if(emptyStack(S)) printf("No path!\n");
	else {
		printf("走出迷宫最短路经如下:\n");
		for(i=0; i<n-1; i++) {
			Pop(&S,&e);
			printf("(%-2d,%-2d) -> ",e.i,-e.j);
		}
		Pop(&S,&e);
		printf("(%-2d,%-2d)",e.i,-e.j);
	}
	return OK;
}
小明同学喊你学习啦
关注
  • 13
    点赞
  • 踩
  • 68
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
程序设计综合实训-迷宫问题（I）
xingzi201的博客
08-12 630
这个题就是一个简单的深搜 不多说直接贴代码 #include<stdio.h> #include<stdlib.h> #define Max 100 #define MAX 10000 int Map[Max][Max]; int x1,x2,y1,y2,m,n,x3,y3,l,f; int jr[][2]={-1,0,1,0,0,-1,0,1};//用于上下左右移动 struct SeqStack /* 顺序栈类型定义 */ { int t; /* ..
程序设计综合实训-迷宫问题(II)
xingzi201的博客
08-12 426
简单的广搜 #include<stdio.h> #include<stdlib.h> #define MX 100 #define MAXSIZE 150//最大的限制 int sx,sy,ex,ey,m,n,l;//起始位置坐标sx,sy,目标位置坐标ex,ey,行,m,列,n，l用于判断是否有最短路径 int mp[MX][MX];//用于构造迷宫 int jr[][2]={-1,0,1,0,0,1,0,-1};//用于上下左右移动 typedef struct { ..
迷宫 题解
linweitong2020的博客
06-24 408
迷宫 题解 题目 在这里。 解题方法 这道题目的方法很显然是搜索。 dfsdfsdfs 直接dfsdfsdfs或记忆化dfsdfsdfs就行了，真的没啥好讲。 其实我不知道不用记忆化能不能满分。 bfsbfsbfs 直接按题意bfsbfsbfs。 ...
数据结构：迷宫
mxc111213_的博客
01-22 2359
迷宫问题。假设迷宫由m行n列构成，有一个入口和一个出口，入口坐标为（1，1），出口坐标为（m，n），试设计并验证以下算法：找出一条从入口通往出口的路径，或报告一个“无法通过”的信息。 (1) 用C语言实现顺序存储结构上队列的基本操作，然后利用该队列的基本操作找出迷宫的一条最短路径。 (2) 设计一个二维数组MAZE[m+2][n+2]表示迷宫，数组元素为0表示该位置可以通过，数组元素为1表示该位置不可以通行。MAZE[1][1]、MAZE[m][n]分别为迷宫的入口和出口。 (3) 输入迷宫的大小m行和n列
迷宫问题 假设迷宫由m行n列构成，有一个入口和一个出口，入口坐标为(1，1)，出口坐标为(m，n)，试找出一条从入口通往出口的最短路径。设计算法并编程输出一条通过迷宫的最短路径或报告一个“无法通过”的信息。
06-04
题目：假设迷宫由m行n列构成，有一个入口和一个出口，入口坐标为(1，1)，出口坐标为(m，n)，试找出一条从入口通往出口的最短路径。设计算法并编程输出一条通过迷宫的最短路径或报告一个“无法通过”的信息。 要求：用栈和队列实现，不允许使用递归算法。
实验三 栈和队列的应用.docx
07-12
实验三 栈和队列的应用.docx实验三 栈和队列的应用.docx实验三 栈和队列的应用.docx实验三 栈和队列的应用.docx实验三 栈和队列的应用.docx实验三 栈和队列的应用.docx实验三 栈和队列的应用.docx实验三 栈和队列的...
数据结构实验三栈和队列及其应用.pdf
07-12
数据结构实验三栈和队列及其应用.pdf数据结构实验三栈和队列及其应用.pdf数据结构实验三栈和队列及其应用.pdf数据结构实验三栈和队列及其应用.pdf数据结构实验三栈和队列及其应用.pdf数据结构实验三栈和队列及其应用...
实验三 栈和队列的应用.pdf
11-10
。。。
数据结构栈和队列解决迷宫问题
06-07
这个文档详细的介绍了利用栈和队列解决迷宫问题的步骤，对与初学者学习数据结构能很好的进行辅导
数据结构基础系列(3)：栈和队列
09-08
数据结构课程是计算机类专业的专业基础课程，在IT人才培养中，起着重要的作用。课程按照大学计算机类专业课程大纲的要求，安排教学内容，满足需要系统学习数据结构的人。系列课程包含11个部分，本课为第3部分栈和队列，介绍在系统软件和应用软件开发中大有用途的两种特殊线性表——栈和队列的构组成、存储结构的选择，以及基本运算的实现，通过相关的应用案例介绍了这些数据结构的应用方法。
数据结构（C语言版） 栈与队列 迷宫问题
06-10
数据结构 （C语言版）上面的第三章栈与队列中的迷宫问题。
分别用栈和队列实现迷宫
05-14
分别用栈和队列实现走迷宫的算法，电子工业出版社，叶核亚版的数据结构（java）课后习题，希望对大家有用。
用递归和非递归算法分别实现迷宫求解例子
06-21
由0和1构成的m*n维矩阵M表示一个迷宫，其中0表示通路，1表示墙壁。迷宫入口为(1,1),出口为(m,n)。迷宫随机产生。试编一算法求出从入口点到出口点可沿八个方向或四个方向前进的一条通路，或显示没有通路
实验报告栈和队列的操作实验报告
04-25
栈，队列，循环队列； 数据结构实验报告，循环队列打印杨辉三角
数据结构上机实验_栈和队列的应用_迷宫问题 （含代码和报告）
07-18
一． 实验题目：栈和队列的应用 二． 实验内容：迷宫问题 三．实验目的：掌握栈和队列的概念及工作原理，运用其原理完成实验题目中的内容。 四．实验要求：为了使学生更好的掌握与理解课堂上老师所讲的概念与原理，实验前每个学生要认真预习所做的实验内容及编写源程序伪码（写在纸上及盘中均可） 以便在实验课中完成老师所布置的实验内容 五．概要设计原理： 使用穷举求解的方法，即从入口出发，顺某一方向向前探索，若能走通，则继续往前走；否则沿原路退回，换一个方向再继续探索，直至所有可能的通路都被探索为止。
栈和队列的应用（迷宫问题）
qq_40502460的博客
06-05 2450
栈和队列的应用（迷宫问题） 栈——深度优先搜索 一条路走到黑，假设我们规定判断的方向为上，右，下，左。从起点开始，判断能走的方向，一直走到没有路可以走了，这时，将走过的路径上所有点的坐标存放进一个栈里面，执行一次出栈操作，判断后退一步后的位置是否有路可走，没有则继续出栈。如果栈空，则说明没有可以抵达终点的路径。否则一直走到达终点，栈内的元素组成了能走出迷宫的路线。但是使用栈实现的迷宫问题有一个缺点，它的路线不一定是最短的。 代码实现： maze = [ [1, 1, 1, 1, 1, 1, 1
栈与队列算法设计：(1)迷宫问题
weixin_43972499的博客
08-06 3353
目录1.题目2.题目分析 算法分析 算法实现3.参考代码4.测试结果 1.题目   迷宫问题的求解是实验心理学中的一个经典问题，心理学家把一只老鼠从一个无顶盖的大盒子的入口处赶进迷宫，迷宫中设置很多隔墙，对前进方向形成了多处障碍，心理学家在迷宫的唯一出口处放置了一块奶酪，吸引老鼠在迷宫中寻找通路以到达出口。设计算法实现迷宫求解。 2.题目分析  算法分析   1.这里我们使用的是栈来解决迷宫问题。    对于迷宫问题，我们常规的思维是——试错，即先随便找一条路，一直走下去，直到走到尽头，如果无法抵达出口，
(三)1.2_迷宫求解(使用队列)
鸣鼓ming的博客
12-02 4124
一.问题描述   1.迷宫问题.假设迷宫由m行n列构成,有一个入口和一个出口,入口坐标为(1,1),出口坐标为(m,n),设计一个算法,找出一条最短的路径,如果没有路径报告无法通过的信息.   2.输入m,n,用二维数组创建一个m行n列的迷宫   3.迷宫的任一位置(i,j)上均有八个可以移动的方向(上, 右上, 右, 右下, 下, 左下, 左, 左上) 二.思路分析   1.这里我们用队...
数据结构--栈和队列及应用--迷宫问题
WX_timi的博客
02-07 2591
数据结构–栈和队列及应用–迷宫问题 【实验目的】 使学生深入了解栈和队列的特性，以便在实际问题背景下灵活运用它们，同时还将巩固对这两种结构的构造方法的掌握及基本操作的实现。 【实验内容】 １、问题描述：以一个m×n的长方阵表示迷宫，0和1分别表示迷宫中的通路和障碍。设计一个程序，对任意设定的迷宫，求出一条从入口到出口的通路，或得到没有通路的结论。 ２、基本要求： 首先实现一个以链表作存储结构的栈类...
数据结构中队列和栈的综合应用感想
最新发布
12-20
队列和栈的综合应用可以帮助我们解决一些实际问题，以下是一些感想： 1. 队列和栈的综合应用可以实现任务调度。例如，在操作系统中，可以使用队列来管理进程的调度顺序，而栈可以用来保存函数调用的上下文信息。 2...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值