使用深度优先搜索算法来求解迷宫问题（C语言）

最新推荐文章于 2024-02-12 20:18:15 发布
最新推荐文章于 2024-02-12 20:18:15 发布
阅读量5.3k 收藏 22
点赞数 4
分类专栏： C语言 文章标签： c语言 算法 搜索
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kejizuiqianfang/article/details/68539878
版权

作为一名学软件的学生，现在才接触算法，实在有点……
下面是使用深度优先搜索算法的C语言代码

#include <stdlib.h>
#include <stdio.h>
#include <malloc.h>

#define SIZE_OF_STACK 100  //确定栈的初始长度
#define SIZE_OF_NEW_STACK 10  //确定栈每次延展的长度
#define true 1  //个人习惯定义的类似布尔类型数据
#define false 0


//初始化迷宫，0为可走路线
int map[15][15] =
{
    { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
    { 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
    { 1, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1 },
    { 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1 },
    { 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1 },
    { 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1 },
    { 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1 },
    { 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1 },
    { 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1 },
    { 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1 },
    { 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1 },
    { 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1 },
    { 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1 },
    { 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 1 },
    { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }
};

typedef struct maze
{
    int *baseX;   //储存x坐标的栈底指针
    int *baseY;     //储存y坐标的栈底指针
    int *topX;      //储存x坐标的栈顶指针
    int *topY;      //储存y坐标的栈顶指针
    int sizeStack;  //储存栈的当前长度
} MAZE;

int initStack(MAZE *M); //初始化栈
int destoryStack(MAZE *M);  //销毁栈
int pushStack(MAZE *M, int x, int y);  //可以把坐标压入栈顶
int getTop(MAZE M, int a[2]);  //获得栈顶的元素
int popStack(MAZE *M);   //弹出栈顶的元素
int isEmpty(MAZE *M);    //判断栈是否为空

int main()
{
    MAZE M;
    int tempA[2];  //定义一个用于储存坐标的数组
    int x, y;  //用于储存坐标的变量
    int flag = 4;  //标志性变量，用于每次标志已经搜索过的迷宫路径
    int count;  //判断每次查找到了几个方向的相同0数字
    initStack(&M);  //初始化栈
    pushStack(&M, 1, 1);  //先把迷宫入口压入栈中
    while(isEmpty(&M))
    {
        getTop(M, tempA);  //获得栈顶的元素
        popStack(&M);  //弹出栈顶的元素
        count = 0;  //每次对count初始化
        if(map[tempA[0]][tempA[1]] == 0)
            map[tempA[0]][tempA[1]] = flag;
        //判断上下是否为0
        if(tempA[0]>0 && tempA[0] < 14)
        {
            if(map[tempA[0]-1][tempA[1]] == 0)
            {
                x = tempA[0] - 1;
                y = tempA[1];
                pushStack(&M, x, y);
                count ++;
            }
            else if (map[tempA[0]-1][tempA[1]] == 3)
            {
                break;
            }
            if(map[tempA[0]+1][tempA[1]] == 0)
            {
                x = tempA[0] + 1;
                y = tempA[1];
                pushStack(&M, x, y);
                count ++;
            }
            else if (map[tempA[0]+1][tempA[1]] == 3)
            {
                break;
            }
        }
        //判断左右是否为0
        if(tempA[1] > 0 && tempA[1] < 14)
        {
            if(map[tempA[0]][tempA[1]-1] == 0)
            {
                x = tempA[0];
                y = tempA[1] -1;
                pushStack(&M, x, y);
                count ++;
            }
            else if (map[tempA[0]][tempA[1]-1] == 3)
            {
                break;
            }
            if(map[tempA[0]][tempA[1]+1] == 0)
            {
                x = tempA[0];
                y = tempA[1] + 1;
                pushStack(&M, x, y);
                count ++;
            }
            else if (map[tempA[0]][tempA[1]+1] == 3)
            {
                break;
            }
        }
        if(1 != count)
        {
            flag++;
        }
    }

    //下面开始判断哪些元素可以变成-1，用于下面的输出路径
    x = y = 1;
    int max = map[x][y];
    int xi, yi;
    while(3 != map[x][y])
    {
        if(x>0 && x<14)
        {
            if(map[x - 1][y] > max)
            {
                xi =  x - 1;
                yi = y;
                max = map[xi][yi];
            }
            else if(map[x - 1][y] == 3)
                break;
            if(map[x+1][y] > max)
            {
                xi = x+1;
                yi = y;
                max = map[xi][yi];
            }
            else if(map[x + 1][y] == 3)
                break;
            if(map[x][y+1] > max)
            {
                xi = x;
                yi = y+1;
                max = map[xi][yi];
            }
            else if(map[x][y+1] == 3)
                break;
            if(map[x][y-1] > max)
            {
                xi = x;
                yi = y-1;
                max = map[xi][yi];
            }
            else if(map[x][y-1] == 3)
                break;
        }
        map[xi][yi] = -1;
        //下面开始进行下一轮迭代的初始化
        max = 3;
        x = xi;
        y = yi;
    }
    //下面开始打印迷宫，带路线的
    int i, j;
    for(i=0; i<15; i++)
    {
        for(j=0; j<15; j++)
        {
            if(-1 == map[i][j])
                printf("- ");
            // 回复原来的值
            else if(map[i][j] > 3)
                printf("0 ");
            else
                printf("%d ", map[i][j]);
        }
        printf("\n");
    }
    destoryStack(&M);
    return 0;
}

int initStack(MAZE *M)
{
    M->baseX = (int *)malloc(sizeof(int) * SIZE_OF_STACK);
    if(M->baseX == NULL)
    {
        printf("fail to get memory!\n");
        exit(1);
    }
    M->baseY = (int *)malloc(sizeof(int) * SIZE_OF_STACK);
    if(M->baseY == NULL)
    {
        printf("fail to get memory!\n");
        exit(1);
    }

    M->topX = M->baseX;
    M->topY = M->baseY;
    M->sizeStack = SIZE_OF_STACK;
    return true;
}

int destoryStack(MAZE *M)
{
    free(M->baseX);
    free(M->baseY);
    M->topX = M->baseX = NULL;
    M->topY = M->baseY = NULL;
    M->sizeStack = 0;
    return true;
}

int pushStack(MAZE *M, int x, int y)
{
    if(M->topX - M->baseX >= M->sizeStack)
    {
        M->baseX = (int *)malloc(sizeof(int) * SIZE_OF_NEW_STACK);
        if(M->baseX == NULL)
        {
            printf("fail to get memory!\n");
            exit(1);
        }
        M->topX = M->baseX + SIZE_OF_STACK;
        M->sizeStack += SIZE_OF_NEW_STACK;
    }

    if(M->topY - M->baseY >= M->sizeStack)
    {
        M->baseY = (int *)malloc(sizeof(int) * SIZE_OF_NEW_STACK);
        if(M->baseY == NULL)
        {
            printf("fail to get memory!\n");
            exit(1);
        }
        M->topY = M->baseY + SIZE_OF_STACK;
        M->sizeStack += SIZE_OF_NEW_STACK;
    }
    *M->topX++ = x;
    *M->topY++ = y;
    return true;
}

int getTop(MAZE M, int a[2])
{
    if(M.baseX == M.topX)
        return false;
    a[0] = *(--M.topX);
    a[1] = *(--M.topY);
    return true;
}

int popStack(MAZE *M)
{
    if(M->baseX == M->topX)
        return false;
    M->topX--;
    M->topY--;
    return true;
}

int isEmpty(MAZE *M)
{
    if(M->baseX == M->topX)
        return false;
    return true;
}

这里推荐一篇博客
http://blog.csdn.net/gujinjinseu/article/details/42063437

kejizuiqianfang
关注
  • 4
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
教小学妹学算法：搜索算法解决迷宫问题
Alex
04-20 1980
最近有一位小学妹 Coco 入坑了算法，没有跟着老师正规的学习，而是自己走的野路子，一些解题方式确实把我雷到了，来看一下小学妹是怎么解决迷宫问题的。
C语言使用广度优先搜索算法解决迷宫问题（队列）
08-29
主要介绍了C语言使用广度优先搜索算法解决迷宫问题,结合迷宫问题分析了C语言队列广度优先搜索算法的相关使用技巧,需要的朋友可以参考下
C语言使用深度优先搜索算法解决迷宫问题(堆栈)
12-25
本文实例讲述了C语言使用深度优先搜索算法解决迷宫问题。分享给大家供大家参考，具体如下： 深度优先搜索 伪代码 （Pseudocode）如下： 将起点标记为已走过并压栈; while (栈非空) { 从栈顶弹出一个点p; if (p这个点是终点) break; 否则沿右、下、左、上四个方向探索相邻的点 if (和p相邻的点有路可走，并且还没走过) 将相邻的点标记为已走过并压栈，它的前趋就是p点; } if (p点是终点) { 打印p点的坐标; while (p点有前趋) { p点 = p点的前趋; 打印p点的坐标; } } else 没有路线可以到达终点; C语言代码： #include
C语言 数据结构中求解迷宫问题实现方法
08-30
主要介绍了C语言 数据结构中求解迷宫问题实现方法的相关资料,需要的朋友可以参考下
深度优先搜索解决迷宫问题（最小步数求解）
最新发布
dinosaur2004的博客
02-12 866
迷宫问题是一个经典的图搜索问题，其中迷宫由一系列的单元格组成，有些单元格之间可以相互通行，有些则不行。玩家的目标是从迷宫的起点出发，通过一系列合法的移动，最终到达迷宫的终点。深度优先搜索（DFS）是解决迷宫问题的一种有效算法。
基于Python实现的机器人自动走迷宫
热门推荐
毕业作品网站
05-22 1万+
Maze选取图中某一顶点ViV_iVi​为出发点，访问并标记该顶点；以Vi为当前顶点，依次搜索ViV_iVi​的每个邻接点VjV_jVj​，若VjV_jVj​未被访问过，则访问和标记邻接点VjV_jVj​，若VjV_jVj​已被访问过，则搜索ViV_iVi​的下一个邻接点；以VjV_jVj​为当前顶点，重复上一步骤），直到图中和ViV_iVi​有路径相通的顶点都被访问为止；
【路径规划】基于A星算法机器人走迷宫路径规划matlab代码
m0_60703264的博客
12-06 294
1 简介 基本的迷宫搜索算法被称为无信息规划算法是一种盲从状态下的搜索算法。所谓的无信息规划，指的是除了起点和终点之间的点以外的中间节点都是可扩展节点，且它们成为系统后续搜索节点的概率是相同的。无信息规划算法中最常见的是广度优先和深度优先两种。而传统的向心法则是由右手法则、左手法则、中左法则和中右法则按照一定规则有机组合起来的一种深度优先的搜索法则。这种算法首先将迷宫分为4个区域，当电脑鼠处在不同区域时再根据电脑鼠的行进方向选择不同的搜索法则，其具体组合方式如图1所示。大多数情况下其搜索效率优于右手...
机器人走迷宫
h91er的博客
12-29 1893
机器人走迷宫 在解题时应注意题目问的为可以到达的且列
人工智能 - A*算法解决迷宫问题 附源码和可视化显示
SCY164759920的博客
12-31 3293
人工智能 - A*算法解决迷宫问题 附源码和可视化显示
C++ 栈和典型迷宫问题
y6123236的专栏
10-10 1672
本文编码实现了顺序栈和链式栈，简要介绍了STL中的stack容品，并使用它解决了典型的迷宫问题。
C语言万能搜索之走迷宫
weixin_74612475的博客
03-27 186
接着，如果路径顺畅的话，标记好你走过的位置,知道意外跳出循环或者到达终点，用return,使得book[][]=0,清除你走过的前几点（具体怎么的过程，可参考放置卡牌），最终计算出路径数！其次，注意判断在走完之后，（tx = x+next[k][0],ty = y + next[k][1]）时，tx,ty不能越界！接着，如果，走着走着越界，记住要continue,会跳出此次循环，对其他方向进行探索，不能用return,否则直接进行下一步递归，还有方向没考虑；2.递归格式：先写判断条件，判断是否走到终点；
C语言迷宫求解算法设计
07-07
C语言迷宫求解算法设计
【最新编排】迷宫求解C语言版(数据结构书上的算法).doc
05-06
【最新编排】迷宫求解C语言版(数据结构书上的算法).doc
《数据结构》 严蔚敏老师 迷宫求解算法（栈） C语言实现
01-07
根据书中的伪代码实现的迷宫求解，但是并不是最优解，适合刚开始学栈的同学参考 #include #include #include #include #define TURE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASINLE -1 #...
使用C语言实现串的匹配朴素算法（BF算法）
kejizuiqianfang的博客
04-02 4206
使用C语言实现BF这种低效率的算法，代码还是比较简单的。 不过效率比较低下。#include <stdio.h> #include <stdlib.h> #include <string.h>#define MAXSIZE 100 #define MINSIZE 30int main() { char parentString[MAXSIZE]; char sonString[MI
使用堆栈实现十进制转换成二进制
kejizuiqianfang的博客
03-30 2360
计算十进制转换成二进制的方式非常类似堆栈的后进先出的方式（LIFO），所以可以使用下面的代码实现#include <stdio.h> #include <stdlib.h> #include <malloc.h>#define SIZE_INTI_STACK 100 //确定栈的初始长度 #define SIZE_OF_NEW_STACK 10 //确定栈每次延展的长度 #define true
KMP算法简介（next数组的计算方法）
kejizuiqianfang的博客
04-03 2352
网上不少KMP算法的实例和讲解，很多大神也对此进行了详细的讲解，作为一名大一的新接触算法的人而言，我对此感觉很高深，而且有些不耐烦看长篇大论的文章。 下面附上一个next计算的算法不错的博客，我就是从这里面学到的next算法 http://www.cnblogs.com/yjiyjige/p/3263858.html 这篇博客使用java编写的KMP算法，我使用的是C语言，对于初学者应该比较好
深度优先搜索求解迷宫问题算法
11-29
以下是使用深度优先搜索算法解决迷宫问题的C语言代码示例： ```c #include #include #define ROW 5 #define COL 5 int maze[ROW][COL] = { {0, 1, 0, 0, 0}, {0, 1, 0, 1, 0}, {0, 0, 0, 0, 0}, {0, 1, 1, ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值