迷宫

最新推荐文章于 2023-01-26 13:42:13 发布
最新推荐文章于 2023-01-26 13:42:13 发布
阅读量815 收藏 2
点赞数
CC 4.0 BY-SA版权
分类专栏： 数据结构 文章标签： 迷宫 栈应用 二维数组 迷宫递归实现
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/dangzhangjing97/article/details/78868963
本文介绍了一种使用递归和非递归方法解决迷宫问题的算法。通过将迷宫表示为二维数组，并利用栈来追踪路径，该算法能够找到从入口到出口的有效路线。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

如何走出这个迷宫？

算法：把迷宫保存在一个二维数组里，0代表不是路，1代表是路，给一个入口，开始探险，对走过的路径做一个标记
走过的路：用'2'标记
走错的路：用'3'标记
循环实现迷宫

Maze.h

#include<stdio.h>
#include<stdlib.h>
#include<iostream>
#include<stack>
using namespace std;
#define MAX_ROW 10
#define MAX_COL 10
struct Position
{
    Position(int x , int y  );
    int _x;
    int _y;
};
class maze
{
public:
    maze(int *array, size_t row, size_t col);//初始化迷宫
    void PrintMap();//打印迷宫
    void PassMazeNor(Position pos);//非递归实现走迷宫
    bool IsPass(Position pos);//判断是否为通路，如果不是通路，返回假，否则返回真
    bool IsExit(Position pos);//判断是否为出口，如果不是出口，返回假，否则返回真
private:
    int _map[MAX_ROW][MAX_COL];
};

Maze.cpp

#include"Maze.h"
Position::Position(int x , int y  )
:_x(x)
,_y(y)
{}
maze::maze(int *array, size_t row, size_t col)//初始化迷宫
{
    for (size_t i = 0; i < row; ++i)
    {
        for (size_t j = 0; j < col; ++j)
        {
            _map[i][j] = array[i*col + j];
        }
    }
}
void maze::PrintMap()//打印迷宫
{
    printf("迷宫为：\n");
    for (size_t i = 0; i <MAX_ROW; ++i)
    {
        for (size_t j = 0; j < MAX_COL; ++j)
        {
            cout << _map[i][j] << " ";

        }
        cout << endl;
    }
}
bool maze::IsPass(Position pos)//判断是否为通路，如果不是通路，返回假，否则返回真
{
    if (pos._x < 0 || pos._x >= MAX_ROW || pos._y < 0 || pos._y >= MAX_COL)//如果超过数组的边界，那就说明已经到出口
        return true;
    if (1 == _map[pos._x][pos._y])
        return true;
    return false;
}
bool maze::IsExit(Position pos)//判断是否为出口，如果不是出口，返回假，否则返回真
{
    if (pos._x >= 0 && pos._x < MAX_ROW&&pos._y >= 0 && pos._y < MAX_COL)//此位置还在迷宫里（数组里），那就不是出口，返回假
        return false;
    return true;//返回真，就意味着此位置是出口
}

void maze::PassMazeNor(Position pos)//非递归实现走迷宫
{
    if ( !IsPass(pos) )//判断是否为通路，如果不是通路，直接返回，否则进行下面的步骤
        return;
    stack<Position> s;
        s.push(pos);
        while (!s.empty())//栈为空，就退出循环，栈部位空，进入循环
        {
            if (IsExit(pos))//如果是出口，那就直接返回
            {
                s.pop();//最后一步不是有效路径，应出栈（栈中保存的是某一步路径）
                return;
            }
            pos = s.top();
            _map[pos._x][pos._y] = 2;//把走过的步标记为2

            /*先往上走，通的话，一直往上走，上如果不通，那就往左走，还是不通的话，那就往
            右走，还是不通的话，往回倒一步（不能往下走，因为走过的路，不能再走），再重新
            判断四周，往复循环，直到退到可以改变方向的位置*/

            //先往上走
                Position up(pos);
                up._x -= 1;//x坐标减去1，y坐标不变
                if (IsPass(up))//此位置如果是通路，把此位置保存到栈中，并且退出本次循环
                {
                    s.push(up);
                    continue;
                }
                //往左走
                Position left(pos);
                    left._y -= 1;//y坐标减去1，x坐标不变
                if (IsPass(left))//此位置如果是通路，把此位置保存到栈中，并且退出本次循环
                {
                    s.push(left);
                    continue;
                }
                //往右走
                Position right(pos);
                right._y += 1;//y坐标加上1，x坐标不变
                if (IsPass(right))//此位置如果是通路，把此位置保存到栈中，并且退出本次循环
                {
                    s.push(right);
                    continue;
                }
                //往回倒一步（不是往回走，而是往回倒一步，因为走过的路，不能再重复走）
                Position down(pos);
                down._x += 1;//x坐标加上1，y坐标不变
                if (IsPass(down)) //此位置如果是通路，把此位置保存到栈中，并且退出本次循环
                {
                    s.push(down);
                    continue;
                }
                _map[pos._x][pos._y] = 3;//把往回倒的步标记为3(位置是错的，标记此位置，并回到上一步）
                s.pop();//走错的步要出栈，以为栈里保存的是正确的路径
        }
}

test.cpp

#include"Maze.h"
int main()
{
    int mapArray[MAX_ROW][MAX_COL] =
    {
        { 0, 1, 0, 0, 0, 0, 0, 0, 0, 0 },
        { 0, 1, 0, 0, 0, 0, 0, 0, 0, 0 },
        { 0, 1, 0, 0, 0, 0, 0, 0, 0, 0 },
        { 0, 1, 1, 0, 0, 0, 0, 0, 0, 0 },
        { 0, 0, 1, 0, 0, 0, 0, 0, 0, 0 },
        { 0, 0, 1, 0, 1, 0, 0, 0, 0, 0 },
        { 0, 0, 1, 0, 1, 0, 0, 0, 0, 0 },
        { 0, 0, 1, 1, 1, 1, 0, 0, 0, 0 },
        { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 },
        { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 },
    };
    maze m((int*)mapArray, MAX_ROW, MAX_COL);
    m.PrintMap();
    m.PassMazeNor(Position(9, 5));//非递归实现迷宫
    m.PrintMap();
    system("pause");
    return 0;;
}

运行结果：
这里写图片描述

递归实现迷宫

Maze.h

#include<stdio.h>
#include<stdlib.h>
#include<iostream>
#include<stack>
using namespace std;
#define MAX_ROW 10
#define MAX_COL 10
struct Position
{
    Position(int x , int y  );
    int _x;
    int _y;
};
class maze
{
public:
    maze(int *array, size_t row, size_t col);//初始化迷宫
    void PrintMap();//打印迷宫
    void PassMazeNor(Position pos);//非递归实现走迷宫
    bool IsPass(Position pos);//判断是否为通路，如果不是通路，返回假，否则返回真
    bool IsExit(Position pos);//判断是否为出口，如果不是出口，返回假，否则返回真
    bool PassMaze(Position pos);//递归实现走迷宫
private:
    int _map[MAX_ROW][MAX_COL];
};

Maze.cpp

#include"Maze.h"
Position::Position(int x , int y  )
:_x(x)
,_y(y)
{}
maze::maze(int *array, size_t row, size_t col)//初始化迷宫
{
    for (size_t i = 0; i < row; ++i)
    {
        for (size_t j = 0; j < col; ++j)
        {
            _map[i][j] = array[i*col + j];
        }
    }
}
void maze::PrintMap()//打印迷宫
{
    printf("迷宫为：\n");
    for (size_t i = 0; i <MAX_ROW; ++i)
    {
        for (size_t j = 0; j < MAX_COL; ++j)
        {
            cout << _map[i][j] << " ";

        }
        cout << endl;
    }
}
bool maze::IsPass(Position pos)//判断是否为通路，如果不是通路，返回假，否则返回真
{
    if (pos._x < 0 || pos._x >= MAX_ROW || pos._y < 0 || pos._y >= MAX_COL)//如果超过数组的边界，那就说明已经到出口
        return true;
    if (1 == _map[pos._x][pos._y])
        return true;
    return false;
}
bool maze::IsExit(Position pos)//判断是否为出口，如果不是出口，返回假，否则返回真
{
    if (pos._x >= 0 && pos._x < MAX_ROW&&pos._y >= 0 && pos._y < MAX_COL)//此位置还在迷宫里（数组里），那就不是出口，返回假
        return false;
    return true;//返回真，就意味着此位置是出口
}


/*先往上走，通的话，一直往上走，上如果不通，那就往左走，还是不通的话，那就往
右走，还是不通的话，往回倒一步（不能往下走，因为走过的路，不能再走），再重新
判断四周，往复循环，直到退到可以改变方向的位置*/
bool maze::PassMaze(Position entry)//递归实现走迷宫
{
    if (IsExit(entry))//如果是出口，那就直接返回
        return true;
    if (IsPass(entry))
    {
        _map[entry._x][entry._y] = 2;//把走过的步标记为2
        Position up(entry);
        up._x -= 1;//x坐标减去1，y坐标不变
        if (PassMaze(up))//此位置如果是通路，开始下一次的函数调用
            return true;
        Position left(entry);
        left._y -= 1;//y坐标减去1，x坐标不变
        if (PassMaze(left))
            return true;
        Position right(entry);
        right._y += 1;//y坐标加上1，x坐标不变
        if (PassMaze(right))
            return true;
        Position down(entry);
        down._x += 1;//x坐标加上1，y坐标不变
        if (PassMaze(down))
            return true;
        _map[entry._x][entry._y] = 3;//把走错的路标记为3
    }
    return false;

}

test.cpp

#include"Maze.h"
int main()
{
    int mapArray[MAX_ROW][MAX_COL] =
    {
        { 0, 1, 0, 0, 0, 0, 0, 0, 0, 0 },
        { 0, 1, 0, 0, 0, 0, 0, 0, 0, 0 },
        { 0, 1, 0, 0, 0, 0, 0, 0, 0, 0 },
        { 0, 1, 1, 0, 0, 0, 0, 0, 0, 0 },
        { 0, 0, 1, 0, 0, 0, 0, 0, 0, 0 },
        { 0, 0, 1, 0, 1, 0, 0, 0, 0, 0 },
        { 0, 0, 1, 0, 1, 0, 0, 0, 0, 0 },
        { 0, 0, 1, 1, 1, 1, 0, 0, 0, 0 },
        { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 },
        { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 },
    };
    maze m((int*)mapArray, MAX_ROW, MAX_COL);
    m.PrintMap();
    m.PassMaze(Position(9, 5));//递归实现迷宫
    m.PrintMap();
    system("pause");
    return 0;;
}

运行结果：
这里写图片描述

迷宫-用栈实现的
10-13
迷宫-用栈实现的，数据结构严蔚敏版上的，迷宫-用栈实现的，数据结构严蔚敏版上的
迷宫栈
xyjy11的博客
04-02 694
do{ if(当前位置可以通过){ 入栈当前位置； 判断当前是否到终点； 未到终点，选择一个方向上的下个位置成为当前位置； } else{ 出栈；判断是否四个方向都遍历完； 是则当前位置不可行，标记不通；再出栈栈顶元素新一轮判断； 没有选择另一方向继续； }}while（栈不为空）主要代码如下：//type内保存当前位置的坐标和下一位置的方向class type{ int row; int c...
迷宫(栈实现)
StuRun的专栏
10-11 904
  #include #include #include using namespace std;#define OK 1 #define ERROR 0 #define STACK_INIT_SIZE 100 #define STACKINCREMENT 10 #define OVERFLOW -2 typedef int Status;t
栈实现迷宫
05-06
用栈实现迷宫问题，是数据结构中一个比较有意义的算法，如怎么实现最短路径
Maze迷宫游戏_迷宫小游戏C++_迷宫_
10-03
在本文中，我们将深入探讨如何使用C++编程语言来实现一个经典的迷宫游戏。迷宫游戏是一种极具挑战性和趣味性的智力活动，它涉及到路径搜索、决策制定和算法应用。在这个项目中，我们将创建一个名为“小老鼠走迷宫”...
迷宫生成器1.0迷宫生成器1.0
04-17
迷宫生成器1.0 迷宫生成器1.0迷宫生成器1.0迷宫生成器1.0迷宫生成器1.0迷宫生成器1.0迷宫生成器1.0迷宫生成器1.0迷宫生成器1.0迷宫生成器1.0迷宫生成器1.0迷宫生成器1.0迷宫生成器1.0迷宫生成器1.0迷宫生成器1.0迷宫...
zoumigong.rar_老鼠形象_老鼠走迷宫_老鼠迷宫游戏_迷宫图_迷宫老鼠游戏
07-14
走迷宫 程序开始运行时显示一个迷宫地图，迷宫中央有一只老鼠，迷宫的右下方有一个粮仓。游戏的任务是使用键盘上的方向键操纵老鼠在规定的时间内走到粮仓处。 要求： 1老鼠形象可辨认，可用键盘操纵老鼠上下左右移动...
Maze_qt迷宫_迷宫qt代码_qt生成迷宫_QT游戏_Qt；C++；迷宫；游戏_
10-03
《Qt C++构建的迷宫游戏详解》 在IT领域，游戏开发是一项充满挑战与创新的任务，而迷宫游戏作为经典的游戏类型，以其独特的趣味性和逻辑性吸引了众多开发者。本项目利用Qt C++框架，实现了迷宫的随机生成以及游戏...
用栈结构实现迷宫求解问题
03-02
数据结构试验实验一题目3——利用栈结构实现迷宫求解问题。
迷宫寻径 栈实现
10-11
数据结构课程设计 用栈实现寻径 显示路径
c语言的迷宫的栈求解
04-03
c语言里的栈的应用 源代码 极难
用栈写了一个迷宫算法
12-09
数据结构中的用栈实现迷宫算法，不是用递归算法，类似于图的遍历
迷宫问题（栈）
CXR_XC的博客
01-26 1558
用栈解决迷宫问题，并直观地展现出来
利用栈实现迷宫求解
胡邪的博客
03-26 8043
转自：https://www.cnblogs.com/cxyc/p/5322406.html 利用栈实现迷宫求解 前言：众所周知，栈是（First in last out）先进后出的数据结构，利用这个属性可以实现类似与回溯的方式，比如当前数据满足条件，则入栈，否则出栈返回上一级，依次循环。 在本题中，将每个迷宫路径上的点封装成上下左右四个方向数节点，先入栈迷宫入...
迷宫 栈的实现
famefamefame的博客
11-23 504
给一个二维列表，表示迷宫（0表示通道，1表示围墙）。给出算法，求一条走出迷宫的路径。 1代表墙，0代表路，图示如下： #include <stdio.h> #include <stdlib.h> #include <malloc.h> #define max 100 typedef struct Dircet { int x; int y; }Dircet; typedef struct Coordinate { int x; int y; }c..
用栈实现迷宫问题
weixin_45613730的博客
04-06 4132
#include <stdio.h> #include <stdlib.h> #include <malloc.h> #define MAXSIZE 500 //栈最大的容量 #define MAXLENGTH 20//设置最大的行和列是20 20*20 typedef struct{ int x; int y; }PosType;//PosType 坐标类型的变量PosType typedef struct { int ord;//用于存放路线 PosTy
c语言迷宫栈,学了栈，做了一个迷宫程序。
weixin_34942265的博客
05-20 120
该楼层疑似违规已被系统折叠隐藏此楼查看此楼#include#include#include#define NULL 0struct maze{struct maze *prior;int x;int y;int dir;struct maze *next;};int cmp(struct maze *head,struct maze *q){struct maze *p;int i=1;p=he...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值