数据结构--栈的应用 ( 迷宫问题 )

最新推荐文章于 2022-11-18 21:49:08 发布
最新推荐文章于 2022-11-18 21:49:08 发布
阅读量1.4k 收藏 19
点赞数 8
分类专栏： 数据结构 文章标签： 迷宫问题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ds19980228/article/details/82226662
版权

迷宫问题 : 

其中要使用栈    栈的定义和基本操作 : 传送门  https://blog.csdn.net/ds19980228/article/details/81741617

简单迷宫 :  

0    0    0    0    0    0  

0    0    1    0    0    0  

0    0    1    0    0    0  

0    0    1    1    1    0  

0    0    1    0    1    1  

0    0    1    0    0    0

简单迷宫 (如上图所示 ) : 当我们找出它的通路时, 可以直接利用栈的性质, 从起点开始将所走的路径以下标的方式存入栈, 并且将原来坐标所存的值标记为2, 证明已经走过,  那么周围没有路径可走时, 将栈顶坐标出栈, 再次寻找可走路径, 当栈为空或者达到定义的出口时结束 .这种方法称作回溯法  ( 走完之后如下图所示 )

简单迷宫 :  

0    0    0    0    0    0  

0    0    2    0    0    0  

0    0    2    0    0    0  

0    0    2    2    2    0  

0    0    2    0    2    2  

0    0    2    0    0    0

上面是简单迷宫的处理方法, 那如果迷宫复杂一点的话( 如下图所示 )那又该如何处理呢 ? 

多通路迷宫 : 通路间不带环

0    0    0    0    0    0  

0    1    1    1    1    1  

0    1    0    0    0    0  

0    1    0    0    0    0  

0    1    1    1    1    1  

0    1    0    0    0    0

多通路迷宫 : 通路带环

0    0    0    0    0    0  

0    1    1    1    0    0  

0    1    0    1    0    0  

0    1    0    1    0    0  

0    1    1    1    1    1  

0    1    0    0    0    0

当然上面的方法也能求解出通路不带环问题, 但是如果遇到带环或者要求出迷宫中最短路径呢 ? 这样就不能用上面的问题求解了, 下面介绍一种方法 : 

当找迷宫通路时候, 每走一步将坐标入栈的同时将坐标位置的值改为上一个坐标点值加 1, 当然第一个入栈坐标代表的值要改为 2 ;

然后判断是否可以通行的条件就变为 :

  • 当下一个坐标的值为 1 可以通行 
  • 当下一个坐标的值比当前坐标值大于 2 可以通行
  • 当无路可走且栈不为空时, 出栈 , 栈为空时结束

若要求出最小的路径只需要将每次到出口时的路径求出, 并且与下次新出口的路径进行比较, 保持路径最小

演示 : 

 

第一遍走 :                                                             第二遍走

0    0    0    0    0    0            0    0    0    0    0    0  

0    6    7    8    0    0            0    6    7    8    0    0

0    5    0    9    0    0            0    5    0    7    0    0

0    4    0   10   0    0            0    4    0    6    0    0

0    3   12  11  12  13           0    3    4    5    6    7

0    2    0    0    0    0            0    2    0    0    0    0

代码如下 : 

//检查是否有通路
int CheckAccess(Pos next,Pos cur)
{
        //判断是否有通路的条件
	if ((next._col > 0 && next._col<N&&next._row>0 && next._row < N) &&
(maze[next._row][next._col] == 1 || maze[next._row][next._col] > maze[cur._row][cur._col] + 1))
		return 1;
	else
		return 0;
}
//寻找最短通路
void MazeGetShortPath(Pos entry)
{
	int i, j;
	int arr[N][N] = {0};
	Stack path;
	Pos cur;
	Pos next;
	int len = 0;
	StackInit(&path);
	StackPush(&path, entry);
	cur = StackTop(&path);
	maze[cur._row][cur._col] = 2;
	while (StackEmpty(&path))
	{
		cur = StackTop(&path);
                //当找到出口时,求出路径长度
		if (cur._col == 5)
		{
                        //如果旧路径小于新路径或者len为0时,则更新len的大小,并且用两个辅助栈
                        //记录该路径所走的路线
			if (len == 0 || len > StackSize(&path))
			{
                                Stack back;            
	                        Stack Path;
				len = StackSize(&path);
				StackInit(&Path);
				StackInit(&back);
                                //将最短路径所走的路线存在Path里边
				while (StackEmpty(&path))
				{
					StackPush(&back, StackTop(&path));
					StackPush(&Path, StackTop(&path));
					StackPop(&path);
				}
                                //还原原始栈
				while (StackEmpty(&back))
				{
					StackPush(&path, StackTop(&back));
					StackPop(&back);
				}
			}
		}
		//检查上边是否通路
		next = cur;
		next._row -= 1;
		if (CheckAccess(next, cur))
		{
			StackPush(&path, next);
			maze[next._row][next._col] = maze[cur._row][cur._col] + 1;
			continue;
		}
                //检查下边是否有通路
		next = cur;
		next._row += 1;
		if (CheckAccess(next, cur))
		{
			StackPush(&path, next);
			maze[next._row][next._col] = maze[cur._row][cur._col] + 1;
			continue;
		}
                //检查左边是否有通路
		next = cur;
		next._col -= 1;
		if (CheckAccess(next, cur))
		{
			StackPush(&path, next);
			maze[next._row][next._col] = maze[cur._row][cur._col] + 1;
			continue;
		}
                //检查右边是否有通路
		next = cur;
		next._col += 1;
		if (CheckAccess(next, cur))
		{
			StackPush(&path, next);
			maze[next._row][next._col] = maze[cur._row][cur._col] + 1;
			continue;
		}
                //若无通路栈顶元素出栈
		StackPop(&path);
	}
	printf("最短路径长度为:%d", len);
	printf("\n");
	printf("所走路径如下图:");
	while (StackEmpty(&Path))
	{
		arr[StackTop(&Path)._row][StackTop(&Path)._col] = -1;
		StackPop(&Path);
	}
	printf("\n");
	for (i = 0; i < N; i++)
	{
		for (j = 0; j < N; j++)
			printf("%2d ", arr[i][j]);
		printf("\n");
	}
}

完整代码 : 

栈之前已经实现过, 直接拿来用即可

Maze.h

#pragma once
#define N 6
static  int maze[N][N] = { 0, 0, 0, 0, 0, 0,
			   0, 1, 1, 1, 0, 0,
			   0, 1, 0, 1, 0, 0,
			   0, 1, 0, 1, 0, 0,
			   0, 1, 1, 1, 1, 1,
			   0, 1, 0, 0, 0, 0 };
//数据结构
typedef struct Pos
{
	int _row;
	int _col;
}Pos;
//寻找最短路径,并且打印最短路线
void MazeGetShortPath(Pos entry);
//打印迷宫
void PrintMaze()

Maze.c

#include "Maze.h"
//栈的头文件  
#include "Stack.h"  
//检查是否有通路
int CheckAccess(Pos next,Pos cur)
{
	if ((next._col > 0 && next._col<N&&next._row>0 && next._row < N) &&
		(maze[next._row][next._col] == 1 || maze[next._row][next._col] > maze[cur._row][cur._col] + 1))
	//判断条件
		return 1;
	else
		return 0;
}
//打印迷宫
void PrintMaze()
{
	int i, j;
	printf("\n");
	for (i = 0; i < N; i++)
	{
		for (j = 0; j < N; j++)
			printf("%2d ", maze[i][j]);
		printf("\n");
	}
}
//寻找最短通路
void MazeGetShortPath(Pos entry)
{
	int i, j;
	int arr[N][N] = {0};
	Stack back;
	Stack path;
	Stack Path;
	Pos cur;
	Pos next;
	int len = 0;
	StackInit(&path);
	StackPush(&path, entry);
	cur = StackTop(&path);
	maze[cur._row][cur._col] = 2;
	while (StackEmpty(&path))
	{
		cur = StackTop(&path);
		if (cur._col == 5)
		{
			if (len == 0 || len > StackSize(&path))
			{
				len = StackSize(&path);
				StackInit(&Path);
				StackInit(&back);
				while (StackEmpty(&path))
				{
					StackPush(&back, StackTop(&path));
					StackPush(&Path, StackTop(&path));
					StackPop(&path);
				}
				while (StackEmpty(&back))
				{
					StackPush(&path, StackTop(&back));
					StackPop(&back);
				}
			}
		}
		//检查上边是否通路
		next = cur;
		next._row -= 1;
		if (CheckAccess(next, cur))
		{
			StackPush(&path, next);
			maze[next._row][next._col] = maze[cur._row][cur._col] + 1;
			continue;
		}
		next = cur;
		next._row += 1;
		if (CheckAccess(next, cur))
		{
			StackPush(&path, next);
			maze[next._row][next._col] = maze[cur._row][cur._col] + 1;
			continue;
		}
		next = cur;
		next._col -= 1;
		if (CheckAccess(next, cur))
		{
			StackPush(&path, next);
			maze[next._row][next._col] = maze[cur._row][cur._col] + 1;
			continue;
		}
		next = cur;
		next._col += 1;
		if (CheckAccess(next, cur))
		{
			StackPush(&path, next);
			maze[next._row][next._col] = maze[cur._row][cur._col] + 1;
			continue;
		}
		StackPop(&path);
	}
	printf("最短路径长度为:%d", len);
	printf("\n");
	printf("所走路径如下图:");
	while (StackEmpty(&Path))
	{
		arr[StackTop(&Path)._row][StackTop(&Path)._col] = -1;
		StackPop(&Path);
	}
	printf("\n");
	for (i = 0; i < N; i++)
	{
		for (j = 0; j < N; j++)
			printf("%2d ", arr[i][j]);
		printf("\n");
	}
}

Test.c

#include "Stack.h"
#include "Maze.h"
int main()
{
	Pos entry;
	entry._row = 5;
	entry._col = 1;
	PrintMaze();
	printf("\n");
	MazeGetShortPath(entry);
	PrintMaze();
	system("pause");
	return 0;
}

调试结果如下 : 

    

 

 

Dyson~
关注
  • 8
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【数据结构】栈应用-迷宫（简单vs进阶）
码农印象
08-22 929
题目 对于给定条件的迷宫，若只有一条出路，求出口，若有多条出路，求最短路径！ 迷宫大概可分为三类： 思路 对于迷宫问题，我们首先应该有回溯的思想： 回溯算法实际上一个尝试搜索的过程，主要是在搜索尝试过程中寻找问题的解，当发现已不满足求解条件时，就“回溯”返回，尝试别的路径。回溯法是一种选优搜索法，按选优条件向前搜索，以达到目标。但当探索到某一步时，发现原先选择并不优...
迷宫问题（运用栈解决）
m0_49938352的博客
07-09 4188
求迷宫中从出口到入口的所有路径，在过程中需要用到栈来存储数据结构； 下标起始值是0，从（1，1）开始走，终点是（3，4），问怎样走才能走到终点？（图画的有问题） 先从数据结构入手，需要的数据结构有栈，还有图中的点。 点的数据定义： typedef struct { int x; //行 int y; //列 int next; //下一个可走元素 }point; 栈的数据定义： typedef struct { point *base; ...
数据结构——栈的应用迷宫问题
m0_61635175的博客
09-28 445
数据结构——栈的应用迷宫问题
数据结构——用栈解决简单迷宫问题
GlassySky的博客
10-15 3539
#include #include using namespace std; typedef int ElemType; #define MaxSize 50 /*int mg[n1][n2] #define n1 50//定义行范围 #define n2 50//定义列范围 void array(int g,int h)    //以二维数组形式定义迷宫内容 {
数据结构-走迷宫问题（栈的运用）
qq_40251838的博客
06-02 5517
用矩阵代表地图，矩阵中1代表可以走通，0代表可以走通。假设目前位于（x,y）处，则下一可走位置为（）
数据结构-栈的应用-迷宫求解
04-16
在本主题“数据结构-栈的应用-迷宫求解”中，我们将探讨如何利用栈来解决迷宫路径搜索的问题。 首先，迷宫求解是一个典型的图遍历问题，可以通过深度优先搜索（DFS）或广度优先搜索（BFS）等算法来解决。在这里，...
数据结构-栈的应用：顺序栈与链栈的应用
最新发布
03-22
在这个主题中，我们将专注于栈（Stack）这一特殊的数据结构，及其在实际应用中的两种主要实现方式：顺序栈（Sequential Stack）和链栈（Linked Stack）。栈通常被称为“后进先出”（LIFO，Last In First Out）的数据...
migong.rar_migong_数据结构 迷宫_栈的应用_迷宫 栈_迷宫问题
09-23
标题中的“migong.rar_migong_数据结构 迷宫_栈的应用_迷宫 栈_迷宫问题”暗示了这是一个关于使用栈解决迷宫问题的案例。迷宫问题通常涉及到寻找从起点到终点的有效路径，而栈在这里起到了记录和回溯路径的作用。 ...
数据结构栈和队列解决迷宫问题
06-07
数据结构栈和队列解决迷宫问题 本文档详细介绍了利用栈和队列解决迷宫问题的步骤，对于初学者学习数据结构能很好的进行辅导。本文档主要涉及到数据结构的两个重要概念：栈和队列，并介绍了如何使用这两个数据结构来...
数据结构（C语言版） 栈与队列 迷宫问题
06-10
在C语言版的数据结构课程中，第三章深入探讨了两种基础但非常重要的数据结构——栈和队列，并应用它们解决实际问题，如迷宫问题。 栈是一种后进先出（LIFO）的数据结构，类似于我们日常生活中的叠放物品。它主要...
迷宫问题（栈解决）
04-09
使用栈解决迷宫问题，调用了stack类模板，算法
数据结构：栈与队列之迷宫（详解）
study_jiang_up的博客
11-18 3956
迷宫对于数据结构的萌新来说，是比较困难的。所以需要多理解栈和队列的思想，在看这个之前，可以先做做栈和队列其他题目，比如转进制转化等问题，再回来写迷宫问题会更好理解。
数据结构例程——迷宫问题（用栈结构）
weixin_33893473的博客
09-15 2461
　　本文针对数据结构基础系列网络课程(3)：栈和队列中第6课时栈的应用2-迷宫问题。 例：求出从入口到出口的路径 程序实现： #include <stdio.h> #define MaxSize 100 #define M 8 #define N 8 int mg[M+2][N+2]= { {1,1,1,...
栈求解迷宫问题
dream
04-11 1万+
问题：假设下图是某迷宫的地图，问此迷宫是否有一条通路 求解思想： 用栈来实现解决问题，主要步骤是 （1）从迷宫的
运用栈求解迷宫问题C/C++
g15827636417的博客
10-07 2万+
用栈解决基本的迷宫问题C/C++ 1、问题描述：设置迷宫为m*n的二维数组，起点坐标为（1，1），中点坐标为（m，n），0为通路，1为死路，为防止数组越界将四周设置边界1，即数组变为（m+2）*（n+2）数组，迷宫如下....      迷宫 1 1 1 1 1 1 1 1 1 1 1 0 1 1 1 0 1 1 1 1
迷宫问题【数据结构实验报告】
热门推荐
_
10-27 3万+
数据结构实验报告 实验名称：实验二 迷宫问题 学号：*** 姓名：gnosed 实验日期：2017.10.23   一、实验目的 1、了解回溯法在求解迷宫问题中的应用 2、进一步掌握栈的使用   二、实验具体内容 1、实验题目1： （1）题目 用回溯法求解迷宫问题，可以用一个栈保存探索的序列。并且在该迷宫的行走中，站在一点可以有八个方向选择。 比如如下的迷宫 Ente...
C语言 栈 数据结构 迷宫求解（附完整代码）
weixin_43401438的博客
11-15 2万+
一、程序设计思路 1、题目：应用栈实现迷宫游戏 要求：以书中3.2.4节迷宫求解为基础实现迷宫游戏，游戏运行时显示一个迷宫地图（迷宫内容结构可以参照书中图片，也可以自己编写），玩家从地图左上角的入口处进入迷宫，从右下角出口离开迷宫。玩家不能穿墙而过。本题目需在作业中完成程序设计思路、程序源代码和游戏视频三部分。其中，程序设计思路部分以文字叙述为主，详细阐述迷宫和玩家在迷宫中移动的基本操作；程序源代...
迷宫问题栈实现（数据结构c语言版 ）
qq_36327328的博客
07-31 2685
程序主要参考自严蔚敏老师的数据结构c语言版，在书中程序的大体框架下进行了完善。关于迷宫问题的思路可查阅原书。 #include&lt;iostream&gt; using namespace std; #define MAXSIZE 10 typedef int Status; typedef struct{ int x; int y; }Postype; typedef struct...
数据结构栈的应用迷宫问题
03-16
栈是一种常见的数据结构，它遵循先进后出（IFO）的原则。在迷宫问题中，栈可以用于实现路径的搜索和回溯。 迷宫问题是指在一个迷宫中找到从起点到终点的路径。迷宫通常由网格组成，其中某些网格是墙壁，而其他网格是可以通过的路径。我们需要找到一条从起点到终点的路径，路径只能通过相邻的可通过的网格。 使用栈来解决迷宫问题的一种常见方法是使用深度优先搜索（DFS）。具体步骤如下： 1. 将起点入栈。 2. 当栈不为空时，执行以下步骤： - 弹出栈顶元素作为当前位置。 - 如果当前位置是终点，则找到了一条路径，结束搜索。 - 否则，将当前位置标记为已访问，并将当前位置的相邻可通过的未访问网格入栈。 3. 如果栈为空且没有找到路径，则迷宫没有解。 使用栈进行深度优先搜索可以保证我们首先探索最深的路径，直到找到终点或者无法继续前进时才回溯。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值