【数据结构】求简单迷宫是否存在路径（递归和非递归版）

最新推荐文章于 2022-12-29 22:28:02 发布
最新推荐文章于 2022-12-29 22:28:02 发布
阅读量1k 收藏 3
点赞数 1
分类专栏： 【数据结构】C语言版
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Qregi/article/details/79231654
版权

求简单迷宫是否存在路径


代码中用到的栈代码如下：

stack.h

#pragma once

#include<stdio.h>
#include<stddef.h>
#include"Maze.h"

typedef Pos SeqType;

#define SEQDATAMAX 1000

/*创建一个栈的结构体*/
typedef struct SeqStack{
	SeqType data[SEQDATAMAX];
	int top;
	int bottom;
}SeqStack;


/*初始化栈*/
void SeqStackInit(SeqStack* seq);
/*从栈里面压入一个元素*/
void SeqStackPush(SeqStack* seq, SeqType value);
/*出栈一个元素*/
void SeqStackPop(SeqStack* seq);
/*取栈顶元素*/
SeqType SeqStackTopValue(SeqStack* seq);
/*销毁栈*/
void SeqStackDestory(SeqStack* seq);
/*判断当前栈是不是空栈*/
int SeqStackEmpty(SeqStack* seq);


stack.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"Stack.h"

/*初始化栈*/
void SeqStackInit(SeqStack* seq) {

	seq->top = 0;
	seq->bottom = seq->top;
}
/*从栈里面压入一个元素*/
void SeqStackPush(SeqStack* seq, SeqType value) {

	if (seq == NULL) {
		return;
	}
	/*判断栈是不是已经满了*/
	if (seq->top == SEQDATAMAX - 1) {
		return;
	}
	seq->top++;
	seq->data[seq->top] = value;
}
/*删除栈顶元素,出栈一个元素*/
void SeqStackPop(SeqStack* seq) {

	if (seq == NULL) {
		return;
	}
	/*判断栈是否为空栈*/
	if (seq->top == seq->bottom) {
		printf("栈为空");
		return;
	}
	seq->top--;
}
/*取栈顶元素*/
SeqType SeqStackTopValue(SeqStack* seq) {

	if (seq == NULL) {
		return;
	}
	return seq->data[seq->top];
}

/*销毁栈*/
void SeqStackDestory(SeqStack* seq) {

	if (seq == NULL) {
		return;
	}
	seq->top = 0;
}


/*判断当前栈是不是空栈*/
int SeqStackEmpty(SeqStack* seq) {
	if (seq == NULL) {
		return;
	}
	if (seq->top == seq->bottom) {
		return 1;
	}
	return 0;
}



非递归版代码如下：

maze.h

#pragma once

#include<stdio.h>

typedef struct Pos{
	int _Row;
	int _COL;
}Pos;

int maze[5][5] = { { 0, 1, 0, 0, 0 },
{ 0, 1, 1, 1, 0 },
{ 0, 1, 0, 1, 1 },
{ 1, 1, 0, 1, 0 },
{ 0, 0, 0, 1, 0 },
};
typedef struct Maze{

	struct Pos pos;

}Maze;


maze.c

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdlib.h>
#include"Maze.h"
#include"Stack.h"

/*判断当前点能否落脚*/
int CanStay(Pos* pos) {
	if (pos == NULL) {
		return;
	}
	/*行和列 小于0， 或者行也列大于5*/
	if (pos->_Row < 0 || pos->_COL < 0
		|| pos->_Row > 4 || pos->_COL > 4) {
		/*表示该点的行和列在迷宫外面*/
		return 0;
	}
	return 1;
}

/*标记当前点*/
void Mark(Pos* Pos, int Maze[5][5]) {
	if (Pos == NULL) {
		return;
	}
	Maze[Pos->_Row][Pos->_COL] = 2;
}
/*判断该点是不是出口*/
int Check_Export(Pos* Pos, int Maze[5][5]) {

	if (Pos == NULL) {
		return;
	}

		/*该点在迷宫地图内*/
		/*该点在地图边界*/
		if (Pos->_Row == 0 || Pos->_COL == 0 || Pos->_Row == 4 || Pos->_COL == 4) {

			if (Maze[Pos->_Row][Pos->_COL] == 1) {
				/*该点等于1，是出口*/
				return 1;
			}
		}
	return 0;
}

/*判断是否能形成通路*/
int Can_go(Pos* pos, int Maze[5][5]) {

	if (pos == NULL) {
		return;
	}
	/*如果当前点为1，则可以走*/
	if (Maze[pos->_Row][pos->_COL] == 1) {
		return 1;
	}
	return 0;
}

/*得到出口路径*/
/*传入入口点和一个地图*/
int Get_Path(Maze* entry, int Maze[][5]) {
	if (entry == NULL) {
		return;
	}
	/*判断入口点能否落脚*/
	if (!CanStay(entry)) {
		return;
	}
	SeqStack seq;
	SeqStackInit(&seq);

	//标记入口点，然后入栈入口点
	Mark(entry, Maze);
	SeqStackPush(&seq, entry->pos);
	Pos pos;
	pos = entry->pos;
	/*进入循环，循环停止条件是走到出口*/
	while (!Check_Export(&pos, Maze)) {

		/*进入循环了已经把入口点标记了，然后开始判断当前的点周围的四个点是否可以走*/

		/*上*/
		/*当前点的行加个1*/
		pos._Row -= 1;
		/*如果能落脚，在地图上*/
		if (CanStay(&pos, Maze)) {
			/*判断该点是否能走*/
			if (Can_go(&pos, Maze)) {
				/*能走，判断是否为出口点*/
				if (Check_Export(&pos, Maze)) {
					break;
				}
				/*，标记该点把该点入栈*/
				Mark(&pos, Maze);
				SeqStackPush(&seq, pos);
				continue;
			}
		}
		pos._Row += 1;

		
		/*下*/
		pos._Row += 1;
		if (CanStay(&pos, Maze)) {
			if (Can_go(&pos, Maze)) {
				/*可以走*/
				if (Check_Export(&pos, Maze)) {
					break;
				}
				Mark(&pos, Maze);
				SeqStackPush(&seq, pos);
				continue;
			}
		}
		pos._Row -= 1;

		/*左*/
		pos._COL -= 1;
		if (CanStay(&pos, Maze)) {
			if (Can_go(&pos, Maze)) {
				/*可以走*/
				/*判断是不是出口点，如果是，就直接退出，找到该点了*/
				if (Check_Export(&pos, Maze)) {
					break;
				}
				Mark(&pos, Maze);
				SeqStackPush(&seq, pos);
				continue;
			}
		}
		pos._COL += 1;

		/*右*/
		pos._COL += 1;
		if (CanStay(&pos, Maze)) {
			if (Can_go(&pos, Maze)) {
				/*可以走*/
				if (Check_Export(&pos, Maze)) {
					break;
				}
				Mark(&pos, Maze);
				SeqStackPush(&seq, pos);
				continue;
			}
		}
		pos._COL -= 1;

		
		/*每个点都走不了了，如果这个点是入口点，表示没有出口？*/
		if (pos._COL == entry->pos._COL && pos._Row == entry->pos._Row) {
			return 0;
		}
		/*
		**每个点都走不了了
		**这个时候出栈一个元素
		**然后让pos等于当前栈的栈顶元素(回溯)
		*/
		SeqStackPop(&seq);
		pos = SeqStackTopValue(&seq);
	}
	/*如果退出while循环，表示找到了出口点*/
	return 1;
}


int main() {

	/*只是判断有无出口*/
	Maze entry_pos;
	entry_pos.pos._Row = 0;
	entry_pos.pos._COL = 1;
	int path = Get_Path(&entry_pos,	maze);
	printf("expect 1, actual: %d", path);
	system("pause");
	return 0;
}



递归版代码如下:

maze.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"Maze.h"
#include"Stack.h"


int Canstay(Pos* pos) {
	/*判断当前点是否在地图上*/
	if (pos == NULL) {
		return;
	}
	if (pos->_Row < 0 || pos->_COL < 0 ||
		pos->_Row > 4 || pos->_COL > 4) {
		/*该坐标不在地图内*/
		return 0;
	}
	return 1;
}

/*判断该点是否为出口*/
int Check_Export(Pos* pos, int Maze[5][5]) {
	if (pos == NULL) {
		return;
	}
	/*先判断该坐标是否在地图上*/
	if (pos->_Row == 0 || pos->_COL == 0 ||
		pos->_Row == 4 || pos->_COL == 4) {

		if (Maze[pos->_Row][pos->_COL] == 1) {
			printf("出口点坐标为：(%d, %d)", pos->_Row, pos->_COL);
			return 1;
		}
	}
	return 0;
}

/*标记该点*/
void Mark(Pos* pos, int Maze[5][5]) {

	if (pos == NULL) {
		return;
	}
	Maze[pos->_Row][pos->_COL] = 2;
}
/*判断当前点是否是通路*/
int Can_Walk(Pos* pos, int Maze[5][5]) {
	if (pos == NULL) {
		return;
	}
	if (Maze[pos->_Row][pos->_COL] == 1) {
		return 1;
	}
	return 0;
}

int _GetPath(Pos* entry, Pos* pos, int  Maze[5][5]) {
	/*pos就是当前点*/
	if (entry == NULL) {
		return;
	}
	/*判断当前点是否在地图上*/
	if (!Canstay(entry)) {
		return 0;
	}
	/*标记入口点，然后把入口点压栈*/
	Mark(entry, maze);
	//SeqStack seq;
	//SeqStackPush(&seq, *entry);

	/*开始递归*/
	/*递归出口*/
	if (Check_Export(pos, Maze)) {
		return 1;
	}
	else {
		/*如果pos不是出口，就标记它*/
		Mark(pos, Maze);
	}



	/*上*/
	--pos->_Row;
	/*判断坐标是不是在地图上*/
	if (Canstay(pos)) {
		/*如果在地图内,判断该点是否可以走*/
		if (Can_Walk(pos, Maze)) {
			/*把该点标记下*/
			/*判断子问题是否成功找到通路*/
			if (_GetPath(entry, pos, Maze)) {
				return 1;
			}
		}
	}
	++pos->_Row;

	/*下*/
	++pos->_Row;
	if (Canstay(pos)) {
		if (Can_Walk(pos, Maze)) {
			if (_GetPath(entry, pos, Maze)) {
				return 1;
			}
		}
	}
	--pos->_Row;

	/*左*/
	--pos->_COL;
	if (Canstay(pos)) {
		if (Can_Walk(pos, Maze)) {
			if (_GetPath(entry, pos, Maze)) {
				return 1;
			}
		}
	}
	++pos->_COL;
	/*右*/
	++pos->_COL;
	if (Canstay(pos)) {
		if (Can_Walk(pos, Maze)) {
			if (_GetPath(entry, pos, Maze)) {
				return 1;
			}
		}
	}
	--pos->_COL;

	/*到了这里，表示该点走不通*/
	return 0;
}

int main() {
	/*不是最优解最短路径的递归求法*/
	Pos entry;
	Pos pos;
	entry._Row = 0;
	entry._COL = 1;

	pos = entry;
	int i = _GetPath(&entry, &pos, maze);
	printf("expect 1, actual: %d", i);
	system("pause");
	return 0;
}


简单迷宫的递归和非递归代码就这样了，地图在头文件里

Qregi
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
链式栈实现递归和非递归迷宫路径求解
07-11
在IT领域，尤其是在算法设计和数据结构应用中，迷宫路径求解是一个经典的挑战。本话题将深入探讨如何使用链式栈实现递归和非递归的迷宫路径求解方法，结合Java编程语言，以及深度优先搜索（DFS）策略。 首先，我们...
数据结构大作业的迷宫小游戏（递归和非递归都有）.zip
07-08
这个压缩包文件包含了一个关于数据结构的大学作业，主题是设计一个迷宫小游戏。这个项目不仅涉及到了递归算法，还包含了非递归的解决方案，显示了对多种算法的掌握和应用。下面是针对这个项目的一些关键知识点的详细...
DFS非递归实现搜索图中两顶点间的所有路径
naturerun的博客
12-11 1633
搜索无向图或有向图中两顶点间的所有最短路径应当使用DFS，配以适当的回溯操作即可实现路径搜索，具体代码如下，完全使用非递归方法实现 #include <iostream> #include <vector> #include <stdio.h> #include <malloc.h> #define N 6 //无环单边非负权重无向图顶点数 using namespace std; struct Path //路径节点结构体类型 { in
5-5 递归算法求解从入口到出口的所有迷宫路径
wuwuhuai的博客
02-13 5153
//递归算法求解从入口到出口的所有迷宫路径 #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}, {...
迷宫问题的所有路径，递归解法，不用栈，极精简56行，c/c++描述
zhangzhangkeji的博客
06-13 2591
  如图的一个迷宫，是一个10 X 10的矩阵，以 H 表示墙壁障碍物，以空格表示可以走的路径。起点是坐标（1，1），字符 ‘I’,表示in，终点是坐标（8，8），以字符‘O’表示，out。总共有几条路径可以从起点到终点呢？，而且，我们必然可以从所有路径中找到最短路径。   测试结果如下，同咱们的肉眼观察，只有三条路径。   全部代码如下，只有这一个源文件，极为精简。充分应用了递归。充分发挥编译器提供的递归功能。 #include<iostream> using namespace std;
关于递归在求解路经和中的应用
xdbzdgx的博客
08-01 199
觉得递归其实就是数学归纳法的逆运算。 做递归相关的题目时，有三点： 第一：明确要递归的函数要实现的功能，一定要相信这个函数可以完成任务； 第二：不要去考虑细枝末节和它时如何实现的，只考虑当前。 第三：找好终止条件； 下面我们来做路径总和的三道题： 112. 路径总和 这个题目是判断从根到叶子节点的路径和是否等于一个数。首先我们hasPathSum（root，sum）这个函数的作用是找出以root为根的树的路径和等于sum的个数，我们相信它可以实现。接下来找终止条件如果root是叶子节点的话，那
Java数据结构与算法（六）
weixin_43672579的博客
03-04 111
递归 什么是递归 递归就是方法自己调用自己，每次调用时传入不同的变量，递归有助于编程者解决复杂的问题，同时可以让代码变得简洁。 简单演示 阶乘 public static int recursion(int num){、 //利用递归计算阶乘 int sum=1; if(num < 0) throw new IllegalArgumentException("必须为正整数!");//抛出不合理参数异常 if(num==1)
简单版非递归迷宫.zip
07-12
《简单版非递归迷宫》是针对初学者设计的一个编程实践项目，它基于数据结构的知识，特别是利用栈这一数据结构来解决迷宫问题。这个压缩包中的核心内容是“迷宫”文件，可能包含了源代码、解释文档或示例说明。 在...
升级版非递归迷宫问题.zip
07-11
《升级版非递归迷宫问题》是一款基于数据结构与算法设计的迷宫求解程序。这个项目源自清华大学出版社出版的书籍中所介绍的非递归迷宫问题，旨在通过深度优先搜索（DFS）和随机生成策略来创建迷宫，并采用非递归的...
C语言迷宫问题递归和非递归求解
08-07
总的来说，C语言中的迷宫问题提供了一个实践数据结构和算法的好机会，无论选择递归还是非递归方法，都需要深入理解搜索策略和数据结构的运用。通过解决这类问题，可以提升编程思维和问题解决能力。
迷宫 最短路径及所有路径的问题
12-06
迷宫问题，完成的是一个现实中的迷宫游戏求最短路径及所有路径的问题，本程序相对于航班信息查询系统比较简单，主要包含使用系统迷宫（可以选择迷宫的入口和出口，并输出所有路径和最短路径），使用新建迷宫（可以自己设计迷宫的大小，及所有通路，可以选择迷宫的入口和出口，并输出所有路径和最短路径），用到了栈的使用，如栈的创建、入栈、出栈等函数功能。
求解迷宫全部路径问题
10-07
问题描述： 以一个m*n的长方阵表示迷宫，0和1分别表示迷宫中的通路和障碍。设计一个程序，对任意设定的迷宫，求出从入口（0，0）到出口（m-1，n-1）的通路和通路总数，或得出没有通路的结论。例如下图， 0（入口） 1 0 1 0 0 0 0 1 0 0 1 1 0 0 0 0 0 0 0 0 1 0 0 0（出口） 从入口到出口有6条不同的通路。 而下图： 0 0 1 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 0 0 1 1 0 1 0 1 1 1 0 0 1 0 0 0 0 1 0 0 0 0 0 1 0 0 0 1 0 1 0 1 1 1 1 0 0 1 1 1 0 0 0 1 0 1 1 1 0 0 0 0 0 0 从入口到出口则没有通路。 算法设计： 给定一个m*n的长方阵表示迷宫，设计算法输出入口到出口的通路和通路总数，或得出没有通路的结论。 算法提示： 和皇后问题与分书问题类似。可以用二维数组存储迷宫数据，对于迷宫中任一位置，均可约定有东、南、西、北四个方向可通。从当前位置a（用（x，y）表示一个位置，假定它是以向右的x轴和向下的y轴组成的平面上的一个点）出发依次尝试四个方向是否有路，若某个方向的位置b可通，则按照同样的方法继续从b出发寻找。若到达出口，则找到一条通路。 数据输入： 由文件input.txt 提供输入数据。第一行是m和n的值，空格分隔，其后共m行。每行有n个数字，数和数之间用空格分隔。 结果输出： 将计算出的所有从入口到出口的通路输出到文件output.txt 中。若没有通路，则将0写入文件中。
路径总和问题递归求解
m0_62995774的博客
12-29 135
利用递归方法求解
JAVA编程基础——迷宫找路径问题
Kiryul的博客
07-29 658
JAVA编程基础——迷宫找路径问题迷宫类主函数栈 问题描述： 给一个迷宫和一个入口，找出所有走出迷宫的路线并输出路线 分析： 1、可以用一个二维数组来表现迷宫地图；1表示墙，0表示路 2、用一个栈来存储走过的路线，走一步存一个 3、每走到一个格子就要遍历除了自己过来的那个方向的其他三个方向，判断，有路就往前走，遇墙就换方向，这样遍历到第四个就说明遇到死胡同，原路返回 4、设置一个边界判断，表示如果...
（*递归/动态规划）有多少种路径
DirBee的博客
03-31 1253
题目描述请编写一个函数（允许增加子函数），计算n x m的棋盘格子（n为横向的格子数，m为竖向的格子数）沿着各自边缘线从左上角走到右下角，总共有多少种走法，要求不能走回头路，即：只能往右和往下走，不能往左和往上走。输入描述:输入两个正整数输出描述:返回结果思路一：递归调用将右下角看做原点(0, 0)，左上角看做坐标(m, n)，从(m, n)—&gt;(0, 0)就分两步走：f(m, n - 1)...
【数据结构算法】迷宫的最短路径 - BFS
UESTC_201722的博客
08-05 849
题目 给定一个大小为N*M的迷宫，由通道(’.’)和墙壁(’#’)组成，其中通道S表示起点，通道G表示终点，每一步移动可以达到上下左右中不是墙壁的位置。试求出起点到终点的最小步数。（本题假定迷宫是有解的） 解题思路 是BFS和队列的结合应用 结合代码看，更容易理解 从起点开始，先将其加入队列，设置距离为0 从队列首端取出位置，将从这个位置能够到达的位置加入队列，并且让这些位置的距离为上一个位置的...
迷宫问题数据结构非递归
最新发布
06-25
迷宫问题通常使用数据结构和算法来解决，非递归的方法主要涉及到广度优先搜索（BFS）或深度优先搜索（DFS），但这里重点介绍广度优先搜索（BFS）因为它更适合用于寻找最短路径，特别是对于迷宫这类问题。 **BFS 解迷宫数据结构实现方法**: 1. **队列（Queue）**: BFS 使用队列作为主要的数据结构。从起点开始，每次从队列头部取出一个节点，然后检查其相邻的未访问节点，将这些节点添加到队列的尾部。这样可以保证总是先探索离起点最近的节点。 2. **二维数组或邻接矩阵**: 用来表示迷宫中的状态和可达性，0 表示通路，1 或其他值表示墙壁。随着搜索过程，可以标记已经访问过的节点，避免重复访问。 3. **路径记录**: 用一个额外的数据结构（如栈或数组）来存储找到的路径，当到达终点时，回溯路径就是解。 **BFS 非递归伪代码**（假设 maze 为二维数组，start 为起点，end 为终点）: ``` queue = [(start, [start])] visited = set() while queue: current_node, path = queue.pop(0) if current_node == end: return path if current_node not in visited: visited.add(current_node) for neighbor in get_neighbors(maze, current_node): if neighbor is not None and maze[neighbor]: queue.append((neighbor, path + [neighbor])) get_neighbors() 函数根据迷宫规则返回当前节点的所有相邻节点。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值