迷宫（栈回溯）

最新推荐文章于 2022-03-28 15:36:13 发布
原创 最新推荐文章于 2022-03-28 15:36:13 发布 · 1.1k 阅读 · 8 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文详细介绍三种迷宫寻路算法：单出口迷宫、多出口迷宫（不带环）及多出口迷宫（带环）。通过递归和栈结构实现路径寻找，展示如何在复杂迷宫中找到所有可能的出口。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

迷宫介绍

在生活中我们玩过很多种走迷宫的小游戏，游戏给了一个迷宫，这个迷宫中只有一个入口，我们要从这个入口一直走下去，直到找到出口，这里出口可能是一个，也可能是多个。在这里我简单介绍三种实现起来由易到难的迷宫。

前提说明
我们这里的坐标是x轴正半轴向下伸展，y轴正半轴向右伸展

简单迷宫

在这里插入图片描述

这是一种简单迷宫，有一个入口和一个出口，我们从入口开始按照左上右下的顺序进行尝试走迷宫，如果都走不了，就开始进行回溯，前提是我们走过的路需要提前标记，这样回溯的时候就比较方便了。代码如下：

maze.h

#pragma once
#include<stdio.h>
#include<windows.h>
#define ROWS 6
#define COLS 6
#define MAX 100
typedef struct {
	int x;
	int y;
}Position;
typedef Position datatype;
typedef struct Stack{
	datatype data[MAX];
	int top;
}Stack;
void GoMaze();

maze.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"maze.h"
int maze[ROWS][COLS] = {
	{ 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 }
};//迷宫
void StackInit(Stack *stack)
{
	stack->top = 0;
}
void StackPush(Stack *stack,datatype data)
{
	stack->data[stack->top] = data;
	stack->top++;
}
void StackPop(Stack *stack)
{
	stack->top--;
}
datatype StackTop(Stack *stack)
{
	return stack->data[stack->top - 1];
}
int IsExit(Position pos)
{
	if (pos.y == COLS - 1)
	{
		return 1;
	}
	else
		return 0;
}
int CanPass(Position pos)
{
	if (pos.x < 0 || pos.x >= ROWS)
	{
		return 0;
	}
	if (pos.y < 0 || pos.y >= COLS)
	{
		return 0;
	}
	if (maze[pos.x][pos.y] == 1)
	{
		return 1;
	}
	else
		return 0;
}
void PrintMaze()
{
	for (int i = 0; i < ROWS; i++)
	{
		for (int j = 0; j < COLS; j++)
		{
			if (maze[i][j] == 1)
			{
				printf("  ");//路用空格表示
			}
			else if (maze[i][j] == 0)
			{
				printf("■");//墙
			}
			else
			{
				printf("◎");//走过的路进行标记方便回溯
			}
		}
		printf("\n");
	}
}
void GoMaze()
{
	Stack stack;
	StackInit(&stack);
	Position entry = { 5,2 };
	Position pos = entry;
	Position nextpos = pos;

	while (1)
	{
		//标记走过的位置
		maze[pos.x][pos.y] = 2;
		system("cls");//打印前清屏
		PrintMaze();
		Sleep(300);//有间隔效果看起来会好一点
		StackPush(&stack, pos);
		//当前是否走到出口
		if (IsExit(pos))
		{
			printf("找到出口了！\n");
			return;
		}
		//没有走到出口，按照左上右下的顺序进行尝试
		nextpos.y -= 1;
		if (CanPass(nextpos))
		{
			pos = nextpos;
				continue;
		}
		nextpos = pos;
		nextpos.x -= 1;
		if (CanPass(nextpos))
		{
			pos = nextpos;
			continue;
		}
		nextpos = pos;
		nextpos.y += 1;
		if (CanPass(nextpos))
		{
			pos = nextpos;
			continue;
		}
		nextpos = pos;
		nextpos.x += 1;
		if (CanPass(nextpos))
		{
			pos = nextpos;
			continue;
		}
		//如果都走不了，出栈
		StackPop(&stack);
		pos = StackTop(&stack);
		StackPop(&stack);
	}
}
void test()
{
	
	GoMaze();
}

在这里插入图片描述

多通路迷宫（不带环）

在这里插入图片描述

这是第二种迷宫，有一个入口，但是有两个出口。如果还是用第一种简单迷宫的方法，很显然当它找到第一个出口的时候就会停下来，那么我们如果想要把所有的路走找到，当找到第一个出口的时候我们把出口改成墙继续找第二个出口，知道栈里面一个元素都没有的时候就结束。代码如下：

maze.h

#pragma once
#include<stdio.h>
#include<windows.h>
#define ROWS 6
#define COLS 6
#define MAX 100
typedef struct {
	int x;
	int y;
}Position;
typedef Position datatype;
typedef struct Stack{
	datatype data[MAX];
	int top;
}Stack;
void GoMaze();

maze.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"maze.h"
int maze[ROWS][COLS] = {
{ 0,0,0,0,0,0 },
{ 0,0,1,1,1,1 },
{ 0,0,1,0,0,0 },
{ 0,0,1,0,0,0 },
{ 0,0,1,1,1,1 },
{ 0,0,1,0,0,0 }
};
void StackInit(Stack *stack)
{
	stack->top = 0;
}
void StackPush(Stack *stack,datatype data)
{
	stack->data[stack->top] = data;
	stack->top++;
}
void StackPop(Stack *stack)
{
	stack->top--;
}
datatype StackTop(Stack *stack)
{
	return stack->data[stack->top - 1];
}
int StackEmpty(Stack *stack)
{
	if (stack->top == 0)
	{
		return 1;
	}
	else
		return 0;
}
int IsExit(Position pos)
{
	if (pos.y == COLS - 1)
	{
		return 1;
	}
	else
		return 0;
}
int CanPass(Position pos)
{
	if (pos.x < 0 || pos.x >= ROWS)
	{
		return 0;
	}
	if (pos.y < 0 || pos.y >= COLS)
	{
		return 0;
	}
	if (maze[pos.x][pos.y] == 1)
	{
		return 1;
	}
	else
		return 0;
}
void PrintMaze()
{
	for (int i = 0; i < ROWS; i++)
	{
		for (int j = 0; j < COLS; j++)
		{
			if (maze[i][j] == 1)
			{
				printf("  ");
			}
			else if (maze[i][j] == 0)
			{
				printf("■");
			}
			else
			{
				printf("◎");
			}
		}
		printf("\n");
	}
}
void GoMaze()
{
	Stack stack;
	StackInit(&stack);
	Position entry = { 5,2 };
	Position pos = entry;
	Position nextpos = pos;

	while (1)
	{
		//标记走过的位置
		maze[pos.x][pos.y] = 2;
		system("cls");//打印前清屏
		PrintMaze();
		Sleep(300);//有间隔效果看起来会好一点
		StackPush(&stack, pos);
		//当前是否走到出口
		if (IsExit(pos))
		{
			printf("找到出口了！\n");
			maze[pos.x][pos.y] = 0;
			goto BACK;
		}
		//没有走到出口，按照左上右下的顺序进行尝试
		nextpos.y -= 1;
		if (CanPass(nextpos))
		{
			pos = nextpos;
				continue;
		}
		nextpos = pos;
		nextpos.x -= 1;
		if (CanPass(nextpos))
		{
			pos = nextpos;
			continue;
		}
		nextpos = pos;
		nextpos.y += 1;
		if (CanPass(nextpos))
		{
			pos = nextpos;
			continue;
		}
		nextpos = pos;
		nextpos.x += 1;
		if (CanPass(nextpos))
		{
			pos = nextpos;
			continue;
		}
BACK:
		//如果都走不了，回溯
		StackPop(&stack);
		if (StackEmpty(&stack))
		{
			printf("结束\n");
			return;
		}
		pos = StackTop(&stack);
		StackPop(&stack);
	}
}
void test()
{
	
	GoMaze();
}

在这里插入图片描述

多通路迷宫（带环）

在这里插入图片描述

这是第三种迷宫，仍然是多通路，不同的是，这次带了环，和该如何是好呢？这时候我们可以递归的思想，利用递归的思想在回溯的时候可以不用判断之前走过的路了。代码如下：

maze.h

#pragma once
#include<stdio.h>
#include<windows.h>
#define ROWS 6
#define COLS 6
#define MAX 100
typedef struct {
	int x;
	int y;
}Position;
typedef Position datatype;
typedef struct Stack{
	datatype data[MAX];
	int top;
}Stack;
void GoMazeR();

maze.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"maze.h"
int maze[ROWS][COLS] = {
{ 0,0,0,0,0,0 },
{ 0,1,1,1,1,0 },
{ 0,1,0,0,1,0 },
{ 0,1,0,0,1,0 },
{ 0,1,1,1,1,1 },
{ 0,1,0,0,0,0 }
};
void StackInit(Stack *stack)
{
	stack->top = 0;
}
void StackPush(Stack *stack,datatype data)
{
	stack->data[stack->top] = data;
	stack->top++;
}
void StackPop(Stack *stack)
{
	stack->top--;
}
datatype StackTop(Stack *stack)
{
	return stack->data[stack->top - 1];
}
int StackEmpty(Stack *stack)
{
	if (stack->top == 0)
	{
		return 1;
	}
	else
		return 0;
}
int IsExit(Position pos)
{
	if (pos.y == COLS - 1)
	{
		return 1;
	}
	else
		return 0;
}
int CanPass(Position pos)
{
	if (pos.x < 0 || pos.x >= ROWS)
	{
		return 0;
	}
	if (pos.y < 0 || pos.y >= COLS)
	{
		return 0;
	}
	if (maze[pos.x][pos.y] == 1)
	{
		return 1;
	}
	else
		return 0;
}
void PrintMaze()
{
	for (int i = 0; i < ROWS; i++)
	{
		for (int j = 0; j < COLS; j++)
		{
			if (maze[i][j] == 1)
			{
				printf("  ");
			}
			else if (maze[i][j] == 0)
			{
				printf("■");
			}
			else
			{
				printf("◎");
			}
		}
		printf("\n");
	}
}
void GoMazeR(Position pos)
{
	Position nextpos = pos;

		//标记走过的位置
		maze[pos.x][pos.y] = 2;
		system("cls");//打印前清屏
		PrintMaze();
		Sleep(300);//有间隔效果看起来会好一点
		//当前是否走到出口
		if (IsExit(pos))
		{
			maze[pos.x][pos.y] = 1;
			printf("找到出口了！\n");
			return;
		}
		//没有走到出口，按照左上右下的顺序进行尝试
		nextpos.y -= 1;
		if (CanPass(nextpos))
		{
			GoMazeR(nextpos);
		}
		nextpos = pos;
		nextpos.x -= 1;
		if (CanPass(nextpos))
		{
			GoMazeR(nextpos);
		}
		nextpos = pos;
		nextpos.y += 1;
		if (CanPass(nextpos))
		{
			GoMazeR(nextpos);
		}
		nextpos = pos;
		nextpos.x += 1;
		if (CanPass(nextpos))
		{
			GoMazeR(nextpos);
		}
		//回溯之前把走过的路清空
		maze[pos.x][pos.y] = 1;
}
void test()
{
	Position entry = { 5,1 };
	GoMazeR(entry);
}

在这里插入图片描述

用栈来实现迷宫
zimituanzi_的博客
06-11 3217
迷宫 下面先简单的介绍一下迷宫，我们给出的迷宫实际上是一个二维数组，在二维数组中1表示可以走通，0表示走不通，如下图所示给一个简单的迷宫： 实现代码： maze.h文件 // 用递归的方式求解简单迷宫问题 #define MAX_ROW 5 #define MAX_COL 5 #include "Stack.h" typedef struct Maze { int ...
迷宫问题的递归回溯算法c语言,c语言迷宫问题求解——递归、栈回溯
weixin_36345268的博客
05-23 2070
第一次写，见谅以下是求迷宫的实现为什么下面会出现标签啊，有什么简便的方法去掉吗？求告知最后是关于求所有通路，个人愚笨只想到改变搜索方向顺序这种笨方法，总共有16种不同顺序，有兴趣的小伙伴可以试一下/*第一部分使用递归求解为了数据的简单化，不对路口进行数据结构化，将用一个简单的int类型数组来表示迷宫因为每一个路口的四个方向相对于当前路口的位移都是一样的，这样可以用一个int类型二位数据表示四个方向...
迷宫栈
xyjy11的博客
04-02 695
do{ if(当前位置可以通过){ 入栈当前位置； 判断当前是否到终点； 未到终点，选择一个方向上的下个位置成为当前位置； } else{ 出栈；判断是否四个方向都遍历完； 是则当前位置不可行，标记不通；再出栈栈顶元素新一轮判断； 没有选择另一方向继续； }}while（栈不为空）主要代码如下：//type内保存当前位置的坐标和下一位置的方向class type{ int row; int c...
迷宫回溯
用心改变世界
09-28 565
迷宫回溯什么是递归递归要遵守的规则迷宫寻路问题解决 什么是递归 递归简单的说就是自己调用自己。 //求10的阶乘 public static int recursive(int n){ if(n==1){ return 1; }else { return n * recursive(n-1); ...
回溯法迷宫求解
shuduti的博客
06-13 2102
回溯法解迷宫（利用栈的性质进行迷宫求解）一、迷宫类： package migongqiujie; import java.awt.BorderLayout; import java.awt.Color; import java.awt.GridLayout; import java.awt.Window; import java.awt.event.ActionEvent; impor
用栈、回溯算法设计迷宫程序
10-24
标题中的“用栈、回溯算法设计迷宫程序”指的是使用数据结构中的栈以及算法中的回溯法来解决迷宫问题。在这个问题中，我们通常将迷宫视为一个二维矩阵，其中1代表墙壁，0代表可通行的道路。目标是找到从起点到终点的...
migong.rar_migong_数据结构 迷宫_栈的应用_迷宫 栈_迷宫问题
09-23
迷宫问题通常涉及到寻找从起点到终点的有效路径，而栈在这里起到了记录和回溯路径的作用。 迷宫问题可以抽象为一个二维数组或图，每个节点代表迷宫中的一个位置，值0表示可通行，1表示障碍。我们可以通过广度优先...
迷宫问题的非递归算法(栈实现.rar_迷宫 栈_迷宫 问题 非递归 算法_迷宫 非递归_迷宫问题_迷宫问题栈
09-21
首先，栈是一种后进先出（LIFO）的数据结构，适用于解决需要回溯的问题，例如深度优先搜索（DFS）。在迷宫问题中，我们可以将栈用于存储待检查的节点，而不是像递归那样使用调用栈。 1. **迷宫表示**：迷宫通常被...
用栈走迷宫
l-jobs的专栏
11-26 1264
问题描述：如何求出从入口到出口的一条迷宫路径？ 问题思路： 回溯法。从入口开始选定一个方向走，如果这个方向走不通，就换下一个方向，如果走得通，存下这个位置，跳到下一个位置继续判断。如果试完所有方向都不通，那么说明这个位置是死路，标记当前位置已走过，然后回溯到上一个位置继续判断。直到走到终点程序结束。 那么怎么保存走过的位置和回去呢？我们需要一个先进后出的数据结构，栈就满足这个要求，出栈就是返
C语言实现迷宫（回溯）
06-03
C语言实现迷宫，利用回溯的思想。。。。。。。。
栈实现迷宫
05-06
用栈实现迷宫问题，是数据结构中一个比较有意义的算法，如怎么实现最短路径
迷宫问题（栈）
weixin_34167043的博客
04-11 169
"迷宫问题（栈）" “栈”是一种简单的数据结构，它的主要特点就是"先进后出"，即就是先压入栈中的数据需要最后出栈。相当于栈是一个杯子，最先放进栈中的东西，只能够最后拿出来。下面对“栈”的特点用图形象的表示出来。 这次所要讨论的是基于栈的迷宫问题，当给定一个迷宫，我们怎样能够找出迷宫中的通道呢？如果迷宫的规模比较大，我们又该如何去...
【数据结构】栈 实现迷宫算法
man_zuo的博客
09-06 4957
#include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #include&lt;string.h&gt; #include&lt;iostream&gt; using namespace std; #define STACK_INIT_SIZE 100 #define STACKINCREMENT 10 #define TURE 1 #define FA...
利用栈走迷宫
漫鱼
04-23 928
预备知识 前置声明头文件：https://blog.youkuaiyun.com/hanzheng6602/article/details/80031130 动态顺序表：https://blog.youkuaiyun.com/hanzheng6602/article/details/79917391 拓展：带环迷宫求最短路 https://blog.youkuaiyun.com/hanzheng6602/article/...
栈的应用之迷宫自动行走（回溯）
qq_60899598的博客
03-28 656
这题可以用栈写，主要思路就是把路径用栈储存，当遇到分岔路时就按优先级选择一条，当路被堵住时，就一直退栈到分岔口，并在原来的路上打印！，遇到下一个分岔口时就在原来的路上打印*。开始用栈写了一遍，后面看到大佬同学用递归写，感觉确实阔以，就试了试。嘿嘿。一查发现可以用回溯算法，下面给出第二种做法（50到60行）。
以栈解决迷宫问题
weixin_34248849的博客
05-19 281
怎么找到一个迷宫的出口呢。首先要知道迷宫长啥样，之后知道出入口，再之后就是找通路的过程了。显然主要的部分是如何找通路。我们就举一个例子：在这个迷宫中0就是墙，1就是路。那么我们可以用一个二维数组来表示这个迷宫。之后我们需要一种结构来实现我们表示位置的移动。structPos { size_tline; size_trow; };这个结...
【栈的应用】迷宫算法（栈和回溯思想）
askunix
07-31 4474
人生，就像一个很大的栈演变。出生时赤条条地来到这个世界，慢慢地长大，渐渐地变老，最终还得赤条条地离开世间。 思路分析： 上面是一个迷宫地图，在地图上，0 代表墙，1 代表通路。 迷宫是回溯法和栈的综合应用。 下面给出完整的思路和寻路算法： 这里我们只研究一种情况：地图只有一条路径可以出去。 寻路算法按照上下左右的顺序进行遍历和判断。 从入口出发，按照上...
链式栈求解迷宫问题：回溯算法及两种输出形式解析
在给定的文件信息中，我们关注的是如何利用链式栈结构来解决迷宫问题，以及采用回溯算法搜索所有可能的路径，并提供两种不同的输出形式。 首先，让我们解释迷宫问题本身。迷宫问题通常描述为一个二维网格，其中包含...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值