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

最新推荐文章于 2024-07-05 12:14:40 发布
最新推荐文章于 2024-07-05 12:14:40 发布
阅读量5.3k 收藏 66
点赞数 15
分类专栏： 数据结构 C&C++ 文章标签： 数据结构 DFS c\c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43606858/article/details/102633692
版权
本文介绍如何使用DFS算法解决迷宫问题，给出C语言实现的详细代码，包括栈的数据结构和迷宫的遍历。通过该方法可以生成随机迷宫并找出所有可行路径及其长度。
摘要由CSDN通过智能技术生成

写在前面

可解决问题：输入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
关注
专栏目录
DFS求解迷宫问题(输出所有的路径)
tensory的博客
03-27 2万+
问题：给出一个n*n的迷宫，起点为(0,0)，终点为(n-1,n-1).可以向上、下、左、右四个方向走. 任务：1.判断是否有可行路径            2.如果有可行路径，输出所有的可行路径. ———————————————————————————————————————————————————— 如下图所示，当前位置为中间点，如果中间点不是终点，那么会从4个方向进行下一步探测，进入
数据结构之用栈实现迷宫问题（dfs）
蒟蒻小胖
09-28 1730
给一个n*n的方格，让你求从左上角到所给一点的任意一条路径并输出 该题用到dfs，以下是对dfs的简要解析  ：详解请参见 传送门 dfs是一种用于遍历或搜索树或图的算法。 沿着树的深度遍历树的节点，尽可能深的搜索树的分支。当节点v的所在边都己被探寻过或者在搜寻时结点不满足条件，搜索将回溯到发现节点v的那条边的起始节点。整个进程反复进行直到所有节点都被访问为止。属于盲目搜索,最糟糕的情况算法时...
走迷宫的递归与非递归写法
锦恢的博客
10-30 942
递归解法 走迷宫的递归走法很好理解：假设我们已经写好了搜路径的函数dfs。那么我们只需要建立相邻两个状态的递推关系就行。递推关系很简单：已搜长度为n时，在当前走到的点上搜另外四个方向，每搜到一个可行方向，则使用n+1时的dfs。 需要注意的有两点： 开头需要将起点放入记录路径的数组中。 起点需要设为不可通行（否则会出现很多经过两边起点的路径）。 dfs时，需要先将当前点设为不可通行，退出递归时，再需要将当前点设为可通行。 #include <iostream> #include <cs
【数据结构】迷宫问题DFS非递归（c语言实现）
yyqzjw的博客
10-08 1594
迷宫问题
迷宫搜索所有路径(递归)
最新发布
Lincooo的博客
07-05 822
（3）走迷宫：从入口开始，在迷宫中寻找通路达到出口，障碍处无法通行。（1）创建迷宫：根据用户输入的行数n(3<=n<=100)和列数m(3<=m<=100)，假定入口始终在（1，1）位置，出口始终在（n,m）位置，创建一个n*m个格子的迷宫，要求屏幕中能显示迷宫信息。一个骑士骑马从入口走进迷宫，迷宫中设置很多墙壁，对前进方向形成了多处障碍。（2）创建障碍：用户输入障碍数k（1<k<n*m）,在创建好的迷宫中，随机将k个格子设置为障碍，不能将入口和出口设置为障碍，要求能在迷宫中显示障碍信息。
求解迷宫全部路径问题
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写入文件中。
遍历迷宫
weixin_33928467的博客
08-27 135
走迷宫 1 #include<stdio.h> 2 #define MAXSIZE 15 3 char point[MAXSIZE][MAXSIZE]={ 4 {'X','X','X','X','X','X','X','X','X','X','X','X','X','X','X'}, 5 {' ','o','o','o','o','o','X','o','o...
C语言 DFS (寻求迷宫起点到终点的所有路径)
Thy__father的博客
12-05 1770
数据结构:DSF(入门) 数据结构课程刚讲过DSF用的还不熟练,但是数据结构太枯燥了,不想练;好巧不巧,CSDN上刚好有人问一道迷宫路径的问题;哎！瞬间起劲了,虽然啥都不懂,但是就是想写一下试试;扣了一个小时,不过还好写出来了,同时参考了《啊哈算法》第4章 第1节(不撞南墙不回头—深度优先搜索) 没有什么快乐是水题给不了的,如果有,那就多来几道; #include<stdio.h> #include<string.h> #define N 1001 struct st{ int x
数据结构 图的遍历.pdf
09-13
数据结构中的图遍历是图论中的核心概念，主要用于遍历或访问图中所有节点，确保每个节点只被访问一次。...在实现过程中，通常需要借助辅助数据结构如栈（DFS）或队列（BFS）来辅助节点的访问和状态管理。
迷宫问题数据结构.docx
10-30
在计算机科学中，迷宫问题是一个经典的问题，它涉及到路径搜索和图遍历。迷宫问题数据结构的设计和实现是解决此类问题的关键。本篇文章将深入探讨如何使用数据结构，特别是二维数组，来表示和解决迷宫问题。 首先，...
C#迷宫数据结构
10-05
而“C#迷宫数据结构”这个项目，显然是一个利用C#编程语言来实现的关于迷宫问题的数据结构与算法应用实例。在这个项目中，开发者可能会涉及到深度优先搜索(DFS)、广度优先搜索(BFS)等经典算法，以及矩阵或图数据结构...
迷宫的路径输出(dfs)
m0_68565376的博客
09-30 756
递归，堆栈记录路径，dfs非最短路径
迷宫问题输出所有路径
qq_65039825的博客
03-13 985
#include<iostream> using namespace std; int dx[4]= {0,-1,0,1},dy[4]= {-1,0,1,0}; int g[20][20]; int n,m,num=0,endx,endy,flag=1; struct node { int x,y; } k[100]; void dfs(int x,int y,int num) { if(x==endx&&y==endy) { fo
DFS迷宫递归所有路径 新手入门
weixin_30432579的博客
03-09 813
这篇文章写给自己以后复习和个个入门朋友：提示同学们一定耐心看完解释 哪怕看得很难受，我是新手我懂大家的心烦。看完后慢慢体会代码 我们假设迷宫为如下状况： {0,0,1,0} {0,0,1,0} {0,0,0,0} {0,0,1,0}, 1为墙无法通行 只可以上下左右四个方向走动；目的：从左上角到右下角 ...
迷宫算法，求解所有路径（DFS）,(bug找了好久 )
weixin_44077170的博客
09-10 1430
#include using namespace std; typedef class maps { public : int x; int y; int d; maps *next; }*LinkStack,Link; const int M=10,N=10; int cx=8,cy=8;//定义出口变量 void push(LinkStack &L,int i...
输出迷宫的所有路径和最短路径
一介码夫
10-07 9363
编写这个代码主要是锻炼一下回溯和分支界限法的，分别通过深搜和广搜遍历解空间树可以解决 输出迷宫的所有路径和输出所有迷宫最短路径的两个问题，其中要注意的包括： 1，剪枝：包括界限和约束，在这个问题的约束主要是指该节点是否已遍历和是否能通过 2，回溯活节点（指能得到解的节点，比如该题就指矩阵中为0的元素）可多次成为扩展节点（即继续递归下去）， 而分支界限的活节点只有一次机会成为扩展节点。
BFS 遍历迷宫 JAVA 输出所有路径
weixin_42649617的博客
11-03 1370
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迷宫输出所有路径
05-27
好的，针对你的问题，我可以提供一个简单的深度优先搜索（DFS）算法来解决迷宫问题，并输出所有可行的路径。以下是基本的 Python 代码实现： ```python # 定义一个函数，输入迷宫矩阵maze，起点位置start，终点位置end def solveMaze(maze, start, end): # 定义一个空列表用于存储所有路径 allPaths = [] # 定义一个列表用于存储当前路径 currentPath = [] # 调用DFS函数进行搜索，并将结果存储在allPaths中 DFS(maze, start, end, currentPath, allPaths) # 返回搜索结果 return allPaths # 定义深度优先搜索函数DFS def DFS(maze, current, end, currentPath, allPaths): # 将当前位置加入当前路径 currentPath.append(current) # 如果当前位置等于终点位置，则将当前路径加入所有路径 if current == end: allPaths.append(currentPath.copy()) else: # 否则，遍历当前位置的相邻节点 for neighbor in getNeighbors(maze, current): # 如果相邻节点不在当前路径中，则递归调用DFS函数 if neighbor not in currentPath: DFS(maze, neighbor, end, currentPath, allPaths) # 将当前位置从当前路径中删除 currentPath.pop() # 定义一个函数，获取迷宫中某个位置的相邻节点 def getNeighbors(maze, current): neighbors = [] row, col = current # 检查上下左右四个方向的相邻节点 if row > 0 and maze[row-1][col] == 0: neighbors.append((row-1, col)) if row < len(maze)-1 and maze[row+1][col] == 0: neighbors.append((row+1, col)) if col > 0 and maze[row][col-1] == 0: neighbors.append((row, col-1)) if col < len(maze[0])-1 and maze[row][col+1] == 0: neighbors.append((row, col+1)) # 返回所有可行的相邻节点 return neighbors ``` 上述代码中，`solveMaze` 函数接收一个迷宫矩阵 `maze`，起点位置 `start` 和终点位置 `end`，并返回所有可行的路径。其中，`DFS` 函数使用深度优先搜索算法进行迷宫的遍历，并将所有可行的路径存储在 `allPaths` 列表中。`getNeighbors` 函数用于获取某个位置的相邻节点，以便进行搜索。 你可以将上述代码复制到 Python 环境中运行，或者将其集成到你的项目中，以实现在迷宫中输出所有路径的功能。
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值