数据结构之迷宫求解栈（链式栈）实现，队列（循环队列）实现

最新推荐文章于 2022-01-13 00:05:20 发布
最新推荐文章于 2022-01-13 00:05:20 发布
阅读量631 收藏 15
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43312665/article/details/103790768
版权

思路：
将迷宫的布局的矩阵（对应位置的值为0：表示通路，1：表示障碍，-1：表示已访问过）作为全局变量，flag作为全局变量，flag=1:邻居中有出口，flag=0：邻居中无出口，然后先把入口Enter的位置入栈，然后把入口在迷宫布局中对应的值改成-1，表示已经访问过，然后进入循环，
{栈顶元素出栈，先判断栈顶元素是否是出口的位置，如果是，则退出循环，如果不是则继续，将flag改成0，然后从出栈元素开始按照一定次序访问邻居，
{如果邻居存在（注意不能越界）且可通（在矩阵中对应位置是0），则将flag改为1，位置入栈，迷宫矩阵中邻居位置所对应的值改为-1}
如果flag=0，就出栈}

#include<stdio.h>
#include<stdlib.h>
#define OVERFLOW -1
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define MAX_ROW  12
#define MAX_COL  14
typedef struct {
	int Line; //行
	int Column;//列
}SElemType;
typedef int Status;
int flag;
int maze[12][14] = {
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
    1, 0, 1, 0, 0, 0, 1, 0, 1, 1, 0, 1, 1, 1,
    1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 1,
    1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 1,
    1, 0, 1, 1, 1, 0, 1, 0, 0, 0, 1, 0, 1, 1,
    1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1,
    1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1,
    1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1,
	1, 0, 0, 0, 0, 1 ,0 ,0, 0 ,0 ,1 ,0 ,1 ,1,
	1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 0, 1,
	1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1,
	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
typedef struct {
	int flag;
	SElemType* base;
	SElemType* top;
	int stacksize;
}SqStack;
typedef struct SNode {
	SElemType data;
	struct  SNode* next;
}SNode, * LinkStack;
LinkStack InitStack()//注意这个初始化方式！！！！！！
{
	LinkStack s = (SNode*)malloc(sizeof(SNode));
	if (!s)
		exit(OVERFLOW);
	s->next= NULL;
	return s;
}
void Push(LinkStack s, SElemType e)
{
	LinkStack p = (SNode*)malloc(sizeof(SNode));
	if (p == NULL)
		exit(OVERFLOW);
	p->data = e;
	p->next = NULL;
	p->next = s->next;
	s->next = p;//与单链表的头插法相似
}
SElemType Pop(LinkStack s)
{
	LinkStack q;
	q = s->next;
	SElemType e = q->data;
	s->next = q->next;
	free(q);//删除单链表的第一个元素
	return e;
}
Status StackEmpty(LinkStack s)
{
	if (s->next == NULL)
		return TRUE;
	else
	{
		return FALSE;
	}
}
SElemType GetTop(LinkStack l)
{
	return l->next->data;
}
void StackTravers(LinkStack s)
{
	SNode* p = s->next;
	while (p != NULL)
	{
		printf("(%d,%d)\n",p->data.Line, p->data.Column);
		p = p->next;
	}
}
void Visit(SElemType e, LinkStack s, int i)
{
	Push(s, e);
	switch (i)
	{
	case 1:e.Column++; Push(s, e); maze[e.Line][e.Column] = -1; flag = 1; break;//向右
	case 2:e.Line++; Push(s, e); maze[e.Line][e.Column] = -1; flag = 1; break;//向下
	case 3:e.Column--; Push(s, e); maze[e.Line][e.Column]= -1; flag = 1; break; //向左
	case 4:e.Line--; Push(s, e); maze[e.Line][e.Column]= -1; flag = 1; break;//向上
	}
}
Status Mazesolution(int line,int column)
{
	SElemType StackTop,Enter,Path;
	Enter.Column = 1;
	Enter.Line = 1;
	maze[1][1] = -1;
	LinkStack s=InitStack();
	Push(s, Enter);
	while (!StackEmpty(s))
	{
		StackTop = GetTop(s);
		if (StackTop.Line == line - 2 && StackTop.Column == column - 2)
		{
			StackTravers(s);//打印路径
			return OK;
		}
		flag = 0;
		if (StackTop.Column + 1 < column - 1 && maze[StackTop.Line][StackTop.Column+1] == 0)//向右
		{
			Visit(StackTop, s,1);
			continue;
		}
		if (StackTop.Line + 1 < line - 1 && maze[StackTop.Line+1][StackTop.Column] == 0)//向下
		{
			Visit(StackTop, s, 2);
			continue;
		}
		if (StackTop.Column -1 >=1 && maze[StackTop.Line][StackTop.Column-1] == 0)//向左
		{
			Visit(StackTop, s, 3);
			continue;
		}
		if (StackTop.Line - 1 >=1 && maze[StackTop.Line-1][StackTop.Column] == 0)//向上
		{
			Visit(StackTop, s, 4);
			continue;
		}
		if (flag == 0)
		{
			Path=Pop(s);
		}
	}
	return ERROR;
}
int main()
{
	printf("%d\n",Mazesolution(12, 14));
	return 0;
}

循环队列： (感觉用队列更简单一点)
入口入队列q,修改入口位置在迷宫矩阵中的值为-1，然后进入循环，只要队不空
{
出队A
如果A是出口， return OK;
{从A开始按一定次序扫描邻居B，如果B的位置不越界且可通，修改位置B在迷宫矩阵中的值为-1，B进队列}
}

#include<stdio.h>
#include<stdlib.h>
#define OVERFLOW -1
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define MAX_ROW  12
#define MAX_COL  14
#define MAXQSIZE 100 //最大队列长度
typedef struct {
	int Line; //行
	int Column;//列
}QElemType;
typedef int Status;
int flag;
int maze[12][14] = {
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
    1, 0, 1, 0, 0, 0, 1, 0, 1, 1, 0, 1, 1, 1,
    1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 1,
    1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 1,
    1, 0, 1, 1, 1, 0, 1, 0, 0, 0, 1, 0, 1, 1,
    1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1,
    1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1,
    1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1,
	1, 0, 0, 0, 0, 1 ,0 ,0, 0 ,0 ,1 ,0 ,1 ,1,
	1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 0, 1,
	1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1,
	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
typedef struct {
	QElemType* base;//动态分配存储空间
	int front;//头指针，若队列不空，指向队列头元素
	int rear;//尾指针，若队列不空，指向队列尾元素的下一个位置
}SqQueue;
Status InitQueue(SqQueue* Q)
{
	Q->base = (QElemType*)malloc(MAXQSIZE * sizeof(QElemType));
	if (!Q->base)
		exit(OVERFLOW);
	Q->front = Q->rear = 0;
	return OK;
}
Status EnQueue(SqQueue* Q, QElemType e)
{
	if ((Q->rear + 1) % MAXQSIZE == Q->front)//判满
		return ERROR;
	Q->base[Q->rear] = e;
	Q->rear = (Q->rear + 1) % MAXQSIZE;
	return OK;
}
Status Dequeue(SqQueue* q, QElemType* e)
{
	if (q->front == q->rear)//判空
		return;//队列为空
	*e = q->base[q->front];
	q->front = (q->front + 1) % MAXQSIZE;
	return OK;
}
int QueueLength(SqQueue Q)
{
	return (Q.rear - Q.front + MAXQSIZE) % MAXQSIZE;//注意
}

void QueueTravers(SqQueue q)
{
	for (int i = 0; i < QueueLength(q); ++i)
	{
		printf("%d %d\n", q.base[i].Line,q.base[i].Column);
	}
}
void Visit(QElemType e, SqQueue* s, int i)
{
	EnQueue(s, e);
	switch (i)
	{
	case 1:e.Column++;EnQueue(s, e); maze[e.Line][e.Column] = -1; break;//向右
	case 2:e.Line++; EnQueue(s, e); maze[e.Line][e.Column] = -1; break;//向下
	case 3:e.Column--; EnQueue(s, e); maze[e.Line][e.Column]= -1; break; //向左
	case 4:e.Line--; EnQueue(s, e); maze[e.Line][e.Column]= -1; break;//向上
	}
}
Status Mazesolution(int line,int column)
{
	QElemType Enter;
	QElemType* Path = (QElemType*)malloc(sizeof(QElemType));
	Enter.Column = 1;
	Enter.Line = 1;
	maze[1][1] = -1;
	SqQueue* q = (SqQueue*)malloc(sizeof(SqQueue));
	int t=InitQueue(q);
	EnQueue(q, Enter);
	while (q->front!=q->rear)
	{
		t=Dequeue(q, Path);
		printf("%d %d\n", Path->Line, Path->Column);//打印路径？
		if (Path->Line == line - 2 && Path->Column == column - 2)
		{
			return OK;
		}
		flag = 0;
		if (Path->Column + 1 < column - 1 && maze[Path->Line][Path->Column+1] == 0)//向右
		{
			Visit(*Path, q,1);
			continue;
		}
		if (Path->Line + 1 < line - 1 && maze[Path->Line+1][Path->Column] == 0)//向下
		{
			Visit(*Path, q, 2);
			continue;
		}
		if (Path->Column -1 >=1 && maze[Path->Line][Path->Column-1] == 0)//向左
		{
			Visit(*Path, q, 3);
			continue;
		}
		if (Path->Line - 1 >=1 && maze[Path->Line-1][Path->Column] == 0)//向上
		{
			Visit(*Path, q, 4);
			continue;
		}
	}
	return ERROR;
}
int main()
{
	printf("%d\n",Mazesolution(12, 14));
	return 0;
}
泡脚早睡早饭
关注
以栈解决迷宫问题
weixin_34248849的博客
05-19 238
怎么找到一个迷宫的出口呢。首先要知道迷宫长啥样，之后知道出入口，再之后就是找通路的过程了。显然主要的部分是如何找通路。我们就举一个例子：在这个迷宫中0就是墙，1就是路。那么我们可以用一个二维数组来表示这个迷宫。之后我们需要一种结构来实现我们表示位置的移动。structPos { size_tline; size_trow; };这个结...
简单的迷宫问题 ——链栈实现
From now on...的Blogs
11-03 1105
迷宫问题直接dfs或者bfs多easy，非要用自己搞的链栈。。。。 不过思想很类似搜索 #include<stdio.h> #include<stdlib.h> #define OK 1 #define ERROR 0 typedef int Status; struct node{ int x; int y; }; typedef struct s...
数据结构之python实现栈的链式存储具体实例
不服输的南瓜的博客
02-24 684
题目如下： python实现： class StackNode: def __init__(self): self.data = None self.next = None class LinkStack: def __init__(self): self.top = StackNode() '''判断链栈是否为空''' ...
用栈实现迷宫问题-C
sofency'Blog
04-16 1127
问题分析： 每走一步需要判断周围四个方向是否可以走 假设我们所走的当前位置无处可走，就要进行退栈，退栈之后那么在退栈之后的位置进行判断时不必要再讲刚才走死胡同的那条路径再考虑进来，因此我们引入di进行记录刚才走过的方向 设计的栈结构体如下 typedef struct { int x; int y; int di;//假如退栈时记录了上次在该点走过的方向 }Box; typed...
数据结构实验报告（包括线性表、栈和队列、串、二叉树、图、查找与排序算法的设计与实现）
最新发布
06-09
- **队列求解迷宫问题**：`Project3.2`部分探讨了使用队列解决迷宫问题的方法，队列用于保存待探索的路径，从而找到从起点到终点的所有可能路径。 #### 四、串的模式匹配算法设计 - **顺序串基本运算**：`Project...
C语言 数据结构中求解迷宫问题实现方法
08-30
本文将详细讲解如何使用C语言和数据结构来实现迷宫问题的求解。 首先，迷宫问题的基本思想是穷举法，也就是广度优先搜索（BFS）或深度优先搜索（DFS）。在本例中，采用了深度优先搜索的方法，通过栈来保存当前位置...
数据结构P50.改栈用来队列实现迷宫。输出从开始到终点的路径。
04-05
本问题主要探讨了如何利用数据结构，特别是栈和队列来解决迷宫问题，并找到从起点到终点的路径。这里我们将详细解析这个话题。 首先，迷宫问题是一个经典的图遍历问题，通常可以使用深度优先搜索（DFS）或广度优先...
利用栈和队列实现迷宫
06-20
我们可以通过栈来实现迷宫的求解，首先将起点压入栈中，然后通过循环来判断当前点是否为终点，如果不是则将可能的下一步压入栈中，直到找到终点。这种方法的缺点是可能会出现死循环，因为栈中可能会出现重复的点。 ...
zhanheduilie.rar_ zhanheduilie_栈操作_栈的初始化_迷宫求解_队列 初始化 、入队列和出队列 的算
09-22
（1）采用链式存储实现... （4）采用顺序存储实现循环队列的初始化、入队、出队操作。 （5）在主函数中设计一个简单的菜单，分别测试上述算法。 （6）综合训练:1)利用栈实现表达式求值算法。 2)利用栈实现迷宫求解。
利用链式栈结构求迷宫问题所有解：回溯算法，两种输出形式数组输出和三元组输出
06-06
VC6.0，详细注释，编译无误 利用链式栈结构求迷宫问题所有解：回溯算法，两种输出形式数组输出和三元组输出
数据结构课程实验->迷宫->分别用链栈，链队，顺序栈，顺序队实现。
Logan
10-30 759
迷宫     实现老鼠走迷宫程序。     功能要求：①输出每一步尝试的状态，直到走完迷宫或无法走通②在迷宫有解的前提下，输出从起点到终点的最短通路。     设计要求：迷宫至少10×10；起点和终点可自定义，也可固定；迷宫可随机生成，也可固定，可以无解；两个功能可用不同算法和程序实现；输出可以是图形界面，也可以是文本界面（如下例）。 # # # # # # # # # # # 0 # # 0 0...
数据结构与算法【Python实现】（三）栈和队列应用——迷宫问题
hhhxykeke的博客
01-13 780
一个二维列表表示迷宫(0表示通道，1表示围墙)，给出算法，求一条走出迷宫的路径 1、使用栈——深度优先搜索 回溯法 一条路走到黑，不行就回退 思路：从一个节点开始，任意找下一个能走的点，当找不到能走的点时，退回上一个点寻找是否有其他方向的点 使用栈存储当前路径，没有路时出栈 maze = [ [1,1,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,.
python列表实现栈数据结构
weixin_45228198的博客
02-25 289
python 实现栈数据结构 顺序存储的方式实现栈模型 思路: 1、栈 : LIFO 后进先出 2、设计 栈顶: 列表的尾部作为栈顶,负责入栈和出栈操作 栈底: 列表的头部作为栈底,不负责任何操作 class ListStack: def __init__(self): # 初始化一个空栈 self.elems = [] def is_empty(self): """判断栈是否为空,为空返回True,非空返回False"""
数据结构之栈迷宫求解
biqigu的博客
09-03 1900
迷宫求解 了解下书上的思路，不过那个伪代码写的例子怎么也看不懂。难道是因为我看的是盗版    头文件  #pragma once #include #define STACK_INIT_SIZE 100 #define STACK_INCREMENT 50 const int Xrange = 12; const int Yrange = 8;
迷宫问题中的链式堆栈类的实现
travel_lone的专栏
03-14 411
class Node{//堆栈的结点类public: Node();//构造函数0 Node(int x, int y, Node *p);//构造函数重载1 void get_xy(int &x, int &y);//取结点的X,Y值 void put_xy(int x, int y);//置结点的X，Y值 bool put_next(Node *n);//置结点的前驱结点域 bool put_
迷宫求解（数据结构栈应用）
abcdefghijk0987的博客
11-12 278
数据结构课作业。-------- 参考资料：《数据结构（C语言版）》严蔚敏 吴伟民 编著； 1 #include <cstdio> 2 #include <cstdlib> 3 #include <iostream> 4 #include <cstring> 5 using namespace s...
关于迷宫问题 利用栈实现
Aierbude的博客
10-11 534
#include #include #define M 10 #define N 10 #define STACK_INIT_SIZE 100 #define STACK_INC 10 int flag=0; typedef struct{ int x; int y; }Position; typedef struct{ Position pos; int id; int dir;
数据结构之栈的应用----迷宫求解
fengxiaoke_fxk的专栏
06-05 2372
/***********程序设计思想*************/ （1）迷宫地图相关： 利用动态二维数组来初步勾勒出迷宫： 建议先用malloc申请一维数组，再用calloc申请每个元素中的一维数组，因为我用的是1来表示迷宫的通路，0表示死路，calloc申请完后就会自动初始化为0 迷宫交岔路结点： 我们要有一个扫描通路的函数，对一个坐标进行东南西北的扫描，当遇到交岔路的坐标时，需要将所
数据结构之链栈实现
李霁明的博客
06-25 512
文章目录数据结构之链栈实现代码及思想测试截图 数据结构之链栈实现 代码及思想 #include <iostream> #include <cstdio> #include <cstdlib> using namespace std; #define ElemType int #define Status int #define OK 1 #define ERR...
数据结构课件：栈与队列在迷宫路径求解中的应用
"数据结构课件中的栈和队列应用" 在计算机科学中，数据结构是组织、管理和存储数据的方式，以便高效地访问和修改。本课件主要讲解了两个重要的数据结构——栈和队列，它们都是线性表的特殊形式，具有特定的操作限制...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值