如何使用C语言实现简单迷宫(递归和非递归实现 含图例)

最新推荐文章于 2023-03-13 16:14:36 发布
最新推荐文章于 2023-03-13 16:14:36 发布
阅读量6.4k 收藏 50
点赞数 6
分类专栏： C语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ty6693/article/details/84232926
版权

1.非递归实现

简单迷宫：只有一条通路的迷宫

思路：在找迷宫通路的时候，我们往往是在给定入口(入口合法且为通路)的情况下，沿着入口的某个方向走（此方向是通路）。现给定走迷宫的方向：上、左、右、下，即优先朝“上”走，如果“上”不通，朝“左”走；如果“左” 不通，朝“右”走；“右”再不通的话，朝“下”走。每次在当前步cur可以走通的情况下，先将cur保存起来，并将其标记成已走过的步，然后判断下一步next（优先朝“上”）是否可以走通。在next可以走通的情况下，继续上述过程，直到找到出口。    但这里有一个问题，当cur步的上下左右均走不通的时候我们该怎么办呢？--->此时表明cur步走错了，我们不应该再将其保存起来，因为此时的cur不是路径的一部分，并且还应该将其标记成走错的步，然后回退到上一步，继续朝其它方向（假设开始cur是从“上”回退的，那么此时cur可以向“左”走）寻找通路。  前边提到如果cur可以走通，我们便将其保存起来，然后走next步，这里我们可以用“栈”保存路径。找到一个可以走通的cur便让其入栈（保存起来），如果cur步走错了的话再让其出栈（不保存走错的cur步）。这样我们便充分利用了栈“后进先出”的特性。

现给定一个简单迷宫如下图所示（0表示不通，1表示可以走通）：

为了方便描述位置，我们用二维数组来表示其每个点坐标。

现给定入口坐标(3,1)：

1.先判断入口坐标是否合法（坐标是否在边界，值是否为1）

2.在入口合法的情况下，先让其入栈保存，并标记成已走步（现为了简便，将其标记成2）

 3.此时优先朝入口的上方寻找通路，如果next步可以走通，入栈保存next，并将其标记成已走步2

（ 如果上方不通，朝左走，如果next步可以走通，入栈保存next，并将其标记成已走步2

  如果左边不通，朝右走，如果next步可以走通，入栈保存next，并将其标记成已走步2

  如果右边不通，朝下走，如果next步可以走通，入栈保存next，并将其标记成已走步2）

 4.在每次入栈保存位置坐标之后，判断是否是出口，如果是出口，直接返回；如果不是，继续步骤3

具体寻找通路过程如下所示（上方的图形表示栈）：

                                         

 源代码如下：

//Stack.h:
#pragma once

#define MAX_SIZE 100
#include <assert.h>
#include <stdio.h>

typedef Position SDataType;
typedef struct Stack
{
	SDataType array[MAX_SIZE];
	int top;      //size
}Stack;

// 初始化 
void StackInit(Stack *pStack)
{
	assert(pStack);
	pStack->top = 0;
}


// 压栈 
void StackPush(Stack *pStack, SDataType data)
{
	assert(pStack);
	if (MAX_SIZE == pStack->top)
	{
		printf("栈已满\n");
		return;
	}
	pStack->array[pStack->top] = data;
	pStack->top++;
}


//判空 空返回1
int StackEmpty(Stack *pStack)
{
	assert(pStack);
	if (0 == pStack->top)
		return 1;
	return 0;
}


// 出栈 
void StackPop(Stack *pStack)
{
	assert(pStack);
	if (StackEmpty(pStack))
	{
		printf("栈为空\n");
		return;
	}
	pStack->top--;
}



// 返回栈顶元素 
SDataType StackTop(Stack *pStack)
{
	assert(pStack);
	return pStack->array[pStack->top - 1];
}


// 返回数据个数 
int StackSize(Stack *pStack)
{
	assert(pStack);
	return pStack->top;
}

//Maze.h

//简单迷宫（非递归）
#pragma once

typedef struct Position   
{
	int _x;
	int _y;
}Position;

#define MAX_ROW  4
#define MAX_COL  4

typedef struct Maze
{
	int _map[MAX_ROW][MAX_COL];
}Maze;



//Maze.c
#include <stdio.h>
#include <assert.h>
#include "Stack.h"

//初始化迷宫
void InitMaze(Maze *m, int map[][MAX_COL])
{
	int i, j;
	if (NULL == m)
	{
		return;
	}
	for (i = 0; i < MAX_ROW; i++)
	{
		for (j = 0; j < MAX_COL; j++)
		{
			m->_map[i][j] = map[i][j];
		}
	}
}


//判断入口是否合法
int IsValidEntry(Maze *m, Position entry)
{
	assert(m);    //保证迷宫存在
	if (0 == entry._x || entry._x == MAX_ROW - 1 || 0 == entry._y || entry._y == MAX_COL - 1)   //在边界
	{
		return 1 == m->_map[entry._x][entry._y];     //如果存的是1，表示是通路；否则，不是通路
	}
	return 0;    //不在边界则一定不是合法入口
}


//判断是否是通路
int IsPass(Maze *m, Position cur)
{   //cur一定在迷宫中
	if (1 == m->_map[cur._x][cur._y])  //若cur步存的是1，则表示是通路
	{
		return 1;
	}
	return 0;
}


//判断是否是出口
int IsExit(Maze *m, Position cur, Position entry)
{
	if (cur._x == entry._x && cur._y == entry._y)  //如果cur等于entry(入口)，表明不是出口
	{
		return 0;
	}
	if (0 == cur._x || cur._x == MAX_ROW - 1 || 0 == cur._y || cur._y == MAX_COL - 1) //在cur不是入口的前提下，如果cur在边界，则表明是出口
	{
		return 1;
	}
	return 0;
}


//entry表示迷宫的入口，栈s保存走过的路径
void PassMaze(Maze *m, Position entry, Stack *s)
{
	Position cur,next;
	//先判断入口是否合法，不合法直接退出
	if (!IsValidEntry(m, entry))
	{
		printf("非法的迷宫入口!\n");
		return;
	}

	StackPush(s,entry);    //入口合法，让其入栈

	while (!StackEmpty(s))    //栈不为空，表明有出口。若迷宫没有入口，则cur会一直出栈，直到空
	{
		cur = StackTop(s);  //取栈顶（前提：栈不为空）
		m->_map[cur._x][cur._y] = 2; //标记一下，代表此位置已经走过

		if (IsExit(m, cur,entry))     //检测cur是否是出口，若为出口，直接返回退出
		{
			return;
		}

		//上
		next = cur;
		next._x -= 1;
		if (IsPass(m, next))
		{
			StackPush(s, next);    //下一步可以走通，让其入栈，先保存起来
			continue;

		}

		//左
		next = cur;
		next._y -= 1;
		if (IsPass(m, next))
		{
			StackPush(s, next);   //下一步可以走通，让其入栈，先保存起来
			continue;

		}

		//右
		next = cur;
		next._y += 1;
		if (IsPass(m, next))
		{
			StackPush(s, next);    //下一步可以走通，让其入栈，先保存起来
			continue;

		}

		//下
		next = cur;
		next._x += 1;
		if (IsPass(m, next))
		{
			StackPush(s, next);     //下一步可以走通，让其入栈，先保存起来
			continue;
		}

		StackPop(s);     //上下左右均走不通，表明cur步走错了，让其出栈，不要出现在最终路径中
		m->_map[cur._x][cur._y] = 3;     //标记走错的步为3
	}

}


//打印迷宫
void PrintMaze(Maze *m, int map[][MAX_COL])
{
	int i, j;
	if (NULL == m)
	{
		return;
	}
	for (i = 0; i < MAX_ROW; i++)
	{
		for (j = 0; j < MAX_COL; j++)
		{
			printf("%d ", m->_map[i][j]);
		}
		printf("\n");
	}
}


//打印最终路径
void Print(Stack *s)
{
	Position top;
	while (StackSize(s) > 1)
	{
		top = StackTop(s);
		StackPop(s);
		printf("(%d,%d) <- ", top);
	}
	top = StackTop(s);
	printf("(%d,%d)\n", top);
}




void TestMaze()
{
	int map[MAX_ROW][MAX_COL] = { { 0, 0, 0, 0},
	                              { 0, 1, 0, 0},
	                              { 0, 1, 1, 1},
	                              { 0, 1, 0, 0}};
	Stack s;
	Position entry;
	Maze m;
	InitMaze(&m,map);
	PrintMaze(&m, map);
	printf("\n");

	StackInit(&s);
	entry._x = 3;
	entry._y = 1;
	PassMaze(&m, entry, &s);
	PrintMaze(&m, map);
	printf("\n");
	Print(&s);
	
}

最终打印出来的路径如下图所示：

 

2.递归实现

思路：在给定入口（入口合法且为通路）的情况下，我们可以把入口的下一步，比如入口上方（上方为通路）作为新的入口点继续走迷宫，直到走完整个迷宫。

源代码如下：

//MazeR.h
//简单迷宫（递归）
#pragma once

typedef struct Position
{
	int _x;
	int _y;
}Position;

#define MAX_ROW  4
#define MAX_COL  4

typedef struct Maze
{
	int _map[MAX_ROW][MAX_COL];
}Maze;




//MazeR.c
#include <stdio.h>
#include <assert.h>


//初始化
void InitMaze(Maze *m, int map[][MAX_COL])
{
	int i, j;
	if (NULL == m)
	{
		return;
	}
	for (i = 0; i < MAX_ROW; i++)
	{
		for (j = 0; j < MAX_COL; j++)
		{
			m->_map[i][j] = map[i][j];
		}
	}
}


//判断入口是否合法
int IsValidEntry(Maze *m, Position entry)
{
	assert(m);    //保证迷宫存在
	if (0 == entry._x || entry._x == MAX_ROW - 1 || 0 == entry._y || entry._y == MAX_COL - 1)   //在边界
	{
		return 1 == m->_map[entry._x][entry._y];    //如果存的是1，表示是通路；否则，不是通路
	}
	return 0;     //不在边界则一定不是合法入口
}


//判断是否是通路
int IsPass(Maze *m, Position cur)
{   //cur一定在迷宫中
	if (1 == m->_map[cur._x][cur._y])  //若cur步存的是1，则表示是通路
	{
		return 1;
	}
	return 0;
}


//判断是否是出口
int IsExit(Maze *m, Position cur, Position entry)
{
	if (cur._x == entry._x && cur._y == entry._y)  //如果cur等于entry(入口)，表明不是出口
	{
		return 0;
	}
	if (0 == cur._x || cur._x == MAX_ROW - 1 || 0 == cur._y || cur._y == MAX_COL - 1) //在cur不是入口的前提下，如果cur在边界，则表明是出口
	{
		return 1;
	}
	return 0;
}

int _PassMaze(Maze *m, Position entry, Position cur)
{
	Position next;
	if (IsPass(m, cur))
	{
		m->_map[cur._x][cur._y] = 2;    //标记一下，代表此位置已经走过

		if (IsExit(m, cur, entry))     //检测cur是否是出口，若为出口，直接返回退出
		{
			return 1;
		}

		//上
		next = cur;
		next._x -= 1;
		if (_PassMaze(m, entry, next))   //递归时，next为下一次的入口，继续走迷宫
		{
			return 1;
		}

		//左
		next = cur;
		next._y -= 1;
		if (_PassMaze(m, entry, next))    //递归时，next为下一次的入口，继续走迷宫
		{
			return 1;
		}

		//右
		next = cur;
		next._y += 1;
		if (_PassMaze(m, entry, next))     //递归时，next为下一次的入口，继续走迷宫
		{
			return 1;
		}

		//下
		next = cur;
		next._x += 1;
		if (_PassMaze(m, entry, next))      //递归时，next为下一次的入口，继续走迷宫
		{
			return 1;
		}
		m->_map[cur._x][cur._y] = 3;    //cur步走错了，标记成3
	}
	return 0;
}


//entry表示入口，栈s保存走过的路径
void PassMaze(Maze *m, Position entry)
{
	//先判断入口是否合法，不合法直接退出
	if (!IsValidEntry(m, entry))
	{
		printf("非法的迷宫入口!\n");
		return;
	}
	_PassMaze(m, entry, entry);      //第一个entry表示入口，第二个entry表示当前入口

}


//打印迷宫
void PrintMaze(Maze *m, int map[][MAX_COL])
{
	int i, j;
	if (NULL == m)
	{
		return;
	}
	for (i = 0; i < MAX_ROW; i++)
	{
		for (j = 0; j < MAX_COL; j++)
		{
			printf("%d ", m->_map[i][j]);
		}
		printf("\n");
	}
}






void TestMaze()
{
	int map[MAX_ROW][MAX_COL] = { { 0, 0, 0, 0 },
	                              { 0, 1, 0, 0 },
	                              { 0, 1, 1, 1 },
	                              { 0, 1, 0, 0 } };
	
	Position entry;
	Maze m;
	InitMaze(&m, map);
	PrintMaze(&m, map);
	printf("\n");

	
	entry._x = 3;
	entry._y = 1;
	PassMaze(&m, entry);
	PrintMaze(&m, map);
	printf("\n");
	
}

 

ty6693
关注
专栏目录
用C语言写迷宫
m0_57907595的博客
07-13 623
用C语言写迷宫 思路： 1、定义一个二维数组作为迷宫 0 ‘ ’ 1 ‘#’ 2 ‘@’ 2、定义两个变量来记录老鼠的坐标 3、记录游戏开始时间 4、进入死循环 （1）清理屏幕system(“clear”); （2）显示迷宫（遍历打印二位数组） （3）判断是否到达出口 是：获取游戏结束时间 结束程序 （4）获取方向键并处理 判断前方是否是路 是： 1、旧位置=0； 2、新位置=2； 3、更新老鼠的位置 #include <stdio.h> #include <getch.h>
迷宫问题的递归回溯算法c语言,c语言迷宫问题求解——递归、栈回溯
weixin_36345268的博客
05-23 1857
第一次写，见谅以下是求迷宫的实现为什么下面会出现标签啊，有什么简便的方法去掉吗？求告知最后是关于求所有通路，个人愚笨只想到改变搜索方向顺序这种笨方法，总共有16种不同顺序，有兴趣的小伙伴可以试一下/*第一部分使用递归求解为了数据的简单化，不对路口进行数据结构化，将用一个简单的int类型数组来表示迷宫因为每一个路口的四个方向相对于当前路口的位移都是一样的，这样可以用一个int类型二位数据表示四个方向...
C语言迷宫问题递归和非递归求解
08-07
C语言迷宫问题递归和非递归求解，手动或者自动生成迷宫均可
递归与非递归实现走迷宫算法
defs6497的博客
10-09 803
●问题描述： 　　给出一个矩阵，其中0表示通路，1表示墙壁，这样就形成了一个迷宫，要求编写算法求出其中一条路径。 ●递归思路： 　　编写一个走迷宫函数，传入二位数组的下标，先假设该点位于最终路径上（将0置为2）再探测周围四个点是否可以走通（是否为０），如果可以走通则将该点四周能走通的点作为函数参数传入函数进入递归。若四周均不能走通（都不为０时）则将该点置回０表示该点不是...
c语言非递归实现迷宫
zw_ss
07-27 1847
　此题可以使用栈来避开递归，首先需要开辟一个和迷宫具有同样几何形状的结构体二维数组来保存是从哪一个点（坐标）到达该点的（该初始化时将所有的坐标都置为0），还需要一个可以保存坐标的栈。每次将能够走通的点（值为1）都入栈然后在循环的开始处将栈顶元素弹出保存进temp变量（保存坐标的变量）中，访问temp变量四周的元素是否可以被访问，如果可以被访问（值为０）则将对应路径数组中的元素（即对应坐标）值改为t...
链式栈实现递归和非递归迷宫路径求解
07-11
本话题将深入探讨如何使用链式栈实现递归和非递归的迷宫路径求解方法，结合Java编程语言，以及深度优先搜索（DFS）策略。 首先，我们要理解链式栈是一种基于链表的数据结构，它支持栈的基本操作——压入（push）和...
使用C语言递归与非递归实现字符串反转函数char *reverse(char *str)的方法
09-05
理解和掌握递归与非递归实现字符串反转是提升C语言编程技巧的重要步骤。在实际应用中，应根据具体需求和性能要求选择合适的实现方式。在学习过程中，可以尝试对这两种方法进行优化，例如，使用迭代法改进递归实现，...
基于C语言实现简单语言递归下降语法制导翻译(编译原理)【100012399】
最新发布
05-24
本项目“基于C语言实现简单语言递归下降语法制导翻译”深入探讨了这一主题，主要关注如何使用C语言来设计和实现一个编译器的核心部分——语义分析和中间代码生成。 首先，我们要理解什么是递归下降解析。递归下降是...
Ｃ语言利用递归算法解决迷宫问题
09-07 3730
上次在ＣＳＤＮ上有人求解一个迷宫算法，当时刚好有点时间，就随便写了写，主要是利用递归回溯，直到找到正确路径为止，当然这个算法还可以稍加修改，也很容易把所有的路径都计算出来．然后找一个最短路径之类的，很容易．//////////////////////////////////////////begin *.c//////////////////////////////////////////////
用C语言做一个迷宫小游戏
qq_41019656的博客
03-13 989
这个迷宫游戏使用了递归回溯算法来寻找通往出口的路径。迷宫中的墙用’#‘表示，路径用空格表示，入口和出口分别用’S’和’E’表示，已走过的路径用’*'表示。在生成迷宫时，先将所有格子初始化为墙，然后随机生成一些路径。在生成入口和出口时，需要避免它们位于墙上或者在同一个位置上。玩家通过在控制台中输入方向键来移动，如果找到了通往出口的路径，程序输出“Congratulation!”，否则输出“Sorry, you are trapped in the maze.”。用C语言做一个迷宫小游戏，以下是代码段。
C语言简单迷宫游戏代码
09-20
C语言中的迷宫：你可以通过键盘上的“W”、“A”、“S”、“D”,4个按键来控制一个小球向上、下、左、右移动，目的就是让这个小球从起点走出迷宫。
C语言生成迷宫并用递归算法求解路径
04-25
在Codeblocks中首先用C语言生成一个迷宫并用递归算法求解一条可行的路径
C例子：走迷宫（C语言实现）
09-06
该程序是我写的博客“一起talk C栗子吧（第四十七回：C语言实例--走迷宫一）”的配套程序，共享给大家使用
C语言用递归函数实现迷宫求解（无数据结构）
Sett_Chen的博客
05-26 750
C语言简单的迷宫求解代码，无堆，无栈，无链表。如果对迷宫问题感兴趣，但是基础知识并不足够解决的同学可以参考一下。
基于C语言实现迷宫
热门推荐
L_X_Y_HH的博客
04-21 1万+
说到迷宫，首先一定要有一个迷宫的地图，让后还要规定寻找迷宫出口的一些规则关于迷宫的地图，在这里我创建了一个二维数组来表示迷宫地图，并且约定（1）位置0为墙（即不能走的地方），位置1为路（2）走到边界点的位置，就为出路（3）按照上、右、下、左（顺时针）的顺序来探测下一步出路，若下一步路，就往下走（4）若当前点可以走，就将当前点标记为2，为了区分位置1，防止不知道自己走了重复的路首先先来创建迷宫地图并...
c语言递归算法求解迷宫问题,c语言迷宫问题的求解(栈和递归)
weixin_34855166的博客
05-23 2352
迷宫问题的求解(栈和递归)实验报告【实验名称】项目一迷宫问题的求解【实验目的】1.了解栈的基本操作以及充分理解栈的特点。熟悉掌握栈的基本操作和结构体的运用。2.学会用栈或者递归方法解决迷宫问题。【实验原理】1.本次实验中，以二维数组maze[row][col]表示迷宫，0表示通路，1表示墙，在构建迷宫时，为了清晰显示，在最外层添加一圈墙。2.算法的核心思想是利用栈后进先出的特点，对迷宫进行探索，如...
c语言用递归算法实现迷宫,用c 实现的迷宫递归算法
weixin_39875842的博客
05-25 352
程序已经被vc6.0调试过，包括一个头文件maze.h和一个主程序再附加一个说明文件格式的代码#ifndef MAZE_H#define MAZE_H#include#include#includetypedef struct{int left;int forward;int right;}Intersection;class Maze{private:int mazesize;int EXIT;...
C语言 迷宫设计
wuchao2020ji的博客
01-20 5360
C 语言 C++ 迷宫问题 迷宫设计
递归算法迷宫c语言,[原创]递归随机迷宫生成算法详解
weixin_42498163的博客
05-25 91
该楼层疑似违规已被系统折叠隐藏此楼查看此楼#include#include#includecharcw[][4]={"　...
C语言实现迷宫路径探索：非递归算法与数据结构应用
本文档主要探讨了如何使用C语言解决迷宫问题，特别是针对给定的m*n长方形迷宫，其中0代表通路，1代表障碍。目标是设计一个非递归程序，利用链表实现的栈来找到从入口到出口的路径，并以三元组（i, j, d）的形式输出...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值