## 基于广度优先搜索及运用队列和栈解决迷宫问题（c语言）

最新推荐文章于 2024-08-17 11:47:21 发布
最新推荐文章于 2024-08-17 11:47:21 发布
阅读量2.4k 收藏 32
点赞数 5
文章标签： 图论 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52447813/article/details/121408254
版权

基于广度优先搜索及运用队列和栈解决迷宫问题（c语言）

一、迷宫问题：
假设迷宫由m行n列构成，有一个入口和一个出口，入口坐标为（1，1），出口坐标为（m，n），试设计并验证以下算法：找出一条从入口通往出口的路径，或报告一个“无法通过”的信息。
(1) 用C语言实现顺序存储结构上队列的基本操作，然后利用该队列的基本操作找出迷宫的一条最短路径。

(2) 设计一个二维数组MAZE[m+2][n+2]表示迷宫，数组元素为0表示该位置可以通过，数组元素为1表示该位置不可以通行。MAZE[1][1]、MAZE[m][n]分别为迷宫的入口和出口。

(3) 输入迷宫的大小m行和n列，动态生成二维数组；由随机数产生0或1，建立迷宫，注意m*n的迷宫需要进行扩展，扩展部分的元素设置为1，相当于在迷宫周围布上一圈不准通过的墙。

(4) 要求输出模拟迷宫的二维数组；若存在最短路经，则由出口回溯到入口（出队列并利用栈实现），再打印从入口到出口的这条路径，例如(1,1)，……，(i,j)，……，(m,n)；若没有路径，则打印“No path!”。

(5)迷宫的任一位置(i,j)上均有八个可以移动的方向，用二维数组Direction存放八个方向上的位置偏移量。

Direction[8][2]={{0,1},{1,1},{0,-1},{-1,-1},{1,1},{0,-1},{-1,-1},{0,1}};

(6)为避免出现原地踏步的情况为了标志已经通过的位置，采用一个标志数组MARK[m+2][n+2]，初值均为0，在寻找路径的过程中，若通过了位置(i,j)，则将MARK[i][j]置为1。

(7) 为了记录查找过程中到达位置(i,j)及首次到达(i,j)的前一位置(i_pre,j_pre)，需要记住前一位置(i_pre,j_pre)在队列中的序号pre，即队列中数据元素应该是一个三元组(i,j,pre)。

(8) 搜索过程简单描述如下：将入口MAZE[1][1]作为第一个出发点，依次在八个方向上搜索可通行的位置，将可通行位置(i,j,pre)入队，形成第一层新的出发点，然后依次出队，即对第一层中各个位置分别搜索它所在八个方向上的可通行位置，形成第二层新的出发点，…，如此进行下去，直至达到出口MAZE[m][n]或者迷宫所有位置都搜索完毕为止。

简述问题：让我们运用到顺序队列和顺序栈基于广度优先搜索找出一个自动生成迷宫的路径，每次搜索是向周围八个方向搜索。

二、广度优先搜索在本次迷宫问题上的应用：
通俗的来说，这种思想在本次问题上的体现是，引入队列，由起点元素出发，找其周围八个地图结点，如果该地图结点时可通的，也就是值为’0‘，那么纳入队列。搜索完起点的八个方向，也就是完成了第一层搜索，此时队列中的元素是起点以及起点的儿子（起点周围的可通点），之后对起点的每个儿子开始搜索，也就是进行第二层搜索，如此又找到起点儿子的各自儿子，又将其纳入队列又开始新一层的搜索，（每次入队时都要入栈，为了便于打印出路径）。搜索会有两种结束情况，1.队列为空，证明在某一层搜索时其所有点都没有儿子（某层的点周围都没有通路），2.在某层对某个点周围进行搜索时找到了终点（最短路径出现了）。
如上的这种搜索，找到的路径一定是最短路径！（读者可自行思考）
三、核心代码解释
1.路径的搜索

void FindPath(MyQueue *queue,MyStack *stack,int sx,int sy,int MAZE[][N],int MARK[][N],int m,int n){//捕捉路径
    node Gather;//先引入一个结构体变量和三个整形的
    int tx;
    int ty;
    PushQueue(queue,sx,sy,-1);//将起点入队和入栈，由于其没有父亲，可将pre定义为-1，其实可以任意定义一个小于1的数字
    PushStack(stack,sx,sy,-1);
    int find = 0;//代表是否搜索到终点
    while (!QueueEmpty(queue) && !find){//循环的结束条件是队列为空或者已经捕获到终点
        Gather = GetQueueHead(queue);//获取队头元素
        OutQueue(queue);//队头结点出队
        int now = queue->front;//队头元素的下标
        for(int k = 0;k < 8;k++){//遍历八次即搜索八个方向
            tx = Gather.x + Direction[k][0];//加上特定二维数组完成对八个方向的搜索
            ty = Gather.y + Direction[k][1];
            if(tx < 1 || tx > n || ty < 1 || ty > m){//判断搜索到的是否是边界
                continue;
            }
            if(MAZE[tx][ty] == 0 && MARK[tx][ty] == 0){//如果其在迷宫上为0且没有在标记数组中出现（即没有被走过）那么纳入队列和栈
                MARK[tx][ty] = 1;
                PushQueue(queue,tx,ty,now);
                PushStack(stack,tx,ty,now);
            }
            if(tx == m && ty == n){//如果捕获到终点则结束
                find = 1;
                break;
            }
        }
    }

    if(find == 0){//如果上面的操作并没有找到终点则打印如下并退出
        printf("NO PATH!");
        exit(-1);
    }
}

2.迷宫的打印

void PrintPath(MyStack *myStack,int MAZE[][N]){//打印地图操作
    printf("\n");
    printf("路径(从右到左):");//由于是栈的操作所以打印出的是终点到起点
    int target = myStack->elem[myStack->top-1].pre;//如果有通路，那么栈顶元素一定是终点，pre为该点父亲的下标也等于其父亲的top-1
    MAZE[GetStackTop(myStack).x][GetStackTop(myStack).y] = 2;//把最短路径赋值为2方便观察
    printf("(");
    printf("%d,%d",myStack->elem[myStack->top-1].x,myStack->elem[myStack->top-1].y);//先打印出终点
    printf(") ");
    while (!StackEmpty(myStack)){//循环结束即出栈完成
        if(myStack->top-1 == target){//如果出栈元素的top-1也就是其下标等于上一次被打印元素的pre，则证明是上一个被打印元素的父亲
            printf("<- (");
            printf("%d,%d",myStack->elem[myStack->top-1].x,myStack->elem[myStack->top-1].y);
            printf(") ");
            target = myStack->elem[myStack->top-1].pre;//target改变，因为已经又找到一个路径元素
            MAZE[GetStackTop(myStack).x][GetStackTop(myStack).y] = 2;
            PopStack(myStack);//出栈
        }
        else{//如果不是其父亲直接出栈
            PopStack(myStack);
        }
    }
    printf("\n\n");
}

四、结果展示：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
五、完整代码

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <Windows.h>
#define M 100
#define N 100
int Direction[8][2]={{-1,0},{-1,1},{0,1},{1,1},{1,0},{1,-1},{0,-1},{-1,-1}};//代表八个方向的位移偏量

typedef struct {//结点元素结构体
    int x;//代表某个点坐标x
    int y;//代表某个点坐标y
    int pre;//代表某点的前驱结点在队列中的下标
}node;

typedef struct {//顺序栈的定义
    node *elem;
    int size;
    int top;
}MyStack;

typedef struct {//顺序队列的定义
    node *node;
    int rear;
    int front;
}MyQueue;

void color(int x);//改变打印出颜色的函数
void InPutMaze(int maze[][N],int m,int n);//自动创建迷宫的函数
void OutPutMaze( int MAZE[][N],int m,int n);//输出迷宫的函数
MyStack *StackCreak(MyStack *stack);//栈的创建
MyQueue *QueueCreak(MyQueue *queue);//队列的创建
void PushStack(MyStack *stack,int x,int y,int pre);//入栈操作
void PopStack(MyStack *stack);//出栈操作
int StackEmpty(MyStack *stack);//判断栈是否为空
node GetStackTop(MyStack *stack);//获取栈顶元素
void PushQueue(MyQueue *queue,int x,int y,int pre);//入队操作
void OutQueue(MyQueue *queue);//出队操作
node GetQueueHead(MyQueue *queue);//获取队头元素
int QueueEmpty(MyQueue *queue);//判断队列是否为空
void PrintPath(MyStack *myStack,int MAZE[][N]);//打印出路径
void FindPath(MyQueue *queue,MyStack *stack,int sx,int sy,int MAZE[][N],int MARK[][N],int m,int n);//找到路径

int main() {
    int m;
    int n;
    printf("请依次输入迷宫的m和n\n");
    printf("迷宫的大小为m+2 * n+2\n");
    scanf("%d %d",&m,&n);
    int MAZE[M][N];
    int MARK[M][N];
    for(int i = 0;i < m+2;i++){
        for(int j = 0; j < n+2;j++){
            MARK[i][j] = 0;
        }
    }
    InPutMaze(MAZE,m,n);//自动生成迷宫
    OutPutMaze(MAZE,m,n);//先打印出迷宫的样子
    MyStack *stack = StackCreak(stack);//创建栈
    MyQueue *queue = QueueCreak(queue);//创建队列
    PushStack(stack,2,2,2);//由于遍历的需要，栈会有个多余元素，其本身不会影响结果，不加的话才会
    FindPath(queue,stack,1,1,MAZE,MARK,m,n);//捕捉路径，传入的参数依次为，队列，栈，起点坐标，迷宫，标记数组，迷宫行列（迷宫终点与其相关）
    PrintPath(stack,MAZE);//打印出路径
    OutPutMaze(MAZE,m,n);//输出操作后迷宫
    return 0;
}

void OutPutMaze( int MAZE [][N],int m,int n) {
    for(int i = 0; i < m + 2; i++){//以二重循环遍历二维数组中的每个元素打印
        for(int j = 0;j < n+2;j++){
            if(MAZE[i][j] == 0){//对于0即可通结点用‘3’颜色，下面原理相同
                color(3);
                printf("%d ",MAZE[i][j]);
            }
            else if(MAZE[i][j] == 1)
            {
                color(4);
                printf("%d ",MAZE[i][j]);
            }
            else if(MAZE[i][j] == 2){
                color(6);
                printf("%d ",MAZE[i][j]);
            }
        }
        printf("\n");
    }
}

void InPutMaze(int maze[][N],int m,int n){//随机生成一个迷宫
    srand((unsigned)time(NULL));
    for(int i = 0;i < m+2;i++){
        for(int j = 0; j < n+2;j++){
            if(i == 0 || j == 0 || i == m+1 || j == n+1)//判断某个坐标点是否为边界点，是的话赋值为1
                maze[i][j] = 1;
            else
                maze[i][j] = rand()%2;//对随机数除2取余即可获得随机的0或1
        }
    }
    maze[1][1] = 0;//起点和终点赋值为0
    maze[m][n] = 0;
}

MyStack *StackCreak(MyStack *stack){//栈的初始化操作
    stack = malloc(sizeof (MyStack));
    stack->elem = malloc(sizeof (node) * 10000);//申请足够大的空间避免溢出
    stack->top = 0;
    stack->size = 1;
    return stack;//返回该指针
}

void PushStack(MyStack *stack,int x,int y,int pre){//入栈操作，栈中每个元素都是一个结构体结点
    stack->size++;
    stack->elem[stack->top].x = x;
    stack->elem[stack->top].y = y;
    stack->elem[stack->top].pre = pre;
    stack->top++;
}

void PopStack(MyStack *stack){//出栈操作
    stack->top--;
}

node GetStackTop(MyStack *stack){//获取栈顶元素
    node node1;//返回的是一个结构体结点
    node1.x = stack->elem[stack->top-1].x;
    node1.y = stack->elem[stack->top-1].y;
    node1.pre = stack->elem[stack->top-1].pre;
    return node1;
}

int StackEmpty(MyStack *stack){//判断栈是否为空
    if(stack->top == 0)
        return 1;
    return 0;
}

MyQueue *QueueCreak(MyQueue *queue){//队列的初始化
    queue = malloc(sizeof (MyQueue));
    queue->node = malloc(sizeof (node) * 10000);//也需要申请足够大的空间
    queue->front = 0;
    queue->rear = 0;
    return queue;
}

void PushQueue(MyQueue *queue,int x,int y,int pre){//入队操作
    queue->node[queue->rear].x = x;//让rear往后移动即可
    queue->node[queue->rear].y = y;
    queue->node[queue->rear].pre = pre;
    queue->rear++;
}

void OutQueue(MyQueue *queue){//出队操作，让front向后偏移
    queue->front++;
}

node GetQueueHead(MyQueue *queue){//获取队头元素
    node node1;//返回对头的坐标及父亲的下标
    node1.x = queue->node[queue->front].x;
    node1.y = queue->node[queue->front].y;
    node1.pre = queue->node[queue->front].pre;
    return node1;
}

int QueueEmpty(MyQueue *queue){//判断队列是否为空
    if(queue->rear == queue->front)
        return 1;
    return 0;
}

void FindPath(MyQueue *queue,MyStack *stack,int sx,int sy,int MAZE[][N],int MARK[][N],int m,int n){//捕捉路径
    node Gather;//先引入一个结构体变量和三个整形的
    int tx;
    int ty;
    PushQueue(queue,sx,sy,-1);//将起点入队和入栈，由于其没有父亲，可将pre定义为-1，其实可以任意定义一个小于1的数字
    PushStack(stack,sx,sy,-1);
    int find = 0;//代表是否搜索到终点
    while (!QueueEmpty(queue) && !find){//循环的结束条件是队列为空或者已经捕获到终点
        Gather = GetQueueHead(queue);//获取队头元素
        OutQueue(queue);//队头结点出队
        int now = queue->front;//队头元素的下标
        for(int k = 0;k < 8;k++){//遍历八次即搜索八个方向
            tx = Gather.x + Direction[k][0];//加上特定二维数组完成对八个方向的搜索
            ty = Gather.y + Direction[k][1];
            if(tx < 1 || tx > m || ty < 1 || ty > n){//判断搜索到的是否是边界
                continue;
            }
            if(MAZE[tx][ty] == 0 && MARK[tx][ty] == 0){//如果其在迷宫上为0且没有在标记数组中出现（即没有被走过）那么纳入队列和栈
                MARK[tx][ty] = 1;
                PushQueue(queue,tx,ty,now);
                PushStack(stack,tx,ty,now);
            }
            if(tx == m && ty == n){//如果捕获到终点则结束
                find = 1;
                break;
            }
        }
    }

    if(find == 0){//如果上面的操作并没有找到终点则打印如下并退出
        printf("NO PATH!");
        exit(-1);
    }
}

void PrintPath(MyStack *myStack,int MAZE[][N]){//打印地图操作
    printf("\n");
    printf("路径(从右到左):");//由于是栈的操作所以打印出的是终点到起点
    int target = myStack->elem[myStack->top-1].pre;//如果有通路，那么栈顶元素一定是终点，pre为该点父亲的下标也等于其父亲的top-1
    MAZE[GetStackTop(myStack).x][GetStackTop(myStack).y] = 2;//把最短路径赋值为2方便观察
    printf("(");
    printf("%d,%d",myStack->elem[myStack->top-1].x,myStack->elem[myStack->top-1].y);//先打印出终点
    printf(") ");
    while (!StackEmpty(myStack)){//循环结束即出栈完成
        if(myStack->top-1 == target){//如果出栈元素的top-1也就是其下标等于上一次被打印元素的pre，则证明是上一个被打印元素的父亲
            printf("<- (");
            printf("%d,%d",myStack->elem[myStack->top-1].x,myStack->elem[myStack->top-1].y);
            printf(") ");
            target = myStack->elem[myStack->top-1].pre;//target改变，因为已经又找到一个路径元素
            MAZE[GetStackTop(myStack).x][GetStackTop(myStack).y] = 2;
            PopStack(myStack);//出栈
        }
        else{//如果不是其父亲直接出栈
            PopStack(myStack);
        }
    }
    printf("\n\n");
}

void color(int x) {//一个可以自由选打印颜色的方法
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), x);
}

六、问题反思：
我认为本问题更适合用链式结构的线性表，如果采用顺序结构，可以使用动态栈和队列，感兴趣的同学可以试试。

爱笑的热情小光头
关注
广度优先搜索：迷宫问题
cclaibryan的专栏
06-22 7384
用广度优先搜索解决迷宫问题是一个比较基础的方法。由于自己在算法方面基础不是很好，并没有达到能随手就写出BFS的水平，所以花了点时间写了一个BFS来解决比较基础的迷宫问题，权当练习，并供自己以后参考。 迷宫描述：迷宫是一个二维数组。其中数字0表示能通过，数字1表示为障碍，数字5代表起点，数字8代表终点。程序首先从laby.txt文件中读取迷宫并存储在二维数组laby中。迷宫显示如下：
数据结构（C语言版） 栈与队列 迷宫问题
06-10
在C语言版的数据结构课程中，第三章深入探讨了两种基础但非常重要的数据结构——栈和队列，并应用它们解决实际问题，如迷宫问题。 栈是一种后进先出（LIFO）的数据结构，类似于我们日常生活中的叠放物品。它主要...
C语言使用广度优先搜索算法解决迷宫问题（队列）
08-29
主要介绍了C语言使用广度优先搜索算法解决迷宫问题,结合迷宫问题分析了C语言队列广度优先搜索算法的相关使用技巧,需要的朋友可以参考下
C程序广度优先搜索求解迷宫问题
04-17
使用C语言编程实现的运用广度优先搜索算法实现的迷宫问题的求解，其中的两点是在扩展过程中剪枝函数和约束函数的运用
数据结构与算法——BFS(广度优先搜索)
最新发布
大三计算机在读，分享我的算法之路
08-17 2832
广度优先搜索（Breadth-First Search，简称BFS）是一种遍历或搜索树和图的算法，也称为宽度优先搜索，BFS算法从图的某个节点开始，依次对其所有相邻节点进行探索和遍历，然后再对这些相邻节点的相邻节点进行探索，直到遍历完所有的节点。
C语言 迷宫问题 （广度优先算法）
u014566150的博客
12-01 1250
本来是想用esayx写的 发现好像用不着，直接改的窗口背景颜色做的，后来还改进了鼠标绘制地图 ，地图大小可以设置，寻路的过程也可以设置放慢的速度，作为大一的一个实践小项目，第一次发csdn，和大家一起分享。废话不多说，直接上代码！ ...
迷宫问题-广度优先搜索
东大微雕
04-05 573
You are trapped in a 3D dungeon and need to find the quickest way out! The dungeon is composed of unit cubes which may or may not be filled with rock. It takes one minute to move one unit north, sou
迷宫问题的算法(优于广度优先,深度优.rar_广度优先_广度优先算法_深度优先_迷宫广度优先_迷宫问题
09-19
迷宫问题的解决方案通常基于图遍历算法，其中广度优先搜索和深度优先搜索是两种常用的方法。首先，我们来理解这两种算法的基本思想： 1. **广度优先搜索（BFS）**： BFS是从起点开始，沿着所有可能的路径逐层向外...
迷宫问题的算法(优于广度优先,深度优先.zip_广度优先_深度优先_深度广度_迷宫问题
09-23
总结一下，迷宫问题的解决依赖于两种主要的搜索算法：广度优先搜索和深度优先搜索。BFS在寻找最短路径上更有优势，而DFS则以简单和内存效率著称。在实际应用中，开发者需要根据具体问题和资源限制来选择合适的算法。...
广度优先搜索(BFS)——迷宫问题(POJ 4127)
青春无问西东 岁月自成芳华
08-13 6990
这是一个经典算法 广度优先搜索的一个常见算法题，迷宫问题 稍微有一点难度的是需要输出最短的路径 (路径输出弄了一下午终于想到好的方法了 QAQ 哭死 一定是我太菜了)
广度优先搜索（迷宫问题2）
JZK-Keven 的博客
02-21 467
迷宫问题求最短路径 在结构体中多加入一个road记录该结构体的来源，然后存入数组，再将数组反向输出即可。 /* S01E 0010 0010 0100 0000 S010 0000 0010 01E0 0000 S011 0011 1111 1111 111E */ #include&lt;stdio.h&gt; #include&lt;string.h&gt; typedef...
广度优先搜索迷宫算法的简单实现
05-27
用二维数组存储迷宫（只存在一条路径），用广度优先搜索算法计算路径
广度优先遍历解决迷宫问题
qq_57484399的博客
10-19 2628
我们之前使用深度优先遍历的方法是 , 只派一个人去探索迷宫,记录其路线 和每个节点走过的方向 , 一条道走到黑 , 当路不通时候,回溯到上一个节点 的下一个方向 , 直到这个节点全部方向都遍历完,我们就放弃路线上的这个节点 ,接着回溯到这个节点的上一个节点的另一个方向 , 我们一定可以成功 ,因为我们就算不成功,早晚也可以回溯到起点 ,从起点的下一个方向出发 ,当把所有节点所有方向都遍历完,如果有解, 我们则可以找到出口 , 无解则输出无解 .
广度优先：链式队列处理迷宫问题（C语言）
weixin_62768524的博客
11-13 462
链式队列处理迷宫问题（C语言）
C语言广度优先搜索之迷宫（队列）
牛儿吃草的博客
09-12 6685
#include #define MAX_ROW 5 #define MAX_COL 5 struct point { int row, col, predecessor; } queue[512]; int head = 0, tail = 0; void enqueue(struct point p) { queue[tail++] = p; } struct point dequeue(
迷宫问题c语言广度搜索,迷宫问题Maze (BFS) 广度优先遍历 C语言
weixin_35507450的博客
05-24 348
給你一個迷宮，S為起點，E為終點。請你找出走出迷宮所需要花費的最短步數。你只能往上下左右四個方向移動。输入格式:第一行有一個數字T，代表有T組測資。每組測資的第一行有兩個數字R、C，代表迷宮的大小(R x C)。接下來R行，每行有C個字元來描述迷宮，'.'代表可以行走的路，'X'代表不可行走的牆壁，'S'代表起點，'E'代表終點。測資範圍：T < 1002 < R,C <= 30...
深度与广度优先搜索迷宫问题c语言,迷宫问题的求解方式：应用深度优先和广度优先的搜索...
weixin_29570673的博客
05-25 674
用堆栈实现迷宫问题，二维数组表示迷宫：1表示墙壁，0表示可以走的路，只能横着走或竖着走不能斜着走，要求编程实现找到从左上角到右下角的路线//深度优先：有解就退出搜索(不一定是最优解)#include#includeusingnamespacestd;#defineROW5#defineCOL5typedefstructpoint{int_row;int_col;}Point;P...
广度优先搜索（迷宫问题）
你就是根号四的博客
08-26 266
Sample Input: 10 10 #S######.# ......#..# .#.##.##.# .#........ ##.##.#### ....#....# .#######.# ....#..... .####.###. ....#...G# Sample Output: 22 #include<stdio.h> #include<stdlib.h> #...
分别用广度优先和深度优先解决迷宫问题c语言
05-31
好的，下面是分别用广度优先和深度优先解决迷宫问题的 C 语言代码，供参考： ### 广度优先搜索 ```c #include #include #include #define ROW 5 #define COL 5 int maze[ROW][COL] = { {0, 1, 0, 0, 0}, {0...
评论 9
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值