链栈求解迷宫从入口到出口的路径

最新推荐文章于 2022-03-19 01:11:48 发布
最新推荐文章于 2022-03-19 01:11:48 发布
阅读量3.1k 收藏 11
点赞数 2
文章标签： 数据结构 c语言 栈
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/calypso6/article/details/108559330
版权

本文参考博客园博客

https://www.cnblogs.com/cxyc/p/5322406.html

代码，加入了自己的理解，写出来希望对大家学习数据结构中的链栈有所帮助！

我在重新学习数据结构这本书（清华大学严纬敏老师）的时候对算法3.3迷宫求解产生了很大的兴趣，遂C语言代码实现。

1. 首先上结果：

在这里插入图片描述（下一个问题：如何找到最近的路？）

思路：最开始入栈入口节点，然后入栈路径（显示为0）节点。如果一条路走到死路，出栈，直到回到先前的岔路口。

  1. 下面分块解析：

头文件：链栈节点结构体、链栈结构体

#pragma once

/*小人在迷宫某位置可以向四周行动的描述 结构体*/
typedef struct  //某一方向为0才能向该方向移动，为1则不能
{
	int top;
	int bottom;
	int left;
	int right;
}direction;  //该结构体为direction型

/*当前小人所在迷宫的位置 结构体*/
typedef struct
{
	int x;
	int y;
}point;  //该结构体为point型

/*链栈节点 结构体*/
typedef struct
{
	direction direct;
	point position;
	struct StackNode* next;
}StackNode, * LinkStackPtr;  //命名为StackNode,指向该结构体的指针名为LinkStackPtr

/*链栈 及 计算链栈含有节点个数 结构体*/
typedef struct
{
	LinkStackPtr top;  //链栈头指针
	int count;  //该链栈拥有的节点个数
}LinkStack;

源文件1：节点、链栈数据结构及基本操作

#include<stdio.h>
#include<stdlib.h>
#include "定义.h"

#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE  -1
#define OVERFLOW  -2

#define size 10

typedef int Status;
typedef int bool;



/*判断链栈是否为空（只有头节点）*/
bool isEmpty(LinkStack L)
{
	if (L.count == 1) return TRUE;
	return FALSE;
}

/*创建链栈 函数*/
Status createLink(LinkStack L)   //                                          这里可能有问题
{
	L.top = (LinkStackPtr)malloc(sizeof(StackNode));  //链栈头指针类型为栈节点，指针为指向这个栈节点的指针
	if (!L.top) exit(OVERFLOW);  //分配失败，没有多余的空间分配给链栈了
	L.top = NULL;  //链栈头指针初始化指向空
	L.count++;
	return OK;
}

/*取头节点  因为链栈入栈头插法，所以要讨论新插入的节点必须取头节点*/
LinkStackPtr GetTop(LinkStack L)  //LinkStackPtr已经是指针了，所以不用加*
{
	return L.top;  //返回的是个链栈型指针
}

/*入栈*/
Status Push(LinkStack* L, LinkStackPtr s)  //s是指向新增节点的指针
{
	s->next = (*L).top;
	(*L).top = s;
	(*L).count++;  //每插入一个，链栈长度加1
	return OK;
}

/*出栈*/
Status Pop(LinkStack* L)
{

	if (isEmpty(*L)) return ERROR;
	LinkStackPtr p;  //创建一个链栈节点型指针p
	p = (*L).top;
	(*L).top = (*L).top->next;
	free(p);
	(*L).count--;  //每弹出一个，链栈长度减1
	return OK;
}

源文件2：预定义及用数组实现的迷宫地图

#include<stdio.h>
#include<stdlib.h>
#include "定义.h"

#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE  -1
#define OVERFLOW  -2

#define size 10

typedef int Status;
typedef int bool;

int enter_x, enter_y;  //入口坐标
int exit_x, exit_y;  //出口坐标

/*导入迷宫地图，1表示墙壁，0表示通路*/
int map[size][size] = {
	{1, 0, 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, 0},
	{1, 1, 1, 1, 1, 1, 1, 1, 1, 1}
};

/*找迷宫的入口和出口。迷宫入口只会存在于第一行，出口只会存在于最后一列*/
void findMap(int map[][size], int* enter_x, int* enter_y, int* exit_x, int* exit_y)  //当二维数组有初值表后，第一维大小就可以省略
{
	for (int i = 0; i < size; i++)
	{
		for (int j = 0; j < size; j++)
		{
			if (i == 0 && map[i][j] == 0)
			{
				*enter_x = i;
				*enter_y = j;
			}
			if (j == size - 1 && map[i][j] == 0)
			{
				*exit_x = i;
				*exit_y = j;
			}
		}
	}//遍历二维数组
	if (*enter_x == *exit_x && *enter_y == *exit_y)
	{
		printf("该迷宫出入口相同，无解。\n");
		system("pause");  //暂停一下程序，按任意键继续
		exit(ERROR);
	}
}  //

/*打印迷宫*/
void printMap(int a[][size])
{
	for (int i = 0; i < size; i++)
	{
		for (int j = 0; j < size; j++)
		{
			printf("%d ", a[i][j]);
		}
		printf("\n");
	}
}

/*判断这一个坐标是不是0，是，能走，否，不能走*/
bool judge(int x, int y)
{
	if (map[x][y] == 0) return TRUE;
	else return FALSE;
}

源文件3：主函数和实现

#include<stdio.h>
#include<stdlib.h>
#include "定义.h"

#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE  -1
#define OVERFLOW  -2

#define size 10

typedef int Status;
typedef int bool;

extern map[size][size];

int main()
{
	printMap(map);
	bool flag = FALSE;  //一开始默认求解失败，成功找到通路了，改为TRUE

	/*初始化链栈并创建链栈结构体中的头指针和count*/
	LinkStack L;
	createLink(&L);  //要加&，表示直接对链栈地址所指的真实值进行操作

	/*找到入口和出口横纵坐标*/
	int enterx, entery, exitx, exity;
	enterx = entery = exitx = exity = 0;
	findMap(map, &enterx, &entery, &exitx, &exity);  //输出的是数组序号0开始

	/*创建链栈头节点并初始化，头节点存储*/
	LinkStackPtr p = (LinkStackPtr)malloc(sizeof(StackNode));  //p是个指针！！p很有用，一直都要用，所以用malloc

	p->position.x = enterx;
	p->position.y = entery;

	p->direct.top = 1;  //入口不能上移，因为在第一行
	p->direct.right = 0;
	p->direct.bottom = 0;
	p->direct.left = 0;

	map[p->position.x][p->position.y] = 2;  //把迷宫入口置2，2表示通路
	Push(&L, p);  //直接把L地址放进去处理，真实改变了L的值，L的值可以传到函数之外

	/*寻路*/
	while (!isEmpty(L))
	{
		LinkStackPtr q;  //q只是临时用一下，随当前坐标的变化，指向不同的当前坐标所属链栈节点
		q = GetTop(L);  //q指向当前坐标节点

		/*判断是否到达终点*/
		if (q->position.x == exitx && q->position.y == exity)
		{
			flag = TRUE;
			break;  //到达迷宫终点，跳出while循环
		}
		/*向上走*/
		if (q->direct.top == 0)  //如果该坐标显示其上方向可走
		{
			if (q->position.x - 1 >= 0)  //如果向上走还在迷宫范围之内
			{
				if (judge(q->position.x - 1, q->position.y))  //如果向上的坐标的数字是0，就是“通路”
				{
					q->direct.top = 1;  //当前坐标向上方向置为1，表示经由该坐标，向上的方向已经走过了

					/*已经向上走一步，把向上走到达的坐标 这一结构体，加入链栈L*/
					LinkStackPtr m = (LinkStackPtr)malloc(sizeof(StackNode));

					m->position.x = q->position.x - 1;  //初始化链栈节点结构体的position数据项，包括x，y坐标
					m->position.y = q->position.y;

					m->direct.top = 0;  //初始化链栈节点结构体的direct数据项，包括四方向可否向其移动
					m->direct.right = 0;
					m->direct.bottom = 1;  //从下面来的，所以下一跳不能回去
					m->direct.left = 0;

					map[m->position.x][m->position.y] = 2;  //将走到的坐标置2
					Push(&L, m);  //上方向坐标块入栈
				}
				else  //如果向上的坐标的数字是1，就是“墙”
				{
					q->direct.top = 1;   //告诉当前坐标，不能向上走
				}
			}
			else  //如果上面不在迷宫范围之内了
			{
				q->direct.top = 1;   //告诉当前坐标，不能向上走
			}
		}
		/*向右走*/
		else if(q->direct.right == 0)
		{
			if (q->position.y + 1 < size)  //如果向右走还在迷宫范围之内
			{
				if (judge(q->position.x, q->position.y + 1))  //如果向右的坐标的数字是0，就是“通路”
				{
					q->direct.right = 1;  //当前坐标向右方向置为1，表示经由该坐标，向右的方向已经走到过了

					/*已经向右走一步，把向右走到达的坐标 这一结构体，加入链栈L*/
					LinkStackPtr m = (LinkStackPtr)malloc(sizeof(StackNode));

					m->position.x = q->position.x;  //初始化链栈节点结构体的position数据项，包括x，y坐标
					m->position.y = q->position.y + 1;

					m->direct.top = 0;  //初始化链栈节点结构体的direct数据项，包括四方向可否向其移动
					m->direct.right = 0;
					m->direct.bottom = 0;  
					m->direct.left = 1;  //从左面来的，所以下一跳不能回去

					map[m->position.x][m->position.y] = 2;  //将走到的坐标置2
					Push(&L, m);  //右方向坐标块入栈
				}
				else  //如果向上的坐标的数字是1，就是“墙”
				{
					q->direct.right = 1;   //告诉当前坐标，不能向右走
				}
			}
			else  //如果上面不在迷宫范围之内了
			{
				q->direct.right = 1;   //告诉当前坐标，不能向右走
			}
		}
		/*向下走*/
		else if (q->direct.bottom == 0)
		{
			if (q->position.x + 1 < size)  //如果向下走还在迷宫范围之内
			{
				if (judge(q->position.x + 1, q->position.y))  //如果向下的坐标的数字是0，就是“通路”
				{
					q->direct.bottom = 1;  //当前坐标向下方向置为1，表示经由该坐标，向下的方向已经走到过了

					/*已经向下走一步，把向下走到达的坐标 这一结构体，加入链栈L*/
					LinkStackPtr m = (LinkStackPtr)malloc(sizeof(StackNode));

					m->position.x = q->position.x + 1;  //初始化链栈节点结构体的position数据项，包括x，y坐标
					m->position.y = q->position.y;

					m->direct.top = 1;  //初始化链栈节点结构体的direct数据项，包括四方向可否向其移动 从上面来的，所以下一跳不能回去
					m->direct.right = 0;
					m->direct.bottom = 0;
					m->direct.left = 0;  

					map[m->position.x][m->position.y] = 2;  //将走到的坐标置2
					Push(&L, m);  //下方向坐标块入栈
				}
				else  //如果向下的坐标的数字是1，就是“墙”
				{
					q->direct.bottom = 1;   //告诉当前坐标，不能向下走
				}
			}
			else  //如果下面不在迷宫范围之内了
			{
				q->direct.bottom = 1;   //告诉当前坐标，不能向下走
			}
		}
		/*向左走*/
		else if (q->direct.left == 0)
		{
			if (q->position.y - 1 >= 0)  //如果向左走还在迷宫范围之内
			{
				if (judge(q->position.x, q->position.y - 1))  //如果向左的坐标的数字是0，就是“通路”
				{
					q->direct.left = 1;  //当前坐标向左方向置为1，表示经由该坐标，向左的方向已经走到过了

					/*已经向左走一步，把向左走到达的坐标 这一结构体，加入链栈L*/
					LinkStackPtr m = (LinkStackPtr)malloc(sizeof(StackNode));

					m->position.x = q->position.x;  //初始化链栈节点结构体的position数据项，包括x，y坐标
					m->position.y = q->position.y - 1;

					m->direct.top = 0;  //初始化链栈节点结构体的direct数据项，包括四方向可否向其移动 
					m->direct.right = 1;  //从右面来的，所以下一跳不能回去
					m->direct.bottom = 0;
					m->direct.left = 0;

					map[m->position.x][m->position.y] = 2;  //将走到的坐标置2
					Push(&L, m);  //左方向坐标块入栈
				}
				else  //如果向左的坐标的数字是1，就是“墙”
				{
					q->direct.left = 1;   //告诉当前坐标，不能向左走
				}
			}
			else  //如果左面不在迷宫范围之内了
			{
				q->direct.left = 1;   //告诉当前坐标，不能向左走
			}
		}
		/*四个方向都不能走*/
		else if (q->direct.top == 1 && q->direct.right == 1 && q->direct.bottom == 1 && q->direct.left == 1)
		{
			map[q->position.x][q->position.y] = 0;  //与51行获得q相对应。q此时已经被设为2了，现在要退回去，重新设置为0
			Pop(&L);
        }
	}

	/*判断是否找到了路径*/
	if (flag == TRUE)
	{
		printf("成功找到路径。0：未走路径；1墙壁；2：路径\n");
		printMap(map);
	}
	else printf("未找到路径");

	return 0;
}

改进：找到入口-出口最近的路。

有思路的小伙伴欢迎在评论区讨论。

Calypso6
关注
  • 2
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【数据结构与算法】之深入解析“迷宫中离入口最近的出口”的求解思路与算法示例
╰つ栺尖篴夢ゞ
03-19 1万+
一、题目要求 给你一个 m x n 的迷宫矩阵 maze （下标从 0 开始），矩阵中有空格子（用 ‘.’ 表示）和墙（用 ‘+’ 表示）。同时给你迷宫的入口 entrance ，用 entrance = [entrancerow, entrancecol] 表示你一开始所在格子的行和列。 每一步操作，你可以往上、下、左或者右移动一个格子，不能进入墙所在的格子，也不能离开迷宫。你的目标是找到离 entrance 最近的出口，出口的含义是 maze 边界上的空格子，entrance 格子不算出口。 请你返回
经典迷宫问题1
ghuilee的专栏
11-27 4351
1.迷宫问题直观感受     下面给出迷宫问题的一个直观感受图，下图中棕色代表通道阻塞，白色代表可用通道，红色代表起始位置，绿色代表当前位置，黄色代表出口。 迷宫1： 迷宫2： 2.迷宫算法 算法基本思想:   首先将入口设为当前位置；然后从当前位置出发，按照固定顺序(例如：右左上下顺序)探测第一个可用下一个单元，然后
求迷宫的最短路径：现要求设计一个算法找一条从迷宫入口到出口的最短路径。
11-25
本算法要求找一条迷宫的最短路径，算法的基本思想为：从迷宫入口点（1,1）出发，向四周搜索，记下所有一步能到达的坐标点；然后依次再从这些点出发，再记下所有一步能到达的坐标点，…，依此类推，直到到达迷宫的出口点(m,n)为止，然后从出口点沿搜索路径回溯直至入口。这样就找到了一条迷宫的最短路径，否则迷宫无路径。
DFS模板
weixin_45817857的博客
12-19 392
7-7 求迷宫最短通道 (20分) 递归求解迷宫最短通道的总步长。输入一个迷宫，求从入口通向出口的可行路径中最短的路径长度。为简化问题，迷宫用二维数组 int maze[10][10]来存储障碍物的分布，假设迷宫的横向和纵向尺寸的大小是一样的，并由程序运行读入, 若读入迷宫大小的值是n（3<n<=10），则该迷宫横向或纵向尺寸都是n，规定迷宫最外面的一圈是障碍物，迷宫的入口是maze[...
求解迷宫从入口到出口的路径【算法】【栈】【深度优先搜索】
PoisonKiller的博客
10-05 4975
题目：求解迷宫从入口至出口的路径 创建一个迷宫，求从入口通向出口的可行路径。 为简化问题，迷宫用二维数组 int maze[10][10]来存储障碍物的分布。 假设迷宫的横向和纵向尺寸的大小是一样的，并由程序运行读入, 若读入迷宫大小的值是n（3<n<=10），则该迷宫横向或纵向尺寸都是n，规定迷宫最外面的一圈是障碍物，迷宫的入口是maze[1][1]，出口是maze[n-2][n-2], 若maze[i][j] = 1代表该位置是障碍物，若maze[i][j] = 0代表该位置是可以行走的空位
5-5 递归算法求解从入口到出口的所有迷宫路径
wuwuhuai的博客
02-13 5160
//递归算法求解从入口到出口的所有迷宫路径 #include &lt;stdio.h&gt; #define MaxSize 100 #define M 4 #define N 4 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}, {...
C++迷宫问题的求解算法
12-20
任务是设计一个程序，对给定的迷宫，找到一条从入口（左上角）到出口（右下角）的路径，如果找不到路径则输出无解。输出的路径以三元组（i，j，d）的形式表示，（i，j）是坐标，d是移动方向（如：上、下、左、右）。...
数据结构课程设计-迷宫求解.pdf
11-17
- `showRoad`：显示从入口到出口的路径。 6. **时间复杂度**：由于采用非递归的DFS，时间复杂度主要取决于迷宫的大小。对于每个节点，算法会检查其所有相邻节点，因此时间复杂度大约为O(N)，N为迷宫中的节点数量。...
数据结构课程设计汇本报告迷宫求解.doc
10-06
迷宫求解的目标是从起点出发，通过尝试各个可能的路径找到出口。为了能够回溯，必须使用后进先出（LIFO）的数据结构，这里选择栈。算法的基本思路是，如果当前位置可通行，就将它加入路径，并探索下一个位置；如果...
迷宫与栈问题课程设计报告
最新发布
05-28
【迷宫与栈问题课程设计】的目的是设计一个程序，解决在一个给定的mXn迷宫中寻找从入口到出口路径的问题。迷宫由0和1表示，0代表通路，1代表障碍。该程序需能处理任意设定的迷宫，并通过栈这种数据结构来寻找路径。 ...
迷宫问题 假设迷宫由m行n列构成，有一个入口和一个出口，入口坐标为(1，1)，出口坐标为(m，n)，试找出一条从入口通往出口的最短路径。设计算法并编程输出一条通过迷宫的最短路径或报告一个“无法通过”的信息。
06-04
题目：假设迷宫由m行n列构成，有一个入口和一个出口，入口坐标为(1，1)，出口坐标为(m，n)，试找出一条从入口通往出口的最短路径。设计算法并编程输出一条通过迷宫的最短路径或报告一个“无法通过”的信息。 要求：用栈和队列实现，不允许使用递归算法。
一个简单的迷宫路径求解
08-20
一个简单的迷宫路径求解 c++实现
栈和队列 迷宫求解
weixin_33713707的博客
01-02 106
用WPF做演示 1.用Stack记录和回溯 在现实生活中,在你迷路的时候,总是记录一些可记忆的建筑物作为返回的标志（比如你出去玩,总得回家的吧,那么就得记得回家的路） (1)画迷宫 public class MazeElement : FrameworkElement { public MazeElement(int[,] mg) { this.mg...
7-7 求解迷宫从入口到出口的路径 (15 分) java
qq_53369749的博客
11-14 1907
求解迷宫从入口到出口的路径。输入一个迷宫，求从入口通向出口的可行路径。为简化问题，迷宫用二维数组 int maze[10][10]来存储障碍物的分布，假设迷宫的横向和纵向尺寸的大小是一样的，并由程序运行读入, 若读入迷宫大小的值是n（3<n<=10），则该迷宫横向或纵向尺寸都是n，规定迷宫最外面的一圈是障碍物，迷宫的入口是maze[1][1]，出口是maze[n-2][n-2], 若maze[i][j] = 1代表该位置是障碍物，若maze[i][j] = 0代表该位置是可以行走的空位（0&lt
迷宫求解数据结构设计完整代码_数据结构实验（2）：使用栈的方法求解迷宫从入口到出口的路径...
weixin_39612817的博客
12-01 2503
题目：求解迷宫从入口到出口的路径。输入一个迷宫，求从入口通向出口的可行路径。为简化问题，迷宫用二维数组 int maze[10][10]来存储障碍物的分布，假设迷宫的横向和纵向尺寸的大小是一样的，并由程序运行读入, 若读入迷宫大小的值是n(3本题要求必须使用严格的搜索顺序，即从右，从下，从左，从上，并非要找到最短路径，例如上图我们得到的路径应该是：所以应该得到程序结果为：对于此题，数据结...
迷宫出口以及迷宫最短路径的求解
Steve_Abelieve
04-20 1645
整理出来方便大家复习//完成迷宫 #pragma warning (disable:4996) #include<iostream> #include<vector> #include<stack> using namespace std; #include<assert.h> //创建迷宫->动态创建二维数组：1.int[][N] 2.int*->（二维数组是按照一维数组来存储的） //打印迷宫
【李春葆教材】用队列实现求解迷宫从入口到出口的一条最短路径(15 分)
m0_60904839的博客
03-19 2020
声明：这道题在李春葆数据结构教材上有主函数的样例代码，本博客直接引用了书上的代码，仅仅是将前面函数部分和主函数整理组合在一起。 有一个小小地方要注意就是主函数中队列中第一个元素pre值应该赋值为0而不是-1，否则与书中之前列出的队列常用函数中front的初值不匹配，则不能输出结果。 求解迷宫从入口到出口的一条最短路径。输入一个迷宫，求从入口通向出口的一条可行最短路径。为简化问题，迷宫用二维数组 int maze[10][10]来存储障碍物的分布，假设迷宫的横向和纵向尺寸的大小是一样的，并由程序运.
求解迷宫最短路径
qq_41027326的博客
04-18 827
1. 多通路迷宫初始化     先构建一个多通路迷宫,并且对其初始化 void MazeInitShortPath(Maze* maze) { if(maze == NULL) { return; } int row = 0; int col = 0; for(; row &lt; MAX_COL; row++) { ...
迷宫问题
寒雪无痕
04-20 823
迷宫问题：给给定一个M X N的迷宫图，求一条从指定入口的到出口的路径  巧用递归思想、回溯剪枝和栈操作
使用递归算法求解迷宫问题，输出从入口到出口的所有迷宫路径
02-01
在求解迷宫问题时，我们可以使用递归算法来找到从入口到出口的所有可能的路径。 算法流程如下： 1. 定义一个函数 find_path，其中参数包括迷宫地图、当前位置坐标 (x, y) 和记录路径的数组 path。 2. 在当前位置...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值