【顺序栈应用】迷宫求解

最新推荐文章于 2024-08-06 12:06:34 发布
最新推荐文章于 2024-08-06 12:06:34 发布
阅读量1.5k 收藏 41
点赞数 4
分类专栏： 数据结构与算法 文章标签： 算法 堆栈 stack 指针 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/flower1234568/article/details/114884122
版权

本文采用C语言应用顺序栈实现对迷宫问题的求解（走迷宫其实也蛮有意思的）

【问题描述】

采用“穷举求解”方法，从起点出发，顺某一方向向前探索，若能走通，则继续往前走；否则沿原路返回，换一个方向再继续探索。为了保证在任何位置上都能沿原路返回，需要用一个后进先出的顺序栈结构来保存从起点到当前位置的路径。

迷宫如图所示（代码中也可以自己更改）：

迷宫

(代码中'#'表示墙壁，‘ ’代表可以通过)

【算法思想】

迷宫求解

假设“当前位置”指的是”在搜索过程中某一时刻所在迷宫图中的某个方块的位置“，则求迷宫的一条路径的算法的基本思想可为：

1.若当前位置”可通“，则纳入”当前路径”，并继续朝”下一位置探索“，即切换”下一位置“为”当前位置“，如此重复直到到达出口；

2.若当前位置”不可通“，则应顺着”来向“退回到”前一通道块“。然后朝着除”来向“之外的其他方向继续探索；

3.若该通道块的四周方块均”不可通“，则应从”当前路径“上删除该通道块。

所谓”下一位置“指的是”当前位置“的四周4个方向上(东、南、西、北)相邻的方块。假设以栈S记录”当前路径“，则栈顶存放的是”当前路径上最后一个通道块“，由此，”纳入路径“的操作即为”当前位置入栈“；”从当前路径上删除前一通道块“的操作即为”出栈“。

算法思想

下面首先来熟悉一下栈的实现，top为指向栈顶元素的下一位置的指针，base为指向栈底元素的指针

一、栈类型的定义：

typedef struct
{
	SElemType *top;
	SElemType *base;
	int stacksize;
}Stack;

二、栈的相关操作

1、栈的初始化

//栈初始化
void InitStack(Stack **b)
{
	(*b)->base = (SElemType*)malloc(MAXSIZE * sizeof(SElemType));
	if (!b)  exit(OVERFLOW);
	(*b)->top = (*b)->base;
	(*b)->stacksize = MAXSIZE;
}

2、判断栈空


//栈空
Status StackEmpty(Stack *b)
{
	if (b->top == b->base)
	{
		return OK;
	}
	else
	{
		return ERROR;
	}
}

3、判断栈满

//栈满
Status StackFull(Stack *b)
{
	if (((b->top) - (b->base)) >= b->stacksize)
	{
		return OK;
	}
	else
	{
		return ERROR;
	}
}

4、入栈

//入栈
void Push(Stack **b, SElemType e)
{
	if (StackFull(*b))
	{
		exit(OVERFLOW);
	}
	*(*b)->top = e;
	(*b)->top = (*b)->top + 1;
}

5、出栈


//出栈
void Pop(Stack **b, SElemType *e)
{
	if (StackEmpty(*b))
	{
		exit(ERROR);
	}
	(*b)->top = (*b)->top - 1;
	*e = *(*b)->top;
}

三、定义地图


//地图，‘#’指墙壁
char map[MAPROW + 2][MAPCOL + 2] = {
	{'#', '#', '#', '#', '#', '#', '#', '#', '#', '#'},
	{'#', ' ', ' ', '#', ' ', ' ', ' ', '#', ' ', '#'},
	{'#', ' ', ' ', '#', ' ', ' ', ' ', '#', ' ', '#'},
	{'#', ' ', ' ', ' ', ' ', '#', '#', ' ', ' ', '#'},
	{'#', ' ', '#', '#', '#', ' ', ' ', ' ', ' ', '#'},
	{'#', ' ', ' ', ' ', '#', ' ', ' ', ' ', ' ', '#'},
	{'#', ' ', '#', ' ', ' ', ' ', '#', ' ', ' ', '#'},
	{'#', ' ', '#', '#', '#', ' ', '#', '#', ' ', '#'},
	{'#', ' ', ' ', ' ', ' ', '#', ' ', ' ', ' ', '#'},
	{'#', '#', '#', '#', '#', '#', '#', '#', '#', '#'}
};



//迷宫中的坐标位置
typedef struct pos
{
	int x;
	int y;
}pos;
typedef struct current
{
	pos seat;//当前位置
	int direction;//走向下一通道块的方向，顺时针方向：direction=1,2,3,4分别为东，南，西，北
}current;
typedef current SElemType;



pos start = { 1,1 };//设置迷宫起点
pos end = { MAPROW,MAPCOL };//设置迷宫终点

四、实现迷宫相应操作

1、对曾经经过的路径设置标记‘1’,方便寻找最短路径


//对曾经经过的路径设置标记`‘1'`,方便寻找最短路径
void beforesign(pos curpos)
{
	map[curpos.x][curpos.y] = '1';
}

2、对于曾经走过虽不是墙壁但是不通的路，标记'@'

//对于曾经走过虽不是墙壁但是不通的路，标记'@'
void nosign(pos curpos)
{
	map[curpos.x][curpos.y] = '@';
}

3、返回下一位置坐标

方向


//返回下一位置坐标
pos nextpos(pos curpos, int dir)
{
	switch (dir)
	{
	    case 1://向东走，行号不变，列号加一
			curpos.y = curpos.y + 1;
			break;
		case 2://向南走
			curpos.x = curpos.x + 1;
			break;
		case 3://向西走
			curpos.y = curpos.y - 1;
			break;
		case 4://向北走
			curpos.x = curpos.x - 1;
			break;
	}
	return curpos;
}

4、判断当前位置是否可通过，即为' ',而不是'#'墙，‘@’死路，‘1’已走过


//判断当前位置是否可通过，即为' ',而不是'#'墙，‘@’死路，‘1’已走过
bool pass(pos curpos)
{
	if (map[curpos.x][curpos.y] == ' ')
	{
		return true;
	}
	else
	{
		return false;
	}
}

5、看迷宫中是否存在一条从入口到出口的路，存放在栈中

注意使用结构体前一定要分配空间，即
Stack *s; s = (Stack*)malloc(sizeof(Stack));


//看迷宫中是否存在一条从入口到出口的路，存放在栈中
bool path(pos start,pos end)
{
	Stack *s;
	s = (Stack*)malloc(sizeof(Stack));
	InitStack(&s);
	pos curpos = start;//设置当前位置为入口
	if (pass(curpos))//如果该位置可以通过
	{
		beforesign(curpos);//作标记‘#’
		current cur;
		cur.seat = curpos;
		cur.direction = 1;
		Push(&s, cur);//将当前的方向和位置压栈
		curpos = nextpos(curpos, 1);//下一位置定为当前位置的东侧
	}
	while (!StackEmpty(s))
	{
		if (pass(curpos))//如果该位置可以通过
		{
			beforesign(curpos);//作标记‘#’
			current cur;
			cur.seat = curpos;
			cur.direction = 1;
			Push(&s, cur);//将当前的方向和位置压栈
			if ((curpos.x == end.x) && (curpos.y == end.y))//到达终点停止
			{
				return true;
			}
			curpos = nextpos(curpos, 1);//下一位置定为当前位置的东侧
		}
		else//如果该位置不能通过,则栈顶元素出栈，即刚刚走过的迷宫块退出
		{
			current cur;
			Pop(&s, &cur);//弹出栈顶元素，并将该元素存在cur中
			while ((cur.direction == 4) && (!StackEmpty(s)))
			{
				nosign(cur.seat);//标记该块四周均不可通
				Pop(&s, &cur);//继续弹出上一块的栈顶位置（即上一步的位置），存在cur中
			}
			if (cur.direction < 4)//如果弹出的当前位置还有别的方向没有探索，则继续探索
			{
				cur.direction = cur.direction + 1;//试探下一个方向
				Push(&s, cur);//将该方向的位置压入栈中
				curpos = nextpos(cur.seat, cur.direction);//计算在该方向的下一位置
			}
		}
	}
	return false;
}

四、输出地图相关函数
1、打印迷宫


//打印迷宫
void printmap()
{
	for (int i = 0; i < MAPROW + 2; i++)
	{
		for (int j = 0; j < MAPCOL + 2; j++)
		{
			printf("%c", map[i][j]);//打印完整的迷宫
		}
		printf("\n");
	}
	printf("\n");
}

2、仅打印通过迷宫的路径


//仅打印通过迷宫的路径
void printpath()
{
	for (int i = 0; i < MAPROW + 2; i++)
	{
		for (int j = 0; j < MAPCOL + 2; j++)
		{
			if ((map[i][j] == '#') || (map[i][j] == '1'))//仅打印墙壁和走过的迷宫路径
			{
				printf("%c", map[i][j]);
			}
			else
			{
				printf(" ");
			}
		}
		printf("\n");
	}
	printf("\n");
}

五、main函数测试


int main()
{
	printf("迷宫的初始状态为：\n");
	printmap();
	if (path(start, end))//如果有路径
	{
		printf("迷宫有路径可通过\n");
		printf("迷宫标识后的状态为：\n");
		printmap();
		printf("通过迷宫的路径为：\n");
		printpath();
	}
	else
	{
		printf("迷宫不存在可通过的路径\n");
	}
	return 0;
}

六、程序运行结果

（1）

（2）

（3）

七、完整代码（附注释）


#include<stdio.h>
#include<stdlib.h>
#define MAXSIZE 100
#define OK 1
#define ERROR 0
#define OVERFLOW -1
#define MAPROW 8
#define MAPCOL 8
typedef int Status;
//迷宫中的坐标位置
typedef struct pos
{
	int x;
	int y;
}pos;
typedef struct current
{
	pos seat;//当前位置
	int direction;//走向下一通道块的方向，顺时针方向：direction=1,2,3,4分别为东，南，西，北
}current;
typedef current SElemType;
typedef struct
{
	SElemType *top;
	SElemType *base;
	int stacksize;
}Stack;
//栈初始化
void InitStack(Stack **b)
{
	(*b)->base = (SElemType*)malloc(MAXSIZE * sizeof(SElemType));
	if (!b)  exit(OVERFLOW);
	(*b)->top = (*b)->base;
	(*b)->stacksize = MAXSIZE;
}
//栈空
Status StackEmpty(Stack *b)
{
	if (b->top == b->base)
	{
		return OK;
	}
	else
	{
		return ERROR;
	}
}
//栈满
Status StackFull(Stack *b)
{
	if (((b->top) - (b->base)) >= b->stacksize)
	{
		return OK;
	}
	else
	{
		return ERROR;
	}
}
//入栈
void Push(Stack **b, SElemType e)
{
	if (StackFull(*b))
	{
		exit(OVERFLOW);
	}
	*(*b)->top = e;
	(*b)->top = (*b)->top + 1;
}
//出栈
void Pop(Stack **b, SElemType *e)
{
	if (StackEmpty(*b))
	{
		exit(ERROR);
	}
	(*b)->top = (*b)->top - 1;
	*e = *(*b)->top;
}
//地图，‘#’指墙壁
char map[MAPROW + 2][MAPCOL + 2] = {
	{'#', '#', '#', '#', '#', '#', '#', '#', '#', '#'},
	{'#', ' ', ' ', '#', ' ', ' ', ' ', '#', ' ', '#'},
	{'#', ' ', ' ', '#', ' ', ' ', ' ', '#', ' ', '#'},
	{'#', ' ', ' ', ' ', ' ', '#', '#', ' ', ' ', '#'},
	{'#', ' ', '#', '#', '#', ' ', ' ', ' ', ' ', '#'},
	{'#', ' ', ' ', ' ', '#', ' ', ' ', ' ', ' ', '#'},
	{'#', ' ', '#', ' ', ' ', ' ', '#', ' ', ' ', '#'},
	{'#', ' ', '#', '#', '#', ' ', '#', '#', ' ', '#'},
	{'#', ' ', ' ', ' ', ' ', '#', ' ', ' ', ' ', '#'},
	{'#', '#', '#', '#', '#', '#', '#', '#', '#', '#'}
};
pos start = { 1,1 };//设置迷宫起点
pos end = { MAPROW,MAPCOL };//设置迷宫终点
//对曾经经过的路径设置标记‘1',方便寻找最短路径
void beforesign(pos curpos)
{
	map[curpos.x][curpos.y] = '1';
}
//对于曾经走过虽不是墙壁但是不通的路，标记'@'
void nosign(pos curpos)
{
	map[curpos.x][curpos.y] = '@';
}
//返回下一位置坐标
pos nextpos(pos curpos, int dir)
{
	switch (dir)
	{
	    case 1://向东走，行号不变，列号加一
			curpos.y = curpos.y + 1;
			break;
		case 2://向南走
			curpos.x = curpos.x + 1;
			break;
		case 3://向西走
			curpos.y = curpos.y - 1;
			break;
		case 4://向北走
			curpos.x = curpos.x - 1;
			break;
	}
	return curpos;
}
//判断当前位置是否可通过，即为' ',而不是'#'墙，‘@’死路，‘1’已走过
bool pass(pos curpos)
{
	if (map[curpos.x][curpos.y] == ' ')
	{
		return true;
	}
	else
	{
		return false;
	}
}
//看迷宫中是否存在一条从入口到出口的路，存放在栈中
bool path(pos start,pos end)
{
	Stack *s;
	s = (Stack*)malloc(sizeof(Stack));
	InitStack(&s);
	pos curpos = start;//设置当前位置为入口
	if (pass(curpos))//如果该位置可以通过
	{
		beforesign(curpos);//作标记‘#’
		current cur;
		cur.seat = curpos;
		cur.direction = 1;
		Push(&s, cur);//将当前的方向和位置压栈
		curpos = nextpos(curpos, 1);//下一位置定为当前位置的东侧
	}
	while (!StackEmpty(s))
	{
		if (pass(curpos))//如果该位置可以通过
		{
			beforesign(curpos);//作标记‘#’
			current cur;
			cur.seat = curpos;
			cur.direction = 1;
			Push(&s, cur);//将当前的方向和位置压栈
			if ((curpos.x == end.x) && (curpos.y == end.y))//到达终点停止
			{
				return true;
			}
			curpos = nextpos(curpos, 1);//下一位置定为当前位置的东侧
		}
		else//如果该位置不能通过,则栈顶元素出栈，即刚刚走过的迷宫块退出
		{
			current cur;
			Pop(&s, &cur);//弹出栈顶元素，并将该元素存在cur中
			while ((cur.direction == 4) && (!StackEmpty(s)))
			{
				nosign(cur.seat);//标记该块四周均不可通
				Pop(&s, &cur);//继续弹出上一块的栈顶位置（即上一步的位置），存在cur中
			}
			if (cur.direction < 4)//如果弹出的当前位置还有别的方向没有探索，则继续探索
			{
				cur.direction = cur.direction + 1;//试探下一个方向
				Push(&s, cur);//将该方向的位置压入栈中
				curpos = nextpos(cur.seat, cur.direction);//计算在该方向的下一位置
			}
		}
	}
	return false;
}
//打印迷宫
void printmap()
{
	for (int i = 0; i < MAPROW + 2; i++)
	{
		for (int j = 0; j < MAPCOL + 2; j++)
		{
			printf("%c", map[i][j]);//打印完整的迷宫
		}
		printf("\n");
	}
	printf("\n");
}
//仅打印通过迷宫的路径
void printpath()
{
	for (int i = 0; i < MAPROW + 2; i++)
	{
		for (int j = 0; j < MAPCOL + 2; j++)
		{
			if ((map[i][j] == '#') || (map[i][j] == '1'))//仅打印墙壁和走过的迷宫路径
			{
				printf("%c", map[i][j]);
			}
			else
			{
				printf(" ");
			}
		}
		printf("\n");
	}
	printf("\n");
}
int main()
{
	printf("迷宫的初始状态为：\n");
	printmap();
	if (path(start, end))//如果有路径
	{
		printf("迷宫有路径可通过\n");
		printf("迷宫标识后的状态为：\n");
		printmap();
		printf("通过迷宫的路径为：\n");
		printpath();
	}
	else
	{
		printf("迷宫不存在可通过的路径\n");
	}
	return 0;
}

越努力，越幸运

end~~~

computer_Fleur
关注
专栏目录
栈的应用：利用顺序栈求解迷宫问题（改编自严蔚敏算法）
小龙虾
07-06 1068
#include &lt;iostream&gt; #include &lt;stdio.h&gt; #include &lt;string.h&gt; #include &lt;stdlib.h&gt; #include &lt;math.h&gt; #define MAXSIZE 100 //定义栈的最大容量 int visited[10][10]; //全局变量，是一个长度和宽度和迷宫一...
栈和队列4 顺序栈的应用实例（迷宫求解）
4-5月更新计算机程序设计的一些实例，之后再更新计算机基础，机器智能相关的一些内容。
05-25 1375
if (a[x][y] == 0) //可通。
栈的应用--迷宫求解
qq_50804645的博客
05-29 3330
栈的应用–迷宫求解 思路: 从一个起点(1,1)坐标开始, 依次判断它的右,下,左,上, 方位能不能走 如果能就直接走, 每走一步将这个位置的坐标入栈, 并且标记为2, 若都不能走, 说明走到死路了, 要开始回溯,走过没有走过标记为3 回溯时就是把入栈的坐标出栈, 即可原路返回, 每返回一步就重新再判断它的 右,下,左,上, 能不能走,直到找到终点(8,8)坐标,否则没有通路 #include <stdio.h> #include <stdlib.h> #include &l
【数据结构与算法】迷宫求解------回溯法
最新发布
qq_74047911的博客
08-06 481
当我们想要找到迷宫的出口,那我们在计算机中,然后操作,可以将每个位置都人栈,然后进行上下左右的路的判断,能否通过,若是死路,就将这个点出栈,回退到刚刚的栈,再判断其他的道路.在同行同列且相邻且在二维数组范围内,值为1就是通道就可以下一步.就当前入口点入栈,然后做标记改为2,就是我们走过的地方.就出栈,进行判断上一个路口,是否可以其他的下一步.地图的结构就是一个二维数组,初始化就是进行赋值.只有我们的栈不为空或者找不到出口,那么就一直找.初始化栈就可以进入到我们的迷宫判断了.能下一步就做标记,入栈.
数据结构-顺序栈解决迷宫问题
代码屋-CODE HOUSE
06-01 1451
#include #include #include #define MaxSize 100 using namespace std; int M=4,N=4; int mg[6][6]= { {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}, {
栈的应用——迷宫求解
Mongo_girl
01-28 380
do｛        若当前位置可通，     则｛         将当前位置插入栈顶；          若该位置是出口位置，则算法结束；                     否则切换当前位置的东邻方块为新的当前位置；     ｝     否则 {            若栈不空且栈顶位置尚有其他方向未被探索，             则设定新的当前位置为: 沿顺时针方向旋转找到的栈顶位置...
栈在迷宫求解问题中的应用.pdf
03-16
在迷宫求解问题中，栈被广泛应用于回溯算法，以找到从起点到终点的有效路径。本实验的目标是让学生掌握栈的使用以及迷宫求解的基本算法。 实验内容主要包括以下几个部分： 1. 构造栈：定义一个链栈结构，包括栈顶...
C语言数据结构顺序栈之迷宫求解
01-15
本主题聚焦于“C语言数据结构顺序栈之迷宫求解”，这是一个结合了基本数据结构和算法的有趣应用。我们将深入探讨顺序栈、迷宫问题以及如何使用C语言实现迷宫求解算法。 顺序栈是一种线性数据结构，它的元素按照...
C语言数据结构顺序栈之迷宫求解最短路径
01-15
本节我们将深入探讨C语言实现的顺序栈在迷宫求解中最短路径的应用。 首先，我们需要理解“顺序栈”这一概念。顺序栈是数据结构中的基本类型，它是一种线性结构，其中元素按照特定顺序存储，只能在栈顶进行插入和...
顺序栈求解迷宫问题
BUG从入门到精通
11-12 1407
下图所示的迷宫，从（1,1）走到（8,8） int mg[10][10] = { //迷宫 {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,.
栈的应用 - 迷宫求解
05-09
很好的一个迷宫求解程序。此程序用0和1来随机产生一个迷宫，然后用栈的基本操作来实现迷宫的求解。很适合用于数据结构栈应用的课程设计。
数据结构-栈的应用-迷宫求解
04-16
使用栈结构完成迷宫求解算法演示，设计了GUI界面使算法演示更加直观
栈---求解迷宫问题
qq_38904904的博客
03-20 286
问题： 在迷宫中寻找一条路径 算法分析： 将迷宫数值化，使用二维数组来表示迷宫，墙单元用0，通道单元用1； 如果能够通过继续前进，如果不能通过则退回到上一个单元，因此用栈来存储通过的路径； 用0，1，2，3来分别表示4个方向 代码： #include "pch.h" #include <iostream> #include<stdio.h> #include ...
数据结构(2)--用栈实现迷宫问题的求解
IRVINGOS的博客
11-19 4182
数据结构--用栈实现迷宫问题的求解目录问题概述程序思路代码实现过程反思 目录 问题概述 我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdown编辑器功能，我们增加了如下几点新功能，帮助你用它写博客： 全新的界面设计 ，将会带来全新的写作体验； 在创作中心设置你喜爱的代码高亮样式，Markdown 将代码片显示选择的高亮样式 进行展示； 增加了 图片拖拽 功能，你可以...
利用栈来破解迷宫问题
m0_48781656的博客
10-06 2860
利用栈来破解迷宫问题 对于迷宫类问题的破解，需要利用栈的思想 1.构思 假设“当前位置”指的是在搜索过程中某一时刻所在途中某个方块的位置，“路径是最优走法”则求迷宫当中一条路径的思想便是：若当前位置可以通过，那么存放在“路径”中，可以通过的位置便是没有走过的位置，因为路径记录的是每一步，并朝向下一个位置进行探索，切换下一个位置为当前位置。把当前位置用一个数组表示，然后判断放入路径然后用栈存放，那么放进去一个位置就代表走过了那个位置。那肯定有很多重复，也会往回走但，那么如何实现走出迷宫呢？ 2.算法 每次走
栈求解迷宫问题
weixin_34128411的博客
04-11 162
求迷宫从入口到出口的所有路径是一个经典的程序设计问题。一般的设计思想就是从入口出发，顺着某个方向向下探索，探索分为上下左右四个方位，哪个方向是通的就将向下走，如果每个方向都走不下去就进行原路“回退”。所以需要一个后进先出的结构来保存从入口到出口的路径。所以运用栈来实现是非常方便的，沿着某个方向走，将每个可通的位置进行入栈标记，再切换到下个位置；如果都不通，则栈顶出栈取...
栈的应用举例2（迷宫求解）
weixin_30906671的博客
08-15 135
// func3-1.cpp、algo3-5.cpp、algo3-9.cpp和algo3-11.cpp要调用的函数、结构和全局变量 struct PosType // 迷宫坐标位置类型(见图3.9) { int x; // 行值 int y; // 列值 }; #define MAXLENGTH 25 // 设迷宫的最大行列为25 typedef int MazeType[MAXLEN...
迷宫求解与栈队列应用
例如，当数组大小为StackSize时，可以定义一个顺序栈类型如下： ```c #define StackSize 100 typedef char datatype; ``` 队列则是另一种重要的数据结构，它遵循先进先出（FIFO）原则。在迷宫问题中，队列常用于广度...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值