栈和队列求解迷宫问题(数据结构学习笔记)


迷宫问题

给定一个M*N的迷宫图、入口与出口、行走规则。求一条从指定入口到出口的路径(这里M=8,N=8),所求路径必须是简单路径,即路径不重复 (为了方便算法起见,在整个迷宫外围加上一堵墙)

在这里插入图片描述

这里分别使用栈和队列两种方法求解迷宫问题,并比较两种算法的具体体现。

“栈”求解迷宫问题

行走规则

上、下、左、右相邻的方块行走。其中(i,j)表示一个方块

在这里插入图片描述

算法思路

1、用二维数组存放0,1来分别表示迷宫中可走方块以及不可走方块。

2、从入口处开始,顺时针方向去试探当前方块的四个方位

在这里插入图片描述

3、在当前位置寻找四个方位中的可走方块。
若当前试探方位可走。则将该试探方位的方块入栈,并将此时走过的方块置为不可走(这里将值置为-1),以防止两个方块来回进入死循环,此时试探方位的方块在栈的顶部,再用栈顶方块继续对四个方位进行试探。
若当前方块的四个试探方位都无法前进。则将当前方块退栈,并将退栈方块的值恢复为0,然后找此时栈顶方块的其他可能的相邻方块。

当所有相邻方块都不能走时的情况
在这里插入图片描述

算法代码

栈的定义
//定义方块类型
typedef struct
{
    int i;  //当前方块的行号
    int j;  //当前方块的列好
    int dj; //下个可走相邻方位的方位号
}Box;
//定义顺序栈类型
typedef struct
{
    Box data[MaxSize];
    int top;    //栈顶指针
}StType;
算法设计
bool mgpath(int xi,int yi,int xe,int ye)
{
	Box path[10000],e;	//path数组用来记录迷宫路径,e用来记录栈顶元素 
	StType *st;		//定义栈st 
	int i,j,di;		//i,j,di用于记录栈顶元素 
	int in,jn;		//用于记录下一方位的方块行列坐标 
	int k;				 
	int find;	//记录是否找到相邻可走元素 
	InitStack(st);	//初始化栈
	
	e.i=xi,e.j=yi,e.di=-1;
	Push(st,e);
	mg[xi][yi]=-1;
	
	
	while(!StackEmpty(st)){
		GetTop(st,e);	//取出栈顶元素 
		i=e.i,j=e.j,di=e.di;
		if(i==xe&&j==ye){	//已到达终点 
			printf("一条迷宫路径如下:\n");
			k=0;
			while(!StackEmpty(st)){
				Pop(st,e);
				path[k++]=e;
			}
			while(k>=1)
			{
				k--;
		                printf("\t(%d,%d)",path[k].i,path[k].j);
				if((k+2)%5==0)	
					printf("\n");	//每输出5个方块后换一行 
			}
			printf("\n");
			DestroyStack(st);	//销毁栈 
			return true;
		}
		
		find=0; //初始化为0,未找到可走相邻方块 
		while(di<4&&find==0){	 
			di++;
			switch(di){
				case 0:{in=i-1,jn=j;break;}
				case 1:{in=i;jn=j+1;break;}
				case 2:{in=i+1;jn=j;break;}
				case 3:{in=i;jn=j-1;break;}
			}
			if(mg[in][jn]==0)	//找到可走相邻方块 
				find=1;	
		}
		
		if(find){	//找到可走相邻方块 
			st->data[st->top].di=di; //修改原栈顶元素的di值 
			e.i=in,e.j=jn,e.di=-1;
			Push(st,e);	//入栈操作 
			mg[in][jn]=-1; 
		}
		else{	//没有可走相邻方块 
			Pop(st,e);	//退栈操作 
			mg[e.i][e.j]=0;	//将退栈方块位置的值恢复为 0 
		}
	}
	DestroyStack(st);	//销毁栈 
	return false;	//表示没有可走路径,返回false 
}
完整代码
#include <stdio.h>
#include <stdlib.h>
#define M 8
#define N 8

typedef struct
{
	int i;
	int j;
	int di;
}Box;

typedef struct
{
	Box data[10000];
	int top;
}StType;

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

//初始化栈 
void InitStack(StType *&st)
{
	st=(StType *)malloc(sizeof(StType));
	st->top=-1;
}
//取出栈顶元素 
void GetTop(StType *&st,Box &e)
{
	e=st->data[st->top];
}
//入栈 
void Push(StType *&st,Box &e)
{
	st->top++;
	st->data[st->top]=e;
}
//出栈 
void Pop(StType *&st,Box &e)
{
	e=st->data[st->top];
	st->top--;
}
//销毁栈 
void DestroyStack(StType *&st)
{
	free(st);
}
//检验栈是否为空 
bool StackEmpty(StType *&st)
{
	if(st->top==-1)
		return true;
	
	return false;
}

bool mgpath(int xi,int yi,int xe,int ye)
{
	Box path[10000],e;	//path数组用来记录迷宫路径,e用来记录栈顶元素 
	StType *st;		//定义栈st 
	int i,j,di;		//i,j,di用于记录栈顶元素 
	int in,jn;		//用于记录下一方位的方块行列坐标 
	int k;				 
	int find;	//记录是否找到相邻可走元素 
	InitStack(st);	//初始化栈
	
	e.i=xi,e.j=yi,e.di=-1;
	Push(st,e);
	mg[xi][yi]=-1;
	
	
	while(!StackEmpty(st)){
		GetTop(st,e);	//取出栈顶元素 
		i=e.i,j=e.j,di=e.di;
		if(i==xe&&j==ye){	//已到达终点 
			printf("一条迷宫路径如下:\n");
			k=0;
			while(!StackEmpty(st)){
				Pop(st,e);
				path[k++]=e;
			}
			while(k>=1)
			{
				k--;
				printf("\t(%d,%d)",path[k].i,path[k].j);
				if((k+2)%5==0)	
					printf("\n");	//每输出5个方块后换一行 
			}
			printf("\n");
			DestroyStack(st);	//销毁栈 
			return true;
		}
		
		find=0; //初始化为0,未找到可走相邻方块 
		while(di<4&&find==0){	 
			di++;
			switch(di){
				case 0:{in=i-1,jn=j;break;}
				case 1:{in=i;jn=j+1;break;}
				case 2:{in=i+1;jn=j;break;}
				case 3:{in=i;jn=j-1;break;}
			}
			if(mg[in][jn]==0)	//找到可走相邻方块 
				find=1;	
		}
		
		if(find){	//找到可走相邻方块 
			st->data[st->top].di=di; //修改原栈顶元素的di值 
			e.i=in,e.j=jn,e.di=-1;
			Push(st,e);	//入栈操作 
			mg[in][jn]=-1; 
		}
		else{	//没有可走相邻方块 
			Pop(st,e);	//退栈操作 
			mg[e.i][e.j]=0;	//将退栈方块位置的值恢复为 0 
		}
	}
	DestroyStack(st);	//销毁栈 
	return false;	//表示没有可走路径,返回false 
}

int main()
{
	if(!mgpath(1,1,M,N))
		printf("该迷宫问题没有解");
		
	return 0;
}

最终迷宫路径

在这里插入图片描述

算法总结

  • 很显然栈求解迷宫问题,只是给出解决迷宫问题的其中一条路径,并非最优路径

“队列”求解迷宫问题

例如此迷宫:
在这里插入图片描述

算法思路

将所有相邻的可走方块进入队列,在队列中一层一层的去从出口反向寻找入口(要记录当前此可走相邻方块的前一个方块位置)

在这里插入图片描述

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vJOKQAAh-1607934602965)(/assets/blogImg/migong/migong8.png)]

算法代码

队列定义
typedef struct
{
	int i,j;	//记录方块的行数与列数 
	int pre;	//记录本路径上一方块在队列中的下标 
}Box; 

typedef struct
{
	Box data[1000];
	int front,rear;	//队头队尾指针 
}Que;
算法设计
//迷宫算法函数
bool mgpath1(int xi,int yi,int xe,int ye)
{
	Box e;
	int i,j,pre;
	Que *qu;
	InitQue(qu);	//初始化队列 
	
	//起点入队
	e.i=xi,e.j=yi,e.pre=-1;	
	mg[xi][yi]=-1;
	Push(qu,e);		 
	
	while(!EmptyQue(qu)){	//队列不空则循环 
		Pop(qu,e);	//队首元素出队 
		i=e.i,j=e.j,pre=e.pre;	//记录当前队首元素的方块类 
		if(i==xe&&j==ye){	//队首元素为出口则输出路径 
			print(qu,qu->front);	//输出路径函数 
			return true;
		}
		
		int d=-1;
		int in,jn;
		while(d<4){	//每个方位进行试探 
			d++;
			switch(d){
				case 0:{in=i-1,jn=j;break;}
				case 1:{in=i;jn=j+1;break;}
				case 2:{in=i+1;jn=j;break;}
				case 3:{in=i;jn=j-1;break;}
			}
			if(mg[in][jn]==0){	//找到可走相邻方块(in,jn)就入队 
				e.i=in,e.j=jn,e.pre=qu->front;
				Push(qu,e);
				mg[in][jn]=-1;	//将其赋值-1,以避免来回重复搜索 
			}
		}
	}
	DestroyQue(qu);	//销毁队列 
	return false;
}
//输出路径函数
void print(Que *&qu,int k)
{
	int j;
	//反向寻找最短路径 
	while(k!=-1){
		j=k;
		k=qu->data[k].pre;
		qu->data[j].pre=-1;	//将找到的路径上的方块的pre成员置为-1 
	}
	
	k=0;
	int ns=0;
	while(k<1000){	//遍历整个队列输出pre成员为-1的方块坐标 
		if(qu->data[k].pre==-1){
			ns++;
			printf("\t(%d,%d)",qu->data[k].i,qu->data[k].j);
			if(ns%5==0)	 printf("\n");	//每输出5个元素后换一行 
		}
		k++;
	}
	printf("\n");
}
完整代码
#include <stdio.h>
#include <stdlib.h>
#define M 4
#define N 4

typedef struct
{
	int i,j;	//记录方块的行数与列数 
	int pre;	//记录本路径上一方块在队列中的下标 
}Box; 

typedef struct
{
	Box data[1000];
	int front,rear;	//队头队尾指针 
}Que;

int mg[M+2][N+2]=
	{	{1, 1, 1, 1, 1, 1},
		{1, 0, 0, 0, 1, 1},
		{1, 0, 1, 0, 0, 1},
		{1, 0, 0, 0, 1, 1},
		{1, 1, 0, 0, 0, 1},
		{1, 1, 1, 1, 1, 1}
	};

void InitQue(Que *&qu)
{
	qu=(Que *)malloc(sizeof(Que));
	qu->front=qu->rear=-1;
}

bool EmptyQue(Que *&qu)
{
	return (qu->front==qu->rear);
}

bool Push(Que *&qu,Box &e)
{
	if(qu->rear>999)
		return false;
	e.pre=qu->front;
	qu->rear++;
	qu->data[qu->rear]=e;
	return true;
}

bool Pop(Que *&qu,Box &e)
{
	if(EmptyQue(qu))
		return false;
	qu->front++;
	e=qu->data[qu->front];
	return true;
}

void print(Que *&qu,int k)
{
	int j;
	//反向寻找最短路径 
	while(k!=-1){
		j=k;
		k=qu->data[k].pre;
		qu->data[j].pre=-1;	//将找到的路径上的方块的pre成员置为-1 
	}
	
	k=0;
	int ns=0;
	while(k<1000){	//遍历整个队列输出pre成员为-1的方块坐标 
		if(qu->data[k].pre==-1){
			ns++;
			printf("\t(%d,%d)",qu->data[k].i,qu->data[k].j);
			if(ns%5==0)	 printf("\n");	//每输出5个元素后换一行 
		}
		k++;
	}
	printf("\n");
}

void DestroyQue(Que *&qu)
{
	free(qu);
}

bool mgpath1(int xi,int yi,int xe,int ye)
{
	Box e;
	int i,j,pre;
	Que *qu;
	InitQue(qu);	//初始化队列 
	
	//起点入队
	e.i=xi,e.j=yi,e.pre=-1;	
	mg[xi][yi]=-1;
	Push(qu,e);		 
	
	while(!EmptyQue(qu)){	//队列不空则循环 
		Pop(qu,e);	//队首元素出队 
		i=e.i,j=e.j,pre=e.pre;	//记录当前队首元素的方块类 
		if(i==xe&&j==ye){	//队首元素为出口则输出路径 
			print(qu,qu->front);	//输出路径函数 
			return true;
		}
		
		int d=-1;
		int in,jn;
		while(d<4){	//每个方位进行试探 
			d++;
			switch(d){
				case 0:{in=i-1,jn=j;break;}
				case 1:{in=i;jn=j+1;break;}
				case 2:{in=i+1;jn=j;break;}
				case 3:{in=i;jn=j-1;break;}
			}
			if(mg[in][jn]==0){	//找到可走相邻方块(in,jn)就入队 
				e.i=in,e.j=jn,e.pre=qu->front;
				Push(qu,e);
				mg[in][jn]=-1;	//将其赋值-1,以避免来回重复搜索 
			}
		}
	}
	DestroyQue(qu);	//销毁队列 
	return false;
}

int main()
{
	if(!mgpath1(1,1,M,N))
		printf("此迷宫问题无解");
		
	return 0;
}

最终迷宫路径(小迷宫)

在这里插入图片描述

最终迷宫路径(原题迷宫)

10

算法总结

  • 队列求解迷宫问题可以解决迷宫问题中最优(短)路径解的问题

  • 学习数据结构教程(第五版)——李春葆教授主编

  • 图片来源于MOOC,数据结构——武汉大学——李春葆教授

  • (如若侵权可联系QQ删除)

  • 175
    点赞
  • 1126
    收藏
    觉得还不错? 一键收藏
  • 16
    评论
程序在VC++ 6下顺利编译通过。 一、 实验目的: (1) 熟练掌握链的基本操作及应用。 (2) 利用链表作为的存储结构,设计实现一个求解迷宫的非递归程序。 二、实验内容: 【问题描述】 以一个m×n的长方阵表示迷宫,0和1分别表示迷宫中的通路和障碍。设计一个程序,对信任意设定的迷宫,求出一条从入口到出口的通路,或得出没有通路的结论。 【基本要求】 首先实现一个链表作存储结构的类型,然后编写一个求解迷宫的非递归程序。求得的通路以三元组(i,j,d)的形式输出,其中:(i,j)指示迷宫中的一个坐标,d表示走到下一坐标的方向。如:对于下列数据的迷宫,输出的一条通路为:(1,1,1),(1,2,2),(2,2,2),(3,2,3),(3,1,2),……。 【测试数据】 迷宫的测试数据如下:左上角(1,1)为入口,右下角(8,9)为出口。 1 2 3 4 5 6 7 8 0 0 1 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 0 0 1 1 0 1 0 1 1 1 0 0 1 0 0 0 0 1 0 0 0 0 0 1 0 0 0 1 0 1 0 1 1 1 1 0 0 1 1 1 0 0 0 1 0 1 1 1 0 0 0 0 0 0 以方阵形式输出迷宫及其通路。 输出: 请输入迷宫的长和宽:5 5 请输入迷宫内容: 0 1 1 0 0 0 0 1 1 0 1 0 0 1 1 1 0 0 1 0 1 1 0 0 0 迷宫的路径为 括号内的内容分别表示为(行坐标,列坐标,数字化方向,方向) (1,1,1,↓) (2,1,2,→) (2,2,1,↓) (3,2,1,↓) (4,2,2,→) (4,3,1,↓) (5,3,2,→) (5,4,2,→) (5,5,0,) 迷宫路径探索成功!
迷宫问题是一个经典的算法问题,可以使用Java中的数据结构栈和队列来解决。下面是一个使用栈和队列解决迷宫问题的示例代码: ```java import java.util.*; public class MazeSolver { private static final int[][] DIRECTIONS = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}}; // 上下左右四个方向 public static boolean solveMaze(int[][] maze, int startX, int startY, int endX, int endY) { int rows = maze.length; int cols = maze[0].length; boolean[][] visited = new boolean[rows][cols]; // 记录是否访问过 visited[startX][startY] = true; Stack<int[]> stack = new Stack<>(); // 使用来进行深度优先搜索 stack.push(new int[]{startX, startY}); while (!stack.isEmpty()) { int[] curr = stack.pop(); int currX = curr[0]; int currY = curr[1]; if (currX == endX && currY == endY) { return true; // 找到终点 } for (int[] dir : DIRECTIONS) { int nextX = currX + dir[0]; int nextY = currY + dir[1]; if (nextX >= 0 && nextX < rows && nextY >= 0 && nextY < cols && maze[nextX][nextY] == 0 && !visited[nextX][nextY]) { stack.push(new int[]{nextX, nextY}); visited[nextX][nextY] = true; } } } return false; // 无法找到路径 } public static void main(String[] args) { int[][] maze = { {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 startX = 0; int startY = 0; int endX = 4; int endY = 4; boolean canSolve = solveMaze(maze, startX, startY, endX, endY); System.out.println("Can solve maze: " + canSolve); } } ``` 这段代码使用了一个二维数组来表示迷宫,其中0表示可以通过的路径,1表示墙壁。通过深度优先搜索的方式,使用来记录路径,直到找到终点或者无法找到路径为止。

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值