DFS遍历迷宫输出所有路径（借助数据结构栈）

最新推荐文章于 2023-08-07 23:31:24 发布
最新推荐文章于 2023-08-07 23:31:24 发布
阅读量5.2k 收藏 65
点赞数 14
分类专栏： 数据结构 C&C++ 文章标签： 数据结构 DFS c\c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43606858/article/details/102633692
版权

写在前面

可解决问题：输入n,m，可随机生成n*m大小的迷宫(伪随机数),也可手动输入迷宫,找到迷宫中的所有可行路径（八个方向：上下左右以及对角），输出路径以及路径长度。

实现效果（更新）

......太多了

基本代码

（觉得麻烦可以直接跳到最后）

C语言实现栈，并打成头文件方便使用：

#ifndef stack_h
#define stack_h
#include <stdio.h>
#include <stdlib.h>

//栈中存位置以及遍历时所走的方向，打印时可以显示出来
typedef struct Node{
    int x;
    int y;
  //  int dir;           //-1为左上右下对应 '\' 0为上下对应'|'  1为左右对应'——' 2为左下右上对应'/'   
    struct node* next;
}Node;

typedef Node* Stack;     //定义数据结构栈 Stack

//-----------创建一个空栈--------------
Stack creakEmptyStack(){
       Stack p;
       p=(Stack)malloc(sizeof(Node));    //申请一个空间
       if(p){
           p->next=NULL;
           return p;
       }
       else{
           printf("No space!\n");    //申请空间失败则提示并返回空
           return NULL;
       }
}

//------------将元素压入栈----------------
void push(int x,int y,Stack s){
    Stack p;
    p=(Stack)malloc(sizeof(Node));
    if(p){                   //如果申请空间成功则用头插法将元素压入
        p->x=x;
        p->y=y;
        if(!s->next) p->next=NULL;  //如果此时栈里还没有任何元素，则p此时为第一个结点
        else p->next=s->next;  //否则将p插入头结点之后
        s->next=p;
    }
    else{
        printf("No space!\n");
    }
}

//-------------检测栈是否为空--------------
int isEmpty(Stack s){           //为空则返回1，不为空返回0
    if(s->next==NULL) return 1;
    else return 0;
}
//--------------将元素弹出栈----------------
void pop(Stack s){
    Stack p;
    p=s->next;
    if(p->next){
        s->next=p->next;
        free(p);
    }
    else return;
}
//------------取栈顶元素------------------
Node top(Stack s){
    Node t;
    //判断是否为空，若不为空则返回
    t=*(s->next);
    return t;
}


#endif

 C语言实现迷宫的遍历并输出所有的路径：

当然这里用c++的STL库的stack也可，但是下面的代码需要做一些小小的修改。

/* filename:  数据结构实验_迷宫.c
 * brife:	  Sovle the maze problem by using dfs&bfs
 * author:	  HP1020--SNOOHAIRY
 * date:	  2019.10.18 -- Firday
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "stack_h"
#define MAXN 20

void mazePath(int x,int y,int endx,int endy,int n,int m,Stack s);
void printPath(Stack s,int n,int m);

/*  *建立一个二维数组存迷宫
    *要是八个方向能有位置则压入栈，要是下一步没有则弹出栈回溯
    *直到找到终点为止
*/
int direction[8][2]={{-1,-1},{-1,0},{-1,1},{0,-1},{0,1},{1,-1},{1,0},{1,1}};  //定义一个数组存八个方向操作数
int maze[MAXN][MAXN];
int flag=0;

int main()
{
    int n,m,i,j,xa,xb,ya,yb,ox;
    //--------------建立迷宫--------------
    printf("请输入迷宫大小：（长、宽）\n");
    scanf("%d%d",&n,&m);
    if(n<=20&&m<=20){
        printf("请选择构建迷宫的方式：\n0.随机生成迷宫\n1.手动输入迷宫\n"); //实际上不是0就可以手动输入
        scanf("%d",&ox);
        for(i=0;i<n;i++){
            for(j=0;j<m;j++){
                if(!ox)maze[i][j]=rand()%2;    //这里为伪随机数
                else scanf("%d",&maze[i][j]);
            }
        }
         printf("\n");
        //----------输出构建迷宫-------------
        printf("生成的迷宫如下：\n");
        for(i=0;i<n;i++){
            for(j=0;j<m;j++){
                printf("%d  ",maze[i][j]);
            }
            printf("\n");
        }

        printf("请输入起点及终点：\n");
        scanf("%d%d%d%d",&xa,&ya,&xb,&yb);
        
        //标记起点
        maze[xa-1][ya-1]=2;                        

        //创建一个空栈
        Stack s=creakEmptyStack();
        //创建一个空队列
        //QueueLink q=creakEmptyQueue();                
        mazePath(xa-1,ya-1,xb-1,yb-1,n,m,s);
        if(!flag) printf("没有成功找到路径\n");
    }
    else printf("输入数据超出迷宫范围\n");
}

//-----------遍历迷宫寻找路径(dfs)------------
void mazePath(int x,int y,int endx,int endy,int n,int m,Stack s){
    int newx,newy,i;
    Node t;
    for(i=0;i<8;i++){
        newx=x+direction[i][0];
        newy=y+direction[i][1];
        if(newx>=0&&newx<n&&newy>=0&&newy<m&&maze[newx][newy]==0){    //走到出口
            push(newx,newy,s);
            maze[newx][newy]=2;
            if(newx==endx&&newy==endy){
                flag++;
                printPath(s,n,m);
                maze[newx][newy]=0;
                pop(s);
            }
            else{
                mazePath(newx,newy,endx,endy,n,m,s);
            }
        }
//        else if(!isEmpty(s)) pop(s);
    }
    maze[x][y]=0;   //遍历完八个方向之后回溯前将自己赋为空
    pop(s);
}

//-------------打印迷宫路径-----------------
void printPath(Stack s,int n,int m){
    int cont =0;    //计算路径长度
    s=s->next;
    int i=0,j=0;
    printf("第%d条路径为：\n",flag);
    for(i=0;i<n;i++){                         //按图形输出
        for(j=0;j<m;j++){
            if(maze[i][j]==2) printf("*  ");
            else printf("%d  ",maze[i][j]);
        }
        printf("\n");
    }
    while(s->next){                          //将栈中的元素输出为直观路径
        printf("(%d,%d)->",s->x+1,s->y+1);
        s=s->next;
        cont++;
    }
    printf("(%d,%d)",s->x+1,s->y+1);
    cont++;
    printf("\n");
    printf("路径长度为：%d\n\n",cont);
}

[不用问为啥复制粘贴执行不了，问就是没加文章开头的头文件]

写在最后（更新）

为了方便大家，我这打出来一个直接复制粘贴就可以运行的代码👨‍🦳

/* filename:  数据结构实验_迷宫.c
 * brife:	  Sovle the maze problem by using dfs&bfs
 * author:	  HP1020--SNOOHAIRY
 * date:	  2019.10.18 -- Firday
 */
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAXN 20

/*  *建立一个二维数组存迷宫
    *要是八个方向能有位置则压入栈，要是下一步没有则弹出栈回溯
    *直到找到终点为止
*/
int direction[8][2]={{-1,-1},{-1,0},{-1,1},{0,-1},{0,1},{1,-1},{1,0},{1,1}};  //定义一个数组存八个方向操作数
int maze[MAXN][MAXN];
int flag=0;

//栈中存位置以及遍历时所走的方向，打印时可以显示出来
typedef struct Node{
    int x;
    int y;
    //  int dir;           //-1为左上右下对应 '\' 0为上下对应'|'  1为左右对应'——' 2为左下右上对应'/'
    struct Node *next;
}Node;

typedef Node* Stack;     //定义数据结构栈 Stack

//-----------创建一个空栈--------------
Stack creakEmptyStack(){
    Stack p;
    p=(Stack)malloc(sizeof(Node));    //申请一个空间
    if(p){
        p->next=NULL;
        return p;
    }
    else{
        printf("No space!\n");    //申请空间失败则提示并返回空
        return NULL;
    }
}

//------------将元素压入栈----------------
void push(int x,int y,Stack s){
    Stack p;
    p=(Stack)malloc(sizeof(Node));
    if(p){                   //如果申请空间成功则用头插法将元素压入
        p->x=x;
        p->y=y;
        if(!s->next) p->next=NULL;  //如果此时栈里还没有任何元素，则p此时为第一个结点
        else p->next=s->next;  //否则将p插入头结点之后
        s->next=p;
    }
    else{
        printf("No space!\n");
    }
}

//-------------检测栈是否为空--------------
int isEmpty(Stack s){           //为空则返回1，不为空返回0
    if(s->next==NULL) return 1;
    else return 0;
}
//--------------将元素弹出栈----------------
void pop(Stack s){
    Stack p;
    p=s->next;
    if(p->next){
        s->next=p->next;
        free(p);
    }
    else return;
}
//------------取栈顶元素------------------
Node top(Stack s){
    Node t;
    //判断是否为空，若不为空则返回
    t=*(s->next);
    return t;
}

void mazePath(int x,int y,int endx,int endy,int n,int m,Stack s);
void printPath(Stack s,int n,int m);
 
int main()
{
    int n,m,i,j,xa,xb,ya,yb,ox;
    //--------------建立迷宫--------------
    printf("请输入迷宫大小：（长、宽）\n");
    scanf("%d%d",&n,&m);
    if(n<=20&&m<=20){
        printf("请选择构建迷宫的方式：\n0.随机生成迷宫\n1.手动输入迷宫\n"); //实际上不是0就可以手动输入
        scanf("%d",&ox);
        for(i=0;i<n;i++){
            for(j=0;j<m;j++){
                if(!ox)maze[i][j]=rand()%2;    //这里为伪随机数
                else scanf("%d",&maze[i][j]);
            }
        }
         printf("\n");
        //----------输出构建迷宫-------------
        printf("生成的迷宫如下：\n");
        for(i=0;i<n;i++){
            for(j=0;j<m;j++){
                printf("%d  ",maze[i][j]);
            }
            printf("\n");
        }
 
        printf("请输入起点及终点：\n");
        scanf("%d%d%d%d",&xa,&ya,&xb,&yb);
        
        //标记起点
        maze[xa-1][ya-1]=2;                        
 
        //创建一个空栈
        Stack s=creakEmptyStack();
        //创建一个空队列
        //QueueLink q=creakEmptyQueue();
        mazePath(xa-1,ya-1,xb-1,yb-1,n,m,s);
        if(!flag) printf("没有成功找到路径\n");
    }
    else printf("输入数据超出迷宫范围\n");
}
 
//-----------遍历迷宫寻找路径(dfs)------------
void mazePath(int x,int y,int endx,int endy,int n,int m,Stack s){
    int newx,newy,i;
    Node t;
    for(i=0;i<8;i++){
        newx=x+direction[i][0];
        newy=y+direction[i][1];
        if(newx>=0&&newx<n&&newy>=0&&newy<m&&maze[newx][newy]==0){    //走到出口
            push(newx,newy,s);
            maze[newx][newy]=2;
            if(newx==endx&&newy==endy){
                flag++;
                printPath(s,n,m);
                maze[newx][newy]=0;
                pop(s);
            }
            else{
                mazePath(newx,newy,endx,endy,n,m,s);
            }
        }
//        else if(!isEmpty(s)) pop(s);
    }
    maze[x][y]=0;   //遍历完八个方向之后回溯前将自己赋为空
    pop(s);
}
 
//-------------打印迷宫路径-----------------
void printPath(Stack s,int n,int m){
    int cont =0;    //计算路径长度
    s=s->next;
    int i=0,j=0;
    printf("第%d条路径为：\n",flag);
    for(i=0;i<n;i++){                         //按图形输出
        for(j=0;j<m;j++){
            if(maze[i][j]==2) printf("*  ");
            else printf("%d  ",maze[i][j]);
        }
        printf("\n");
    }
    while(s->next){                          //将栈中的元素输出为直观路径
        printf("(%d,%d)->",s->x+1,s->y+1);
        s=s->next;
        cont++;
    }
    printf("(%d,%d)",s->x+1,s->y+1);
    cont++;
    printf("\n");
    printf("路径长度为：%d\n\n",cont);
}

📢  转载请注明出处🎈 码字不易，能跑出想要的效果的话点个赞叭

Cotton White Dog
关注
  • 14
    点赞
  • 踩
  • 65
    收藏
    觉得还不错? 一键收藏
  • 8
    评论
专栏目录
BFS 遍历迷宫 JAVA 输出所有路径
weixin_42649617的博客
11-03 1341
import java.util.ArrayList; import java.util.LinkedList; import java.util.List; import java.util.Queue; import java.util.Stack; public class MiGong { public static void main(String[] args) { int[][] A={ {0,0,1,0}, {1,0,1,0},.
DFS搜索和输出所有路径
罗勇军的博客
11-20 8685
DFS搜索和输出所有路径
DFS/BFS搜索迷宫路径
长期更新Java自学笔记
05-11 1415
文章目录一、DFS搜索迷宫路径二、BFS搜索迷宫路径 一、DFS搜索迷宫路径 DFS依赖栈结构 先把左上角节点入栈，然后依次查看栈顶元素的右、下、左、上四个方向是否可以走，如果能走就把节点入栈，然后再依次查看依次查看栈顶元素的右、下、左、上四个方向；如果四个方向都不能走，就把栈顶元素出栈 最终栈空，则说明退回到了左上角的节点；右下角的节点入栈，则表示找到了出口 需要注意的是，每入栈一个节点： 需要将当前节点到入栈节点的方向置为NO，保证如果走进死胡同回退后，不会再次往这个错误的方向走 需要将刚入栈节
迷宫路径的求解（非递归方法和递归方法）
Feynman1999的博客
06-21 2932
迷宫路径的求解（非递归方法和递归方法） （对于非递归 求解一条通路即可，这里借助了pre[ ][ ]数组记录前驱） （非递归的辅助栈为链栈） 代码示例 #include using namespace std; const int maxn=1000; const int dx[5]={0,0,1,0,-1}; const int dy[5]={0,1,0,-1,0};
DFS求解迷宫问题(输出所有的路径)
热门推荐
tensory的博客
03-27 2万+
问题：给出一个n*n的迷宫，起点为(0,0)，终点为(n-1,n-1).可以向上、下、左、右四个方向走. 任务：1.判断是否有可行路径            2.如果有可行路径，输出所有的可行路径. ———————————————————————————————————————————————————— 如下图所示，当前位置为中间点，如果中间点不是终点，那么会从4个方向进行下一步探测，进入
迷宫的所有路径（回溯DFS）
m0_72121170的博客
08-07 718
【代码】迷宫的所有路径（回溯DFS）
迷宫-深度优先搜索-打印所有可行路径
qq_34645863的博客
11-27 2533
继上一篇“迷宫-广度优先搜索-最短路径并打印该条最短路径”——https://mp.csdn.net/postedit/103229718，想着如何才能把所有可行路径打印出来，网上看了些资料都是推荐使用深度优先搜索方法，但是没看到过完全的实现，因此有了这次自己记录。 目录 1.本文例子的迷宫如下： 2.深度优先的基本思路- 3.只考虑一条路径的实现 （1） 栈代码 （2）深度遍历代...
迷宫问题数据结构.docx
最新发布
10-30
在计算机科学中，迷宫问题是一个经典的问题，它涉及到路径搜索和图遍历。迷宫问题数据结构的设计和实现是解决此类问题的关键。本篇文章将深入探讨如何使用数据结构，特别是二维数组，来表示和解决迷宫问题。 首先，...
数据结构 图的遍历.pdf
09-13
数据结构中的图遍历是图论中的核心概念，主要用于遍历或访问图中所有节点，确保每个节点只被访问一次。...在实现过程中，通常需要借助辅助数据结构如栈（DFS）或队列（BFS）来辅助节点的访问和状态管理。
C#迷宫数据结构
10-05
而“C#迷宫数据结构”这个项目，显然是一个利用C#编程语言来实现的关于迷宫问题的数据结构与算法应用实例。在这个项目中，开发者可能会涉及到深度优先搜索(DFS)、广度优先搜索(BFS)等经典算法，以及矩阵或图数据结构...
迷宫问题_迷宫问题_栈_
09-30
迷宫问题的核心是路径搜索，我们可以采用深度优先搜索（DFS，Depth-First Search）策略来解决，而DFS算法正好可以借助栈来实现。迷宫通常被表示为一个二维矩阵，其中0代表可通行的路径，1代表障碍物。我们的目标是从...
数据结构迷宫问题
08-11
在IT领域，数据结构与算法是基础且至关重要的部分，它们是解决问题的关键工具。迷宫问题就是一个典型的应用场景，涉及到图的遍历方法——广度优先搜索（BFS）和深度优先搜索（DFS）。让我们深入探讨这两种算法以及...
广度优先遍历解决迷宫问题
qq_57484399的博客
10-19 2495
我们之前使用深度优先遍历的方法是 , 只派一个人去探索迷宫,记录其路线 和每个节点走过的方向 , 一条道走到黑 , 当路不通时候,回溯到上一个节点 的下一个方向 , 直到这个节点全部方向都遍历完,我们就放弃路线上的这个节点 ,接着回溯到这个节点的上一个节点的另一个方向 , 我们一定可以成功 ,因为我们就算不成功,早晚也可以回溯到起点 ,从起点的下一个方向出发 ,当把所有节点所有方向都遍历完,如果有解, 我们则可以找到出口 , 无解则输出无解 .
解决迷宫路径问题（深度优先）JAVA
Narnat的博客
12-03 717
解决迷宫路径问题（深度优先）JAVA
迷宫的路径输出(dfs)
m0_68565376的博客
09-30 744
递归，堆栈记录路径，dfs非最短路径
c语言 迷宫深度遍历 算法,图的遍历迷宫生成算法浅析
weixin_42351910的博客
05-23 776
1.引言　　在平常的游戏中，我们常常会碰到随机生成的地图。这里我们就来看看一个简单的随机迷宫是如何生成。2. 迷宫描述随机生成一个m *n的迷宫，可用一个矩阵maze[m][n]来表示，如图：图1.1图1.2这里是两个迷宫的例子，其中“■”表示障碍物(Obstacleblock)。以图1.1迷宫为例，我们可用一个9 * 9的矩阵来表示：111111111000000...
C++利用DFS算法求迷宫通关最短步骤以及路径
weixin_50994004的博客
08-10 516
在算出最短的路径的基础上，利用DFS回溯的特性增/删路径，以此来实现对于路径的记录。 PS：最初想通过定义string类型数据来记录路径，但是在回溯删除多余路径时会出现问题（运用函数删除string类型最末尾数据的时候，如果最末尾数据为汉字时会由于数据类型的缘故删除失败出现乱码……求大神的解决方案） #include<iostream> #include<cstring> #include<string> using namespace std; int a[100
dfs求迷宫的最短路径（有障碍物）
WXLGL的博客
11-12 789
dfs求迷宫的最短路径（有障碍物）
走迷宫问题（深度优先遍历 + 广度优先遍历）
u011954296的博客
04-29 1万+
迷宫是许多小方格构成的矩形，在每个小方格中有的是墙（用1表示），有的是路（用0表示）。走迷宫就是从一个小方格沿上、下、左、右四个方向到邻近的方格，当然不能穿墙。设迷宫的入口是在左上角（1,1），出口是在右下角（8,8）。根据给定的迷宫，找出一条从入口到出口的路径。解法一（深度优先遍历，打印所有可行的路径）：#include <iostream> using namespace std;int maz
dfs迷宫输出所有路径
05-27
好的，针对你的问题，我可以提供一个简单的深度优先搜索（DFS）算法来解决迷宫问题，并输出所有可行的路径。以下是基本的 Python 代码实现： ```python # 定义一个函数，输入迷宫矩阵maze，起点位置start，终点位置...
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值