数据结构（二）——栈和队列之DFS和BFS遍历迷宫

最新推荐文章于 2023-06-08 17:33:55 发布
最新推荐文章于 2023-06-08 17:33:55 发布
阅读量580 收藏 2
点赞数
分类专栏： 数据结构 应用
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Double___H/article/details/93775433
版权

代码目的：通过栈和队列分别实现迷宫的DFS遍历并输出可到达的全部点和BFS遍历输出走出迷宫的最短路径

在迷宫输入到电脑中，以?表示起点，以0表示可走路径，以#表示墙，既不可以走的路径，以*表示可以到达的路径。
一、利用栈实现迷宫的深度遍历并打印路径
1.首先运用一个for循环找到迷宫的起点，将起点存入栈中。
2.再运用一个while循环，依次寻找栈顶元素的上，右，下，左，是否为可到达路径并且未走过，若满足其中一个方向为可到达路径并且未走过时，就直接将其入栈，进行下一次寻找；若四个方向均不满足以上条件，则将栈顶元素出栈，进行下一次查找。
3.直到栈为空时，将遍历过的地方打印出来。
代码中dir[][]数组表示方向，vis[][]数组用于标记走过的点，maze[][]数组用于存储迷宫。

void DFS(char maze[maxn][maxn], int n, int m, char vis[maxn][maxn]){
/*
  深度优先遍历的过程
  请在本过程中求出从"?"能到达的点数
  并将所有能到达的点用"$"覆盖
*/
    int i,j,f=0,i1,j1;
	stack *st = InitStack();
    for(i=0;i<n;i++)
    {
        for(j=0;j<m;j++)
        {
            vis[i][j]=maze[i][j];//复制迷宫
        }
    }
	for(i=0;i<n;i++)
    {
        for(j=0;j<m;j++)
        {
            if(vis[i][j]=='?')//寻找起点
            {
                Push(st,i,j,f);//存储起点的位置
                st->size--;//不计入节点的步数
            }
        }
    }
    while(EmptyStack(st))//当栈为空时结束
    {
        if(LegalPosition(vis,st->top->x+dir[0][0],st->top->y+dir[0][1],n,m))//判断该点的右边是否能走
       {
           st->top=Push(st,st->top->x+dir[0][0],st->top->y+dir[0][1],1);
           vis[st->top->x][st->top->y]='$';
       }
            else if(LegalPosition(vis,st->top->x+dir[1][0],st->top->y+dir[1][1],n,m))//判断该点的下边是否能走
                    {
                        st->top=Push(st,st->top->x+dir[1][0],st->top->y+dir[1][1],2);
                        vis[st->top->x][st->top->y]='$';
                    }
                    else if(LegalPosition(vis,st->top->x+dir[2][0],st->top->y+dir[2][1],n,m))//判断该点的左边是否能走
                            {
                                st->top=Push(st,st->top->x+dir[2][0],st->top->y+dir[2][1],3);
                                vis[st->top->x][st->top->y]='$';
                            }
                            else if(LegalPosition(vis,st->top->x+dir[3][0],st->top->y+dir[3][1],n,m))//判断该点的上边是否能走
                                    {
                                        st->top=Push(st,st->top->x+dir[3][0],st->top->y+dir[3][1],4);
                                        vis[st->top->x][st->top->y]='$';
                                    }
                                    else
                                        {
                                            st->top=Pop(st);//若都不行，则出栈，并退一步
                                        }
    }
    for(i1=0;i1<n;i1++)
    {
			for(j1=0;j1<m;j1++)
            {
				printf("%c", vis[i1][j1]);//打印走完后的迷宫
            }
				printf("\n");
    }
    printf("能走到的点的个数为： %d\n \n",st->size);
	memset(vis, 0, sizeof(vis));//清除数组
}

二、利用队列实现迷宫的广度遍历并打印最短路径
1.首先运用一个for循环找到迷宫的起点，并将其存入队列。
2.将队列中的队头元素出队，检测其上、右、下、左是否为可到达路径且未走过。若是，则入队，继续检测；若不是，则不入队，继续检测。直到四个方向均扫描过后，对下一个队头元素进行扫描。直到扫描到了出口或者是队列为空。则打印相应的结果。
3.在打印结果的时候，我运用了类似于树的数据结构，对最后的打印结果进行了回溯。在代码中有体现。

void BFS(char maze[maxn][maxn], int n, int m,char vis[maxn][maxn]){
/*
  广度优先遍历的过程
  请在本过程中求出从"?"出发走出迷宫的最短路长度
  并将最短路径用"*"覆盖
*/
    int i,j,ret,i1,j1;
	Queue *que = InitQueue();//初始化队列
	for(i=0;i<n;i++)
    {
        for(j=0;j<m;j++)
        {
            vis[i][j]=maze[i][j];//复制迷宫
        }
    }
    for(i=0;i<n;i++)
    {
        for(j=0;j<m;j++)
        {
            if(vis[i][j]=='?')//寻找起点
            {
                que->back=EnQueue(que,i,j);//起点入队
                que->front=que->back;
            }
        }
    }
    while(isEmpty(que)&&ret!=2)
    {
        for(i1=0;i1<4;i1++)
        {
            ret=LegalPosition1(vis,que->front->x+dir[i1][0],que->front->y+dir[i1][1],n,m);//判断是否为合法得点点
            if(ret==2)//找到出口
            {
                printf("Success!\n");
                break;
            }
            if(ret==1)//点合法
            {
                que->back=EnQueue(que,que->front->x+dir[i1][0],que->front->y+dir[i1][1]);//入队
                vis[que->back->x][que->back->y]='*';//标记走过的点
            }
        }
        if(ret!=2)//还没找到出口
        {
            que->front=DeQueue(que);
        }
    }
    if(ret!=2)//没找到出口
    {
        printf("Impossible!!!\n");
    }
    else//找到了出口
    {
        while(maze[que->front->x][que->front->y]!='?')//进行回溯寻找路径
        {
            maze[que->front->x][que->front->y]='*';
            que->size++;
            que->front=que->front->prev;//回溯到上一个结点的
        }
        for(i1=0;i1<n;i1++)
        {
                for(j1=0;j1<m;j1++)
                {
                    printf("%c", maze[i1][j1]);//打印最短路径
                }
                    printf("\n");
        }
        printf("the shortest load is %d\n",que->size);
    }
	memset(vis, 0, sizeof(vis));
	memset(maze,0,sizeof(maze));
}

三、附上总代码
由于博主的迷宫存在一个文件夹里，故主函数里用了文件流。使用代码的时候需要在主函数里有些修改。

#include <stdio.h>
#include <malloc.h>
#include <string.h>
#include<assert.h>
#define maxn 1002
/*
maze数组用于存储迷宫
vis数组用于在遍历的时候标记已经访问过的点
dir数组用于表示上下左右方向
n和m分别表示迷宫的行数和列数
*/
char maze[maxn][maxn];
int vis[maxn][maxn];
int dir[4][2] = {{0,1},{1,0},{0,-1},{-1,0}};
int n,m;

int LegalPosition(char maze[maxn][maxn],int x, int y,int n,int m){
/* 判断(x,y)位置是否合法*/
    if(x<0||x>n-1||y<0||y>m-1)//是否越界
    {
        return 0;//位置合法
    }
    if(maze[x][y]=='#'||maze[x][y]=='$'||maze[x][y]=='?')//是否为墙或覆盖过的点
    {
        return 0;//位置不合法
    }
    else
    {
        return 1;//位置合法
    }
}

int LegalPosition1(char maze[maxn][maxn],int x, int y,int n,int m){
/* 判断(x,y)位置是否合法*/
    if(x<0||x>n-1||y<0||y>m-1)
    {
        return 2;//找到出口
    }
    if(maze[x][y]=='#'||maze[x][y]=='*'||maze[x][y]=='?')//是否为墙或覆盖过的点
    {
        return 0;//位置不合法
    }
    else
    {
        return 1;//位置合法
    }
}
typedef struct node{
/* 栈中存储的节点 */
	int x; // 行坐标
	int y; // 列坐标
	int flag; // 当前方向
	struct node *next; // 栈中上一个节点的指针
/* 可自由添加需要用的变量 */

}node,*pnode;

typedef struct stack{
/* 栈 */
	node *top; // 栈顶指针
	int size; // 栈中节点个数
	node *buttom;//栈底指针
/* 可自由添加需要用的变量 */

}stack,*pstack;

pstack InitStack(){
/* 初始化栈 */
	pstack st;
    st=(pstack)malloc(sizeof(stack));
    assert(st);//判断申请是否成功
    st->top=st->buttom;
    st->size=0;
    return st;
}
int EmptyStack(pstack st)//判栈空
{
    if(st->top==st->buttom||st==NULL)//判断是否为空
    {
        return 0;
    }
    else
    {
        return 1;//不为空，返回真
    }
}
pnode Push(pstack st,int x1,int y1,int flag1)//入栈
{
    pnode n=(pnode)malloc(sizeof(node));//申请新结点
    n->x=x1;
    n->y=y1;
    n->flag=flag1;//flag 1.2.3.4 分别代表上下左右
    n->next=st->top;
    st->top=n;
    st->size++;
    return st->top;//返回入栈后的头结点
}
pnode Pop(pstack st)//出栈
{
    pnode n;
    if(st->top==st->buttom)//判断是否为空
    {
        printf("The stack is NULL\n");
        return;
    }
    else
    {
        n=st->top;
        st->top=st->top->next;
        free(n);
        n=NULL;
        return st->top;
    }
}

void DFS(char maze[maxn][maxn], int n, int m, char vis[maxn][maxn]){
/*
  深度优先遍历的过程
  请在本过程中求出从"?"能到达的点数
  并将所有能到达的点用"$"覆盖
*/
    int i,j,f=0,i1,j1;
	stack *st = InitStack();
    for(i=0;i<n;i++)
    {
        for(j=0;j<m;j++)
        {
            vis[i][j]=maze[i][j];//复制迷宫
        }
    }
	for(i=0;i<n;i++)
    {
        for(j=0;j<m;j++)
        {
            if(vis[i][j]=='?')//寻找起点
            {
                Push(st,i,j,f);//存储起点的位置
                st->size--;//不计入节点的步数
            }
        }
    }
    while(EmptyStack(st))//当栈为空时结束
    {
        if(LegalPosition(vis,st->top->x+dir[0][0],st->top->y+dir[0][1],n,m))//判断该点的右边是否能走
       {
           st->top=Push(st,st->top->x+dir[0][0],st->top->y+dir[0][1],1);
           vis[st->top->x][st->top->y]='$';
       }
            else if(LegalPosition(vis,st->top->x+dir[1][0],st->top->y+dir[1][1],n,m))//判断该点的下边是否能走
                    {
                        st->top=Push(st,st->top->x+dir[1][0],st->top->y+dir[1][1],2);
                        vis[st->top->x][st->top->y]='$';
                    }
                    else if(LegalPosition(vis,st->top->x+dir[2][0],st->top->y+dir[2][1],n,m))//判断该点的左边是否能走
                            {
                                st->top=Push(st,st->top->x+dir[2][0],st->top->y+dir[2][1],3);
                                vis[st->top->x][st->top->y]='$';
                            }
                            else if(LegalPosition(vis,st->top->x+dir[3][0],st->top->y+dir[3][1],n,m))//判断该点的上边是否能走
                                    {
                                        st->top=Push(st,st->top->x+dir[3][0],st->top->y+dir[3][1],4);
                                        vis[st->top->x][st->top->y]='$';
                                    }
                                    else
                                        {
                                            st->top=Pop(st);//若都不行，则出栈，并退一步
                                        }
    }
    for(i1=0;i1<n;i1++)
    {
			for(j1=0;j1<m;j1++)
            {
				printf("%c", vis[i1][j1]);//打印走完后的迷宫
            }
				printf("\n");
    }
    printf("能走到的点的个数为： %d\n \n",st->size);
	memset(vis, 0, sizeof(vis));//清除数组
}


typedef struct qnode{
/* 队列中存储的节点 */
	int x; // 行坐标
	int y; // 列坐标
	struct qnode *next; //队列中下一个节点的指针
	struct qnode *prev; //先驱结点
/* 可自由添加需要用的变量 */

}QueueNode,*pQueueNode;

typedef struct queue{
/* 队列 */
	QueueNode *front; //队首指针
	QueueNode *back; //队尾指针
	int size; // 队列中节点个数
/* 可自由添加需要用的变量 */

}Queue,*pQueue;

Queue *InitQueue(){
/* 初始化队列 */
	Queue* que = (Queue *)malloc(sizeof(Queue));//申请空间
	assert(que);//判断是否申请成功
	que->back=NULL;
	que->front=que->back;
	que->size = 0;
	return que;
}
int isEmpty(Queue *que){
/* 判断队列是否为空 */
    if(que->back==NULL)
    {
        return 0;//为空
    }
    else
    {
        return 1;//不为空
    }
}
pQueueNode EnQueue(pQueue que,int x1,int y1)
{
/* 入队 */
    pQueueNode n=(pQueueNode)malloc(sizeof(QueueNode));//申请空间
    n->x=x1;
    n->y=y1;
    if(que->back==NULL)//队列为空的情况下进行入队
    {
        que->back=n;
        que->front=n;
        n->prev=NULL;
        return que->back;
    }
    else//队列不为空的情况下进行入队
    {
        que->back->next=n;
        n->prev=que->front;
        que->back=n;
        return que->back;
    }

}
pQueueNode DeQueue(Queue *que){
/* 出队 */
    if(que->back==que->front)//队列只剩一个结点的情况下
    {
        que->back=NULL;
        que->front=que->back;
        return que->front;
    }
    else//队列还有大于等于二个的结点
    {
        que->front=que->front->next;
        return que->front;
    }
}


void BFS(char maze[maxn][maxn], int n, int m,char vis[maxn][maxn]){
/*
  广度优先遍历的过程
  请在本过程中求出从"?"出发走出迷宫的最短路长度
  并将最短路径用"*"覆盖
*/
    int i,j,ret,i1,j1;
	Queue *que = InitQueue();//初始化队列
	for(i=0;i<n;i++)
    {
        for(j=0;j<m;j++)
        {
            vis[i][j]=maze[i][j];//复制迷宫
        }
    }
    for(i=0;i<n;i++)
    {
        for(j=0;j<m;j++)
        {
            if(vis[i][j]=='?')//寻找起点
            {
                que->back=EnQueue(que,i,j);//起点入队
                que->front=que->back;
            }
        }
    }
    while(isEmpty(que)&&ret!=2)
    {
        for(i1=0;i1<4;i1++)
        {
            ret=LegalPosition1(vis,que->front->x+dir[i1][0],que->front->y+dir[i1][1],n,m);//判断是否为合法得点点
            if(ret==2)//找到出口
            {
                printf("Success!\n");
                break;
            }
            if(ret==1)//点合法
            {
                que->back=EnQueue(que,que->front->x+dir[i1][0],que->front->y+dir[i1][1]);//入队
                vis[que->back->x][que->back->y]='*';//标记走过的点
            }
        }
        if(ret!=2)//还没找到出口
        {
            que->front=DeQueue(que);
        }
    }
    if(ret!=2)//没找到出口
    {
        printf("Impossible!!!\n");
    }
    else//找到了出口
    {
        while(maze[que->front->x][que->front->y]!='?')//进行回溯寻找路径
        {
            maze[que->front->x][que->front->y]='*';
            que->size++;
            que->front=que->front->prev;//回溯到上一个结点的
        }
        for(i1=0;i1<n;i1++)
        {
                for(j1=0;j1<m;j1++)
                {
                    printf("%c", maze[i1][j1]);//打印最短路径
                }
                    printf("\n");
        }
        printf("the shortest load is %d\n",que->size);
    }
	memset(vis, 0, sizeof(vis));
	memset(maze,0,sizeof(maze));
}


int main()
{
/* 从文件maze.in中读入 */
    freopen("maze.in","r",stdin);
	int o=0,i,j;
	printf("Please input data:\n");
	while (scanf("%d %d",&n,&m)!=EOF){
	// 可能有多组输入数据
		o += 1;
		for (i=0;i<n;i++)
			for (j=0;j<m;j++)
				scanf(" %c", &maze[i][j]);
		printf("--------Case #%d--------\n", o);
		DFS(maze, n, m,vis);
		BFS(maze, n, m,vis);
	}
	 fclose(stdin);
	return 0;
}
Double___H
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
搜索与图论（一）——DFS、BFS、树与图的遍历
qq_44005993的博客
02-26 534
算法基础课-3.1,3.2 第三章 搜索与图论（一）+ Week4——习题课 共7题，知识点如下 DFS：排列数字、n-皇后问题。 BFS：走迷宫、八数码。 树与图的深度优先遍历：树的重心 树与图的广度优先遍历：图中点的层次 拓扑排序：有向图的拓扑序列
树和图的DFS和BFS遍历
点典的博客
04-02 353
树和图的DFS和BFS遍历，本质是dfs和bfs搜索在图论中的应用，逻辑都是一样的，不一样或者说需要注意的是：在数和图中往往每个节点只会被访问一次。此外，实现方式也略有不同。时间复杂度都是O(n+m)。 DFS模板 int dfs(int u) { st[u] = true; // st[u] 表示点u已经被遍历过 for (int i = h[u]; i != -1; i = ...
图的遍历（DFS和BFS）
m0_74124886的博客
06-08 1059
NextAdjVex(G,v,w)除了第一个不为0的下一个不为0的如果是邻接表（由表头数组构成的多个单链表，FirstAdjVex(G,v)其中v就是表头，在表头数组中寻找到v，这样就找到了这个单链表， 单链表中的边结点都是该顶点的邻接点，表头的firstarc指针域就是该顶点的第一个邻接点，每个边结点的nextarc是下一个邻接点。和树的通历类似，图的遍历也是从图中某一顶点出发，按照某种方选对图中所有演道进行图的遍历算法是求解图的连通性问题、拓扑排序和关键路径等算法的基础——它们对无向图和有向图都适用。
C++数据结构之图的遍历——DFS和BFS（带有gif演示）
m0_56398315的博客
08-19 6147
本文介绍了继图的存储结构之后对图进行遍历，分为DFS和BFS两种算法，赋有动态gif图示和相关代码以及注释
数据结构(17)--图的遍历DFS和BFS
小白的专栏
03-04 9651
参考书籍：数据结构（C语言版）严蔚敏吴伟民编著清华大学出版社 本文中的代码可从这里下载：https://github.com/qingyujean/data-structure 从图中某一顶点出发访遍图中其余顶点，且使每一个顶点仅被访问一次。这一过程就叫做图的遍历。 示例: 1.深度优先遍历 基本思想： 从图中某顶点V0出发，访问此顶点，然后依次从V0的各个未被访问的...
数据结构实验报告（包括线性表、栈和队列、串、二叉树、图、查找与排序算法的设计与实现）
最新发布
06-09
- **图的 DFS 和 BFS 遍历算法设计**：`Project8.2`部分介绍了图的深度优先搜索（DFS）和广度优先搜索（BFS）的遍历算法设计方法。 - **普里姆算法求最小生成树**：`Project8.3`部分详细分析了普里姆算法的工作原理...
栈和队列迷宫
06-11
栈和队列是两种最基本且重要的数据结构，本项目以"栈和队列迷宫"为主题，结合C++语言，提供了一个实际的应用场景来深入理解这两种数据结构。 栈（Stack）是一种后进先出（LIFO）的数据结构，它的操作类似于日常生活...
数据结构——迷宫.zip
02-01
这个主题涉及到了数据结构的运用，特别是栈和队列，以及如何利用这些数据结构来解决实际问题，如模拟老鼠在迷宫中寻找路径。在这个实验中，我们通过编程实现迷宫的解密，目标是帮助老鼠找到从入口到放置奶酪出口的...
趣学数据结构和算法课件
02-09
图的遍历算法有深度优先搜索（DFS）和广度优先搜索（BFS）。 8. **排序算法**：包括冒泡排序、选择排序、插入排序、快速排序、归并排序、堆排序等。了解各种排序算法的时间和空间复杂度，有助于在不同场景下选择...
数据结构-DFS and BFS-PPT
02-04
在数据结构中，DFS和BFS都是常用的搜索算法，它们可以用于解决各种问题，例如迷宫问题、全排列问题等。下面是一个使用DFS解决全排列问题的示例： 问题描述：输入一个数n，输出1~n的全排列。 解决方法：使用DFS搜索...
图的遍历——BFS、DFS
baboon_chen
04-05 2706
文章目录一、深度优先搜索（Depth First Search，DFS）示例代码算法复杂度二、广度优先搜索（Breadth First Search，BFS）示例代码算法复杂度 一、深度优先搜索（Depth First Search，DFS） 该算法与二叉树的先序遍历类似，在第一次经过一个顶点时就进行访问操作，并记录该顶点已经被访问。具体步骤如下： 设置指针p，指向顶点v。 访问p所指的顶点，并使p指向与其相邻接的且未被访问过的顶点。 如果p所指的顶点存在，则重复步骤(2)，否则执行步骤(4)。 沿着刚
【数据结构基础】图 - 遍历(BFS & DFS)
DeveloperFire的博客
02-06 1970
它的思想: 假设初始状态是图中所有顶点均未被访问，则从某个顶点v出发，首先访问该顶点，然后依次从它的各个未被访问的邻接点出发深度优先搜索遍历图，直至图中所有和v有路径相通的顶点都被访问到。若此时尚有其他顶点未被访问到，则另选一个未被访问的顶点作起始点，重复上述过程，直至图中所有顶点都被访问到为止。显然，深度优先搜索是一个递归的过程。广度优先搜索算法(Breadth First Search)，又称为"宽度优先搜索"或"横向优先搜索"，简称BFS。
数据结构与算法基础-学习-24-图的遍历之DFS（深度优先搜索）和BFS（广度优先搜索）
qq_45111959的博客
05-30 4075
本文介绍数据结构与算法基础-遍历之DFS（深度优先搜索）和BFS（广度优先搜索）的算法实现思路、代码实现、算法效率分析、Linux编译测试结果。
无向图的DFS/BFS遍历
代码行
04-30 1706
#include&lt;bits/stdc++.h&gt; using namespace std; int vis[25],flag=1; queue&lt;int&gt;s; typedef struct node //边结点 { int a; //该边所指向的顶点的位置 struct node *next; //指向下一条边的...
Leetcode数据结构&算法：队列和广度优先搜索（BFS）
yfy1127yfy的博客
11-07 334
一、介绍 在 FIFO 数据结构中，将首先处理添加到队列中的第一个元素。如上图所示，队列是典型的 FIFO 数据结构。 插入（insert）操作也称作入队（enqueue），新元素始终被添加在队列的末尾。 删除（delete）操作也被称为出队（dequeue)。 你只能移除第一个元素。 入队是队尾指针给最后一个赋值，出队只是移动了队首的指针而已。 内存资源有限，使用循环队列。 二、队...
白话解释 DFS 与 BFS 算法 （二叉树的先序遍历，中序遍历、后序遍历、层次遍历）
热门推荐
欢迎来到Gorit的博客
11-28 1万+
DFS 与 BFS一、BFS1.1 什么是 BFS二、DFS2.1 什么是 DFS 一、BFS 1.1 什么是 BFS BFS（Breadth First Search） 即广度优先搜索，在数和图中非常常见 二、DFS 2.1 什么是 DFS DFS 即深度优先搜索，同 BFS，在树和图中也是非常常见的 ...
BFS走迷宫
Andy的博客
04-28 6774
题目描述 一个网格迷宫由n行m列的单元格组成，每个单元格要么是空地（用1表示）要么是障碍物 （用0表示）。任务是找一条从起点到终点的最短移动序列，其中UDLR代表上下左右移动到 相邻单元格。任何时候都不能在障碍物格中，也不能走到迷宫之外。起点和终点保证是空地 n，m<=100； 思路 从迷宫的入口开始，进行层次优先遍历（BFS，我更喜欢称之为层次优先遍历，因为这样更形象）。BFS遍历的关键就...
栈遍历式迷宫
人族科技碾压流
08-11 771
#include #define STACK_SIZE 100 #define STACK_SIZE_INC 10 enum result {     OK,     ERR,     FAIL, }; struct coordinate {     int x;     int y; }; typedef struct {     st
(java)BFS广度优先遍历解决迷宫问题
最白の白菜的博客
02-09 953
借鉴博客https://blog.csdn.net/QIANGWEIYUAN/article/details/90375392 从数据结构出发,在java基础上理解BFS 更容易解决迷宫问题 请输入迷宫的行列数:5 5 请输入迷宫路径 0 0 1 1 1 1 0 0 0 0 1 0 0 0 0 1 1 0 1 1 1 1 0 0 0 迷宫路径搜索结果如下： * * 1 1 1 1 * 0 0 ...
栈和队列的数据结构应用：探索迷宫的路径
"该资源是关于数据结构课程的课件，重点讲解了栈和队列的概念及应用。在迷宫问题的求解中，栈被用于探索路径，当栈不空且栈顶位置还有未探索的方向时，会沿顺时针方向移动到下一个相邻块。如果栈顶四周均无通路，则...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值