栈与队列--迷宫寻路

已于 2022-10-08 15:23:26 修改
阅读量1.1k 收藏 2
点赞数
分类专栏： 数据结构 文章标签： 算法 c语言 深度优先
于 2022-09-27 17:26:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/RXY24601/article/details/127074705
版权

题目：应用栈实现迷宫游戏
要求：游戏运行时显示一个迷宫地图,玩家从地图左上角的入口处进入迷宫，从右下角出口离开迷宫。玩家不能穿墙而过。
输入描述：输入两个整数，分别表示二位数组的行数，列数，再输入相应的数组，其中的1表示墙壁，0表示可以走。数据保证有唯一解，不考虑有多解的情况，即迷宫只有一条通道
输出描述：左上角大右下角的最短路径

 思路1：先判断能那个位置可以走，栈内储存做选择位置的坐标，如果选择过后出现死路径，则跳转回记录的选择位置的坐标，重新选择路径，往回走的方式就叫做回溯，采用最大深度泛式

 

 对于二维数组的动态开辟，动态开辟二维数组首先需要开辟一个大小为N的指针数组，然后需要开辟N个大小为M的数组

 

 以一个简单的[3,3]迷宫举例，运算逻辑为将走过的路径设置为2，避免之后返回已经走过的路径。随后在上下左右四个方向中选择可以行进的路径，到达新位置后如果未到达终点且不能再移动，则递归函数返回false，也就是将位置返回上一级判定，直至返回值有其他方向可走的位置。

到目前位置已经基本实现了迷宫寻路的功能，接下来需要解决的问题就是如何记录正确的路径，并将其输出出来。这里采用栈的形式进行储存，栈后进先出的特性，方便在进入错误路径后删除错误位置并且返回上一个位置。

栈的接口函数：

typedef PS STDataType;

typedef struct Stack
{
	STDataType* a;//建立一个动态数组
	STDataType top;//栈顶
	STDataType capacity;//栈的容量
}ST;

//接口函数
void StackInit(ST* ps);//初始化
void StackDestory(ST* ps);//销毁
void StackPush(ST*ps,STDataType x);//入栈，不分头插尾插，因为栈只能在栈顶操作
void StackPop(ST* ps);//出栈
STDataType StackTop(ST* ps);//取栈顶数据
int StackSize(ST* ps);//得到栈的数据个数
bool StackEmpty(ST* ps);//判断栈是否为空

在栈的接口函数这里，将STDataType设置为ps，方便之后将结构体数据进行进栈出栈操作，这里也同样体现了采用typedef关键字的好处，避免面对不同的数据类型对函数反复重新定义 

栈接口函数的实现：

void StackInit(ST* ps)
{
	assert(ps);
	ps->a = (STDataType*)malloc(sizeof(STDataType) * 4);
	if (ps->a==NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	ps->capacity = 4;
	ps->top = 0;
	//初始top=0，意味着top指向栈顶元素的下一个
	//初始top=-1，意味着top指向栈顶元素
}

void StackDestory(ST* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->top = ps->capacity = 0;
}

void StackPush(ST* ps,STDataType x)
{
	assert(ps);
	if (ps->top==ps->capacity)
	{
		STDataType* tmp = (STDataType*)realloc(ps->a, ps->capacity * 2 * sizeof(STDataType));
		if (tmp==NULL)
		{
			printf("realloc fail\n");
			exit(-1);//终止程序
		}
		else
		{
			ps->a = tmp;
			ps->capacity *= 2;
		}
	}
	ps->a[ps->top] = x;
	ps->top++;
}

void StackPop(ST* ps)
{
	assert(ps);
	assert(ps->top>0);//空栈时调用top直接终止程序报错
	ps->top--;//直接将栈顶数据删除，下一次有数据入栈会覆盖top位置
}

STDataType StackTop(ST* ps)//取栈顶元素
{
	assert(ps);
	assert(ps->top>0);
	return ps->a[ps->top - 1];
}

int StackSize(ST* ps)
{
	assert(ps);
	return ps->top;
}

bool StackEmpty(ST* ps)
{
	assert(ps);
	return ps->top == 0;//如果top为零，说明栈中没有元素，为空
	//返回布尔值为1
}

 代码实现：

//题目：应用栈实现迷宫游戏
//要求：游戏运行时显示一个迷宫地图,玩家从地图左上角的入口处进入迷宫，从右下角出口离开迷宫。玩家不能穿墙而过。
//输入描述：输入两个整数，分别表示二位数组的行数，列数，再输入相应的数组，其中的1表示墙壁，0表示可以走。数据保证有唯一解，不考虑有多解的情况，即迷宫只有一条通道
//输出描述：左上角大右下角的最短路径

//思路1：先判断能那个位置可以走，栈内储存做选择位置的坐标，如果选择过后出现死路径，则跳转回记录的选择位置的坐标，重新选择路径，往回走的方式就叫做回溯
//采用最大深度泛式

#include<stdio.h>
#include<malloc.h>
#include<stdbool.h>


typedef PS STDataType;

typedef struct Stack
{
	STDataType* a;//建立一个动态数组
	STDataType top;//栈顶
	STDataType capacity;//栈的容量
}ST;

ST ps;//这里为ps栈的声明，用于之后存放路径位置

//接口函数
void StackInit(ST* ps);//初始化
void StackDestory(ST* ps);//销毁
void StackPush(ST* ps, STDataType x);//入栈，不分头插尾插，因为栈只能在栈顶操作
void StackPop(ST* ps);//出栈
STDataType StackTop(ST* ps);//取栈顶数据
int StackSize(ST* ps);//得到栈的数据个数
bool StackEmpty(ST* ps);//判断栈是否为空


void StackInit(ST* ps)
{
	assert(ps);
	ps->a = (STDataType*)malloc(sizeof(STDataType) * 4);
	if (ps->a == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	ps->capacity = 4;
	ps->top = 0;
	//初始top=0，意味着top指向栈顶元素的下一个
	//初始top=-1，意味着top指向栈顶元素
}

void StackDestory(ST* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->top = ps->capacity = 0;
}

void StackPush(ST* ps, STDataType x)
{
	assert(ps);
	if (ps->top == ps->capacity)
	{
		STDataType* tmp = (STDataType*)realloc(ps->a, ps->capacity * 2 * sizeof(STDataType));
		if (tmp == NULL)
		{
			printf("realloc fail\n");
			exit(-1);//终止程序
		}
		else
		{
			ps->a = tmp;
			ps->capacity *= 2;
		}
	}
	ps->a[ps->top] = x;
	ps->top++;
}

void StackPop(ST* ps)
{
	assert(ps);
	assert(ps->top > 0);//空栈时调用top直接终止程序报错
	ps->top--;//直接将栈顶数据删除，下一次有数据入栈会覆盖top位置
}

STDataType StackTop(ST* ps)//取栈顶元素
{
	assert(ps);
	assert(ps->top > 0);
	return ps->a[ps->top - 1];
}

int StackSize(ST* ps)
{
	assert(ps);
	return ps->top;
}

bool StackEmpty(ST* ps)
{
	assert(ps);
	return ps->top == 0;//如果top为零，说明栈中没有元素，为空
	//返回布尔值为1
}




//定义一个坐标位置结构体
typedef struct postion
{
	int row;
	int col;
}PS;


//输出迷宫
void print(int **maze,int N,int M)
{
	for (int i = 0; i < N; i++)
	{
		for (int j = 0; j < M; j++)
		{
			printf("%d ", maze[i][j]);
		}
		printf("\n");
	}
}

void PrintPath(ST *ps)//实现路径坐标输出
{
	ST returnpath;
	StackInit(&returnpath);
	while (!StackEmpty(&ps))
	{
		StackPush(&returnpath, StackTop(&ps));
		StackPop(&ps);
	}
	while (!StackEmpty(&returnpath))
	{
		PS top = StackTop(&returnpath);
		printf("(%d,%d)\n",top.row,top.col);
		StackPop(&returnpath);
	}
	StackDestory(&returnpath);
}

//判断上下左右是否可走
bool IsPass(int** maze,int N,int M,PS pos)
{
	if (pos.row>=0&&pos.col>=0&&pos.row<N&&pos.col<M&&maze[pos.row][pos.col]==0)
	{
		return true;
    }
	else
	{
		return false;
	}
}

//采用递归算法实现移动
bool GetMazePath(int** maze, int N, int M, PS cur)//cur代表当前位置
{
	StackPush(&ps, cur);//将cur入栈

	//判断是否到达终点
	if (cur.row == N - 1 && cur.col == M - 1)
	{
		return true;
	}
	//探测cur的上下左右四个方向
	PS next;
	maze[cur.row][cur.col] = 2;//将走过的路径定义为2，避免在探测的过程中返回
	//上
	next = cur;//这一步的动作是为了给next重新赋值
	next.row -= 1;
	if (IsPass(maze, N, M, next))
	{
		if(GetMazePath(maze, N, M, next))
		{
			return true;
		}
	}
	//下
	next = cur;
	next.row += 1;
	if (IsPass(maze, N, M, next))
	{
		if (GetMazePath(maze, N, M, next))
		{
			return true;
		}
	}
	//左
	next = cur;
	next.col -= 1;
	if (IsPass(maze, N, M, next))
	{
		if (GetMazePath(maze, N, M, next))
		{
			return true;
		}
	}
	//右
	next = cur;
	next.col += 1;
	if (IsPass(maze, N, M, next))
	{
		if (GetMazePath(maze, N, M, next))
		{
			return true;
		}
	}
	StackPop(&ps, cur);//当要走到return false时，说明这一步错误，需要出栈
	return false;
}


int main()
{
	int N = 0, M = 0;
	printf("输入N M的值\n");
	scanf_s("%d%d",&N,&M);
	//int a[n][m];     变长数组，部分编译器不支持
	
	while (N!=NULL&&M!=NULL)
	{
		//动态开辟二维数组，首先需要开辟一个大小为N的指针数组，然后需要开辟N个大小为M的数组
		int** maze = (int**)malloc(sizeof(int*) * N);
		for (int i = 0; i < N; i++)
		{
			maze[i] = (int*)malloc(sizeof(int) * M);
		}

		//二维数组的输入
		for (int i = 0; i < N; i++)
		{
			for (int j = 0; j < M; j++)
			{
				printf("输入迷宫\n");
				scanf_s("%d", &maze[i][j]);
			}
		}

		StackInit(&ps);//在栈的定义后设置了ps用于存放路径位置，这里要将栈初始化操作

		//print(maze, N, M);
		PS entry = { 0,0 };//左上角进入位置为{0,0}
		if (GetMazePath(maze, N, M, entry))
		{
			PrintPath(&ps);
		}
		else
		{
			printf("为找到通路\n");
		}

		StackDestory(&ps);

		for (int i = 0; i < N; i++)
		{
			free(maze[i]);
		}
		free(maze);
		maze = NULL;
		
	}
	return 0;
}

RXY24601
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java 栈如何走迷宫寻路_用栈实现迷宫游戏寻路
weixin_30913041的博客
02-28 316
标签：栈迷宫在我们学习数据结构的时候都曾经见过迷宫游戏，迷宫游戏的实现其实并不难，但是，我们在实现每一个算法的时候都应该想一想这个问题的每一个解。最近，博主已经开始重温数据结构啦，记得我们以前学习这里的时候，老师会用队列来实现迷宫最优解的寻找，氮素呢，博主就是这么可爱，博主就是想试试用栈来找一下。在实现之前让我们先来复习一下栈的特点：first in last out对于栈这种数据结构我们只...
自建迷宫寻路
05-29
建立一个m*n的矩阵迷宫并至少有一个入口和出口，0和1分别表示迷宫中的通路和障碍； 探索从迷宫入口到出口有无通路，若有，则计算出通路的路径，通路以(I，j，d)三元素表示，i、j分别表示迷宫中的坐标，d表示走到下一...
3-4-迷宫寻路-栈和队列-第3章-《数据结构》课本源码-严蔚敏吴伟民版
weixin_30667301的博客
02-28 261
课本源码部分 第3章 栈和队列 -迷宫寻路 ——《数据结构》-严蔚敏.吴伟民版 源码使用说明 链接☛☛☛ 《数据结构-C语言版》（严蔚敏,吴伟民版）课本源码+习题集解析使用说明 课本源码合辑 链接☛☛☛ 《数据结构》课本源码合辑 习题集全解析 链接☛☛☛ 《数据结构题集》习题解析合辑 本源码引入的文件 链接☛S...
【数据结构与算法】利用栈和队列进行迷宫求解
weixin_50947533的博客
05-12 952
迷宫求解
数据结构实验之栈与队列十：走迷宫
且视他人之疑目如盏盏鬼火
10-18 421
Problem Description一个由n * m 个格子组成的迷宫，起点是(1, 1)， 终点是(n, m)，每次可以向上下左右四个方向任意走一步，并且有些格子是不能走动，求从起点到终点经过每个格子至多一次的走法数。Input 第一行一个整数T 表示有T 组测试数据。(T <= 110) 对于每组测试数据:第一行两个整数n, m，表示迷宫有n * m 个格子。(1 <= n, m <= 6
栈和队列-数据结构与算法(C语言版)
monkeylvjava
05-17 814
栈和队列 一、栈 1. 概述 栈是限定仅在表尾进行插入和删除操作的线性表。进行插入或删除操作的一端叫做栈顶，另一端称为栈底，没有数据元素的栈称为空栈，插入数据元素的操作称为入栈，删除数据元素的操作称为出栈。 栈的特性：**先进后出（FILO）**或者 后进先出（LIFO）。 栈的存储结构 顺序栈（顺序存储） 采用顺序存储结构模拟栈存储数据，因为每次分配固定大小的存储空间，操作不当可能产生上溢或者下溢。 链栈（链式存储） 采用链式存储结构实现 两种实现方式的区别，仅限于数据元素在实际物
迷宫寻路-BFS
Brinshy的博客
01-10 697
使用广度搜索bfs在迷宫中寻找最短路径 其中我们规定迷宫中0代表可走路，1代表阻碍的路 我们这里使用队列去完成bfs，每次从队列中取出一个点去搜索他的上下左右，如还没有走过，并且可走，那么就将他加入到队列中去，并且记录它的前继（作用是利用前继去复现最短路），最终找到终点就结束。 代码中find-path的作用是bfs找路，print-path的作用是用前继复现最短路。 效果图如下 * 代表走过的路，这里是从0，0点开始到6，6为终点，当然起点、终点以及迷宫的大小都可以修改 没找路径最后也会打印.
迷宫寻路-Easyx演示
TeAmo
07-05 178
从入口开始，检测当前位置的四个方向是否存在可行的位置P，将P放入队列中，将当前位置存储的距离加1后，替换位置P的值。接着从队列中取出下一位置。重复同样的操作，直到下一个位置是出口即可停止。它表示一个迷宫，其中的1表示墙壁，0表示可以走的路，只能横着走或竖着走，不能斜着走，要求找出从左上角到右下角的路线。入口点为[0,0],既第一格是可以走的路。寻找最短路径则比较简单，经过的位置都存储了距离入口的距离，从出口的距离逆向寻找。最短路径可能不止一条。
数据结构课设-迷宫寻路系统
2302_80729149的博客
06-28 895
这是一个迷宫寻路系统，它的功能是创建迷宫判断迷宫是否有出口输出走出迷宫最少的步数输出走出迷宫的轨迹在该课题中，我们主要使用了BFS（广度优先搜索）和队列的概念，队列我们使用的是链队列，下面我先简单介绍一下该队列的结构typedef struct QNode//创建队列节点元素//坐标typedef struct//创建双端队列类型//队头指针queue rear;//队尾指针}Linkqueue;
python迷宫寻路_迷宫寻路
weixin_39826971的博客
12-08 480
57//AC代码:#include#include#include#includeusing namespace std;char G[105][105];int book[105][105][1200],N,M;int Next[4][2]={0,1,0,-1,1,0,-1,0};int bfs(int,int);struct node{int x,y,k,step;node(int x,int...
Python数据结构与算法：栈、队列及迷宫问题的深度与广度搜索详解
jacobbubushiqi的博客
01-19 713
在Python编程的旅程中，深入理解数据结构与算法是每个开发者不可回避的重要议题。本文将结合实际的代码示例，深入剖析栈、队列这两种经典的数据结构，并通过一个实际的迷宫问题，演示它们在深度与广度搜索中的威力。这是一篇适合发表在CSDN等技术平台上的文章，旨在帮助读者更好地理解和运用这些关键的概念。
EXP 1 code_python迷宫寻路_
09-29
在IT领域，迷宫寻路问题是一个经典的计算机科学问题，主要涉及到图论和搜索算法的应用。本主题将深入探讨如何使用Python解决此类问题，重点是深度优先搜索（DFS）、广度优先搜索（BFS）以及A*算法。这些算法都是在有...
迷宫_C＃游戏_迷宫_自动寻路_
09-29
在本文中，我们将深入探讨如何使用C#编程语言来创建一个迷宫游戏，并实现自动寻路功能。C#是一种广泛应用于开发桌面应用、游戏、移动应用以及Web应用的强大语言，其丰富的类库和面向对象的特性使其非常适合进行游戏...
c语言-广度优先-迷宫寻路-程序+源代码
12-10
本项目"**c语言-广度优先-迷宫寻路-程序+源代码**"是大二学生所做的一项实践，它通过控制台界面展示了广度优先搜索（Breadth First Search, BFS）在迷宫问题中的应用。 首先，我们来了解什么是广度优先搜索。BFS是...
简易迷宫寻路
08-11
- **类与对象**：迷宫寻路程序可能需要定义“迷宫”类，包含迷宫的结构信息，如节点、边和路径；另外，还有“位置”类表示节点坐标。 - **数据结构**：栈、队列、数组等数据结构在解决迷宫问题中起到关键作用，如...
算法力扣刷题记录 五十九【450.删除二叉搜索树中的节点】
最新发布
danaaaa的博客
07-25 1265
删除节点，在左右子树不为空的情况，处理稍微复杂。
代码随想录算法训练营第二十二天|回溯算法part01
qq_43456971的博客
07-25 721
这一题与上题一样，除了终止条件中需要判断和是否为target。多了一个剪枝操作，就是当值已经大于target，直接返回。本题还有一个建立数字和字母之间映射的问题，使用string数组来进行映射。因此回溯算法的宽度是每个集合里面的个数，回溯算法的深度是集合的个数。参数是digits与index，index是用来记录遍历第几个集合。在单个集合1-9中，寻找所有个数为k且和为target的组合。在单个集合1-n中，寻找所有个数为k的组合。这一题是在多个集合中找所有可能的组合。和所有递归一样，都有三部曲。
河南萌新联赛2024第（二）场：南阳理工学院
a13997460860的博客
07-25 1306
这场比赛里面出到了很多的题，都是需要很多的时间去写，主要考察到了代码的实现能力，与codeforces里面的题有些差距。codeforces打多了还是有点不习惯的。题挺好的，尤其是H题感觉很考代码实现能力与STL的使用熟练度。多写写这样的题还是对我们很有好处的。只不过前三题都太水了，没有一点难度。
java队列实现迷宫寻路
05-12
要使用队列来解决迷宫寻路问题，可以采用广度优先搜索算法（BFS）。具体实现步骤如下： 1. 定义一个队列来保存需要遍历的节点，初始状态时将起点节点加入队列中。 2. 当队列不为空时，循环执行以下操作： a) ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值