使用栈寻找迷宫通路

最新推荐文章于 2021-06-06 21:06:59 发布
原创 最新推荐文章于 2021-06-06 21:06:59 发布 · 712 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#栈 #数据结构

本文介绍了如何使用栈的非递归和递归算法解决迷宫问题。通过将起点入栈，检查栈中节点的相邻四个方向是否为0来推进路径搜索。在非递归方法中，主循环判断栈不空或栈顶为终点，内部循环尝试右、下、左、上四个方向。在递归方法中，从起点开始，标记并压栈，然后依次检查四个方向，直到找到通路或满足退出条件。

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

问题描述:

给定一个n*n的迷宫矩阵,障碍物记为1,无障碍记为0

int[][] map = new int[][]{
{1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
{1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1},
{1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1},
{1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1},
{1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1},
{1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1},
{1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1},
{1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1},
{1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1},
{1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1},
{1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1},
{1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}};

要求:

  1. 使用栈实现
  2. 非递归算法实现
  3. 递归算法实现

思路:

1.非递归思路:

  1. 将起点入栈
  2. 进入循环 (主循环),循环条件是 栈不空 或者栈顶元素坐标为终点坐标
  3. 循环中依次 对栈顶元素的 右,下,左,上(内循环)四个方向判断是否为0,一旦出现一个为0,压入该节点,该节点标记为2(已访问); 内部循环进行的条件是,不为0的次数<4,如果等于4,说明栈顶元素的四个方向都是堵住的,弹出栈顶元素,结束内层循环
  4. 主循环结束后,通过判断栈是否为空,可以判断是否寻找到通路
java 代码实现:

import java.util.Stack;

/**
 * @author wangwei
 * @date 2019/1/27 20:42
 * @classDescription 迷宫寻找出口路径:
 * 1,使用栈记录正确路径,同时也是方便回退
 */
class mapNode {
    int x;
    int y;

    public mapNode(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        this.y = y;
    }

    @Override
    public String toString() {
        return "mapNode{" +
                "x=" + x +
                ", y=" + y +
                '}';
    }
}

public class MazeStack {
    //使用 10*10 的矩阵  12*12  最外层是墙
    // 1 表示墙
    // 0 表示可走
    static final int N_WIDTH = 12;
    static final int N_HEIGHT = 12;
    int[][] map = new int[][]{
            {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
            {1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1},
            {1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1},
            {1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1},
            {1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1},
            {1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1},
            {1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1},
            {1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1},
            {1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1},
            {1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1},
            {1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1},
            {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}};
//    boolean[][] reachable = new boolean[N_WIDTH][N_HEIGHT];

//    //初始化reachable 数组,标记是否可以到达,辅助数组,能通过为true,已访问,不能通过为false,此代码展示未使用
//    public void init() {
//        for (int i = 0; i < N_WIDTH; i++) {
//            for (int j = 0; j < N_HEIGHT; j++) {
//                boolean reach = map[i][j] == 0;
//                reachable[i][j] = reach;
//            }
//        }
//    }
  /**
   * @author  wangwei
   * @date     2019/1/28 10:44
   * @methodDescription  非递归方式实现
   * 
   *   从起点开始:顺时针方向扫描元素,如果可达,标记为已经扫描,压栈,以该位置继续顺时针方向扫
                                 如果不可达:更改扫描方向
                                如果所有方向都已经扫描,不可达, ,退栈

         保存当前节点到栈中,继续探测该节点周围节点
   */
    public boolean searchWay(Stack<mapNode> way,int currX, int currY, int outX, int outY) {

     
        way.push(new mapNode(currX, currY));
        map[currX][currY] = 2;
        while (!way.isEmpty()) {

            mapNode currNode = way.peek();//取栈顶元素作为当次扫描的中间位置
            if (outX == currNode.getX() && outY == currNode.getY()) {
                System.out.println("找到出路");
                return true;
            }
            // 下一个节点:如果是 0 ,则入栈
            currX = currNode.getX();
            currY = currNode.getY();
            int failed = 0;
            if (map[currX][currY + 1] == 0) {
                way.push(new mapNode(currX, currY + 1));
                map[currX][currY + 1] = 2;//标记为已经到过
            } else {
                failed++;
            }
            if (map[currX + 1][currY] == 0) {
                way.push(new mapNode(currX + 1, currY));
                map[currX + 1][currY] = 2;//标记为已经到过
            } else {
                failed++;
            }
            if (map[currX][currY - 1] == 0) {
                way.push(new mapNode(currX, currY + 1));
                map[currX][currY - 1] = 2;//标记为已经到过
            } else {
                failed++;
            }
            if (map[currX - 1][currY] == 0) {
                way.push(new mapNode(currX - 1, currY));
                map[currX - 1][currY] = 2;//标记为已经到过
            } else {
                failed++;
            }
            //四个方向全部失败,说明栈顶元素周围被堵死,或者都被访问过
            if (failed > 3) {
                way.pop();
            }

        }
        return false;

    }
    public static void main(String[] args) {
        Stack<mapNode> throughWay = new Stack<>();

        MazeStack mazeStack = new MazeStack();

        mazeStack.searchWay(throughWay,1,1,10,10);
        System.out.println("找到的通路:");
        while (!throughWay.empty()) {
            System.out.println(throughWay.pop());
        }

    }
测试结果:

找到出路
找到的通路:
mapNode{x=10, y=10}
mapNode{x=10, y=9}
mapNode{x=9, y=9}
mapNode{x=8, y=9}
mapNode{x=8, y=8}
mapNode{x=8, y=7}
mapNode{x=7, y=7}
mapNode{x=7, y=6}
mapNode{x=6, y=6}
mapNode{x=5, y=7}
mapNode{x=5, y=6}
mapNode{x=5, y=5}
mapNode{x=4, y=5}
mapNode{x=4, y=4}
mapNode{x=3, y=4}
mapNode{x=3, y=3}
mapNode{x=2, y=4}
mapNode{x=2, y=3}
mapNode{x=2, y=2}
mapNode{x=1, y=2}
mapNode{x=1, y=1}

Process finished with exit code 0

2.递归思路,

首先将起点入栈,并且将数组中该点位置做上标记,比如改值为2(或者另起一个辅助数组)
2,对栈顶元素的四个方向节点进行扫描(假定是顺时针)
2.1 访问右节点
2.1.1 如果右节点值为0,将其标记为 2(已访问),压入右节点,递归调用
2.2 如果右节点!=0,访问下节点,
2.2.1 下节点如果为0,标记为2(已访问),压入该节点,递归调用
2.3 如果下节点!=0,访问左节点,
2.3.1 如果左节点为0,标记为2,入栈,压入该节点,递归调用
2.4 如果 左节点!=0,访问上节点,
2.41如果上节点为0,标记为2,入栈,递归调用
2.42 否则(说明四个方向都不为0),弹出栈顶元素,递归调用
**退出递归条件:**这点非常重要,不然会出现StackOverFlow 异常,整的一脸懵逼
1,栈为空,表示没有通路
2,栈顶元素坐标与出口坐标相同,表示找到通路

java 代码实现:

    //使用递归的方式查找出路,
    public boolean findWay(Stack<mapNode> way,  int outX, int outY) {
        int curX = way.peek().getX();
        int curY = way.peek().getY();
        //成功找到出口
        if (curX == outX && curY == outY) {
            return true;
        }
        //四周加上了一堵墙,这行判断就可以去掉了
//        if (curX < 0 || curX > N_WIDTH - 1 || curY < 0 || curY > N_HEIGHT - 1) {
//            return false;
//        }
        //栈中元素一定是可以到达的,接下来是检测其周围元素
        //右,下,左,上
        if (map[curX][curY + 1] == 0) {
            map[curX][curY + 1]=2;//标记为已访问
          way.push(new mapNode(curX,curY+1));
          return  findWay(way,outX,outY);
        }
        if (map[curX+1][curY ] == 0) {
            map[curX+1][curY]=2;
            way.push(new mapNode(curX+1,curY));
            return  findWay(way,outX,outY);
        }
        if (map[curX][curY -1] == 0) {
            map[curX][curY-1]=2;
            way.push(new mapNode(curX,curY-1));
            return  findWay(way,outX,outY);
        }
        if (map[curX-1][curY ] == 0) {
            way.push(new mapNode(curX-1,curY));
            return  findWay(way,outX,outY);
        }
        //四个方向都不可通过,弹出栈顶元素,
         way.pop();
        return findWay(way,outX,outY);
    }
测试代码:
public static void main(String[] args) {
        Stack<mapNode> throughWay = new Stack<>();
        MazeStack mazeStack = new MazeStack();
         throughWay.push(new mapNode(1,1));//压入起点
         mazeStack.findWay(throughWay,  10, 10);
        System.out.println("找到的通路:");
        while (!throughWay.empty()) {
            System.out.println(throughWay.pop());
        }

    }

测试效果:

找到的通路:
mapNode{x=10, y=10}
mapNode{x=10, y=9}
mapNode{x=9, y=9}
mapNode{x=8, y=9}
mapNode{x=8, y=8}
mapNode{x=8, y=7}
mapNode{x=7, y=7}
mapNode{x=7, y=6}
mapNode{x=6, y=6}
mapNode{x=5, y=6}
mapNode{x=5, y=5}
mapNode{x=4, y=5}
mapNode{x=4, y=4}
mapNode{x=3, y=4}
mapNode{x=2, y=4}
mapNode{x=2, y=3}
mapNode{x=2, y=2}
mapNode{x=1, y=2}
mapNode{x=1, y=1}

总结:

  1. 使用了栈保存当前可能的一个在通路上的节点(值为0,即入栈,并且标记已访问,至于它最终能否保留在栈中,还得看四周节点是否为0)

  2. 如果栈顶元素的四周都是不能到达的(或者已经标记过已访问),那么栈顶元素是不能保留在 入口=>出口 的路径上,需要将其弹出

  3. 如果栈为空,表明即使是起点放到栈中,起点也被墙隔离了,肯定是死路

  4. 递归算法,一定要特别注意递归结束条件!!!

C++用栈实现构造迷宫及寻找一条路径
weixin_45189666的博客
06-03 652
头文件和常量定义： #include <graphics.h> #include<iostream> #include<stack> #include<vector> #include <stdlib.h>//包含随机数 #define Row 20 #define Col 20 #define MaxSize 3 using namespace std; 定义一个类用于存放所走过的路径： class Box{ public: int i
堆栈解决迷宫搜索问题
cumt_wangxiang的博客
06-14 939
问题描述： 迷宫（maze）是一个矩形区域，它有一个入口和一个出口，入口位于迷宫的左上角，出口位于迷宫的右下角，在迷宫的内部包含不能穿越的墙和障碍物。迷宫路径搜索问题时寻找一条从入口到出口的路径，该路径是由一组位置组成的，每个位置上都设有障碍，且每个位置（第一个除外）都是前一个位置的东、南、西或北的邻居。 基本思路： 从迷宫的入口出发，沿正东方向顺时针对当前位置相邻的东、南、西、北四个位置依
迷宫问题——求一条通路
07-17
以一个m*n的长方阵表示迷宫，0和1分别表示迷宫中的通路和障碍。设计一个程序，对任意设定的迷宫，求出一条从入口到出口的通路，或得出没有通路的结论。 1.首先实现一个以链表作存储结构的栈类型，然后编写一个求解迷宫的非递归程序。求得的通路以三元组(i,j,d)的形式输出，其中(i,j)指示迷宫中的一个坐标，d表示走到下一坐标的方向。 2.测试几组数据，数据的规模由小变大，即网格越来越小，障碍越来越复杂。
寻找迷宫的一条出路 (o:通路，X障碍）
miao6664659的专栏
12-13 1539
转载自：1.July  http://blog.youkuaiyun.com/v_JULY_v/article/details/6126406 6、寻找迷宫的一条出路（o：通路； X障碍）     char Maze[MAX_SIZE][MAX_SIZE] = {{'X','X','X','X','X','X','X','X'},                                  {
简单迷宫的实现-------------找一条通路
baidu_37964044的博客
04-09 805
#include&lt;iostream&gt; #include&lt;assert.h&gt; #include&lt;stack&gt; using namespace std; //求解路径的基本思想：1.如果当前路径能够通过，将当前路经进行压栈，为了回退（回溯法），并将走过的路标记成2 不能走1，0可以走 //2.如果当前路径上下左右都不能通过，则出栈（回溯）并且将当前路径标为3 即...
用栈寻找迷宫的最短路径
Moons_is_me的博客
06-05 1148
#define _CRT_SECURE_NO_WARNINGS 1 #include using namespace std; #include #include struct Pos { size_t x; size_t y; }; stack MinPath; void InitMaze(int *maze, size_t size) { assert(maze); FIL
迷宫游戏（自动生成迷宫） 运用并查集自动生成迷宫地图，并运用队列和栈寻找迷宫通路并打印出来.zip
06-20
在这个迷宫游戏项目中，我们主要探讨了两个关键的算法技术：自动生成迷宫和寻找迷宫通路。首先，让我们深入理解这两种算法的工作原理。 一、自动生成迷宫地图 1. **并查集（Disjoint Set）**：并查集是一种用于...
python栈实战 迷宫寻找出口
最新发布
09-17
在使用Python进行迷宫寻找出口的实战中，我们可以构建一个二维数组来表示迷宫地图，其中不同的数字或者字符可以用来表示墙壁、通路以及起点和终点。然后通过栈来记录路径，并使用深度优先搜索的方法来探索从起点开始...
迷宫求解程序：使用栈算法寻找迷宫路径
该文件描述了一个基于栈数据结构的迷宫求解程序，其核心功能是在一个给定的迷宫中找到一条路径从起点到达终点，并能够在屏幕上显示该路径。程序允许用户加载和保存迷宫，提供了四个测试迷宫文件（test1~4.dd）来辅助...
用栈非递归方法迷宫找出路
05-12
对于一个给定的迷宫，用0、1分别表示迷宫中的通路和障碍。再分别给定你，入口和出口的坐标，求出一条从入口到出口的通路，或得不到通路。
利用栈实现迷宫找路
小王同学的博客
04-30 2616
利用栈实现迷宫找路 代码是练习时写的，写的可能不太好，但是功能都可以实现，主要看思路： 实现思路是： 1.给出起点 2.判断改点是不是终点 3.列出上下左右四个方向的值 4.判断各个方向是否通行（如果通行就递归调用方法本身，并将这个点入栈） 5.如果一条路走不通了就返回，并将当前点出栈 6.这样递归下去最终会找到出口 首先自己定义一个地图类： package 地图找路; public class...
用C语言解决迷宫设计与寻找通路的问题源程序
10-08
用C语言解决迷宫设计与寻找通路的问题源程序
迷宫求解——栈的简单应用
09-26
迷宫求解——栈的简单应用 要熟练得掌握一种数据结构，要经过大量的练习，而将数据结构应用于实际用用中则是一种非常好的锻炼方式。 此次便是应用java来实现 迷宫求解 这个经典的程序设计问题。
用Java完成迷宫(运用栈)
zhangluweishi的博客
01-07 1564
题目如图片： 处理的办法及代码： 1、迷宫中每个元素，有值、行、列，用一个类写入。 public class MazeNode { private int value;//值 private int i;//x private int j;//y private boolean []wayState;//状态 public MazeNode(...
栈求解迷宫问题
热门推荐
dream
04-11 1万+
问题：假设下图是某迷宫的地图，问此迷宫是否有一条通路 求解思想： 用栈来实现解决问题，主要步骤是 （1）从迷宫的
寻找迷宫出口<一>
John的博客
09-10 4415
寻找迷宫出口 小程序目的： 判断在一个10*10的矩阵中是否可以找到迷宫的出口； PS：程序功能比较单一，还有许多可以改进的地方，比如，可以寻找出口的最优路径，可是我现在没有想出来， 所以，在 寻找迷宫出口 我会对迷宫问题做出进一步的完善！ ---------------------------------------------------------
栈---解决迷宫问题
weixin_34088583的博客
04-12 105
迷宫问题，是栈的一个经典应用。在今多年的面试题中特别常见。本博主呢，也就研究了一二。 若有一迷宫，如何寻找通路？ 解题思路： 迷宫，可将其看成一个二维数组。给定一个入口，需要判断此入口的上下左右是否越界，是否有通路点。若有通路点，将此点前一个通路点记录并将其置为非0（防止访问下一个通路点时再次判断）。继续寻找下一个通路,...以此类推。若查找不到通路点，则需要...
数据结构03 栈 / 队列 /数组查找算法
weixin_50224527的博客
06-06 581
数组 查找算法 线性查找 就是用像查找的数一个个对比数组的数，成功返回下标，失败返回-1 ，因为数组下标没有-1 public static int flow(int[] a,int ele){ for (int i = 0; i <a.length ; i++) { if (a[i]==ele){ return i; } } return -1; } 二分法查找 优化 二分法找不到 必要条件是数组内数字有
栈与队列算法设计：(1)迷宫问题
weixin_43972499的博客
08-06 3827
目录1.题目2.题目分析 算法分析 算法实现3.参考代码4.测试结果 1.题目   迷宫问题的求解是实验心理学中的一个经典问题，心理学家把一只老鼠从一个无顶盖的大盒子的入口处赶进迷宫，迷宫中设置很多隔墙，对前进方向形成了多处障碍，心理学家在迷宫的唯一出口处放置了一块奶酪，吸引老鼠在迷宫中寻找通路以到达出口。设计算法实现迷宫求解。 2.题目分析  算法分析   1.这里我们使用的是栈来解决迷宫问题。    对于迷宫问题，我们常规的思维是——试错，即先随便找一条路，一直走下去，直到走到尽头，如果无法抵达出口，
使用栈解决迷宫问题的算法详解
示例中给出了两个迷宫实例，一个是存在通路的情况，另一个是没有通路的情况。通过运行代码，可以观察到算法如何寻找路径以及输出的结果。 算法的时间复杂度是O(n*m*2)，其中n和m分别是迷宫的行数和列数。这是因为每...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值