数组结构与算法-043-046-递归-迷宫回溯

最新推荐文章于 2024-09-20 14:26:28 发布
最新推荐文章于 2024-09-20 14:26:28 发布
阅读量80 收藏
点赞数
文章标签： 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46998705/article/details/107622879
版权

043 递归应用场景和调用机制

概念
递归就是方法自己调用自己，每次调用时传入不同的变量。递归有助于编程者解决复杂的问题，同时可以让代码变得简洁

package com.old.recursion_034_035;

public class RecursionTest {
    public static void main(String[] args) {
        test(4);
    }

    public static void test(int n){
        if (n > 2){
            test(n - 1);
        }
        System.out.println("n = " + n);
    }
}

044 递归能解决的问题和规则

能解决的问题：

  1. 各种数学问题如：8皇后，汉诺塔、阶乘问题、迷宫问题、球和篮子的问题
  2. 各种算法中也会使用递归，比如：快排、归并排序、二分查找、分治算法
  3. 将用栈解决的问题 递归代码比较简洁

规则：

  1. 执行一个方法时，就创建一个新的受保护的独立空间（栈空间）
  2. 方法的局部变量是独立的，不会相互影响
  3. 如果方法中使用的引用类型变量，就会共享该引用类型的数据
  4. 递归必须向退出递归的条件逼近，否则就是无限递归
  5. 当一个方法执行完毕，或者遇到 return ，就会返回，遵守谁调用，就将结果返回给谁，同时当方法执行完毕或者返回时，该方法也就执行完毕

045-046 迷宫回溯问题

045-迷宫问题实现与回溯-1

说明：

  1. 小球得到的路径，和程序员设置的找路策略有关，即：找路的上下左右的顺序相关
  2. 再得到小球路径时，可以先使用（下右上左），再改成（上右下左），，看看路径是不是有变化
  4. 思考：如何求出最短路径
package com.old.recursion_043_046;

public class MiGong {
    public static void main(String[] args) {
        //先创建一个二维数组，模拟迷宫
        int[][] map = new int[8][7];
        //使用 1 表示墙
        //上下全部转为 1
        for (int i = 0; i < 7; i++) {
//            map[0][i] = 1;
//            map[7][i] = 1;
            map[7][i] = map[0][i] = 1;
        }

        //左右全部置为 1
        for (int i = 0; i < 8; i++) {
//            map[i][0] = 1;
//            map[i][6] = 1;
            map[i][0] = map[i][6] = 1;
        }
        //设置挡板
        map[3][1] = map[3][2] = 1;
        map[1][2] = map[2][2] = 1;
        //输出地图
        System.out.println("地图的情况");
        for (int i = 0; i < map.length; i++) {
            int[] ints = map[i];
            for (int j = 0; j < ints.length; j++) {
                System.out.print(map[i][j] + " ");
            }
            System.out.println();
        }

        System.out.println();

        //使用递归回溯给小球找路
        setWay(map, 1 , 1);
//        setWay(map, 6, 5);
        //再输出新的路径，小球走过，并标识过的地图
        for (int i = 0; i < map.length; i++) {
            int[] ints = map[i];
            for (int j = 0; j < ints.length; j++) {
                System.out.print(map[i][j] + " ");
            }
            System.out.println();
        }
    }

    /**
     * 使用递归回溯来给小球找路
     * 说明：
     * 1. map 表示地图
     * 2. i ， j 表示从走出国门的哪个位置开始出发（1 ， 1）
     * 3. 如果小球能到 map[6][5] 位置，则说明通路找到
     * 4. 约定：当map[i][j] 为 0 表示该点没有走过，当为 1 的时候表示墙，如果
     *      2 表示通路可以走 ，3 表示该点走过，但是走不过
     * 5. 在迷宫时需要确定一个策略（方法），下 -》右 -》上-》左 ，如果该点走不能，再回溯
     * @param map 表示地图
     * @param i 哪个位置开始找
     * @param j
     * @return 如果找到通路，就返回 true，否则rclk false
     */
    public static boolean setWay(int[][] map, int i, int j){
        if (map[6][5] == 2){
            //说明通路已经找到
            return true;
        }else {
            //如果当前这个点还没有走过, 按照策略走 下 -》右 -》上-》左
            if (map[i][j] == 0){
                //假定该点是可以走通的
                map[i][j] = 2;
                if (setWay(map, i + 1, j)){
                    //向下走, 如果走到了 map[6][5] 那么这里就代表已经到达目的地了
                    return true;

                }else if (setWay(map, i, j + 1)){//向右走，理论同上
                    return true;
                }else if (setWay(map, i - 1, j)){//向上走，理论同上
                    return true;
                }else if (setWay(map, i, j - 1)){//向左走，理论同上
                    return true;
                }else {
                    //如果上下左右都走不能
                    map[i][j] = 3;
                    return false;
                }
            }else {
                //如果 map[i][j]  != 0 , 可能是1 ， 2 ， 3
                return false;
            }
        }
    }
}

046-迷宫问题实现与回溯-2

这集讲 最短路径

新增的代码

/**
     * 修改找路的策略，改成 上 -》 右 -》 下 -》 左
     * 找最短路径的思路，判断位置在哪里，根据位置所在判断上下左右执行
     * 没有更好的算法，
     * 把所有的策略用一个数组存起来，然后判断今后大小，这样最小的就是最好的策略
     * @param map
     * @param i
     * @param j
     * @return
     */
    public static boolean setWay2(int[][] map, int i, int j){
        if (map[6][5] == 2){
            //说明通路已经找到
            return true;
        }else {
            //如果当前这个点还没有走过, 按照策略走 上 -》 右 -》 下 -》 左
            if (map[i][j] == 0){
                //假定该点是可以走通的
                map[i][j] = 2;
                if (setWay2(map, i - 1, j)){//上
                    return true;

                }else if (setWay2(map, i, j + 1)){//右
                    return true;
                }else if (setWay2(map, i + 1, j)){//下
                    return true;
                }else if (setWay2(map, i, j - 1)){//左
                    return true;
                }else {
                    //如果上下左右都走不能
                    map[i][j] = 3;
                    return false;
                }
            }else {
                //如果 map[i][j]  != 0 , 可能是1 ， 2 ， 3
                return false;
            }
        }
    }

完整代码

package com.old.recursion_043_046;

public class MiGong {
    public static void main(String[] args) {
        //先创建一个二维数组，模拟迷宫
        int[][] map = new int[8][7];
        //使用 1 表示墙
        //上下全部转为 1
        for (int i = 0; i < 7; i++) {
//            map[0][i] = 1;
//            map[7][i] = 1;
            map[7][i] = map[0][i] = 1;
        }

        //左右全部置为 1
        for (int i = 0; i < 8; i++) {
//            map[i][0] = 1;
//            map[i][6] = 1;
            map[i][0] = map[i][6] = 1;
        }
        //设置挡板
        map[3][1] = map[3][2] = 1;
//        map[1][2] = map[2][2] = 1;
        //输出地图
        System.out.println("地图的情况");
        for (int i = 0; i < map.length; i++) {
            int[] ints = map[i];
            for (int j = 0; j < ints.length; j++) {
                System.out.print(map[i][j] + " ");
            }
            System.out.println();
        }

        System.out.println();

        //使用递归回溯给小球找路
//        setWay(map, 1 , 1);
        setWay2(map, 1 , 1);
//        setWay(map, 6, 5);
        //再输出新的路径，小球走过，并标识过的地图
        for (int i = 0; i < map.length; i++) {
            int[] ints = map[i];
            for (int j = 0; j < ints.length; j++) {
                System.out.print(map[i][j] + " ");
            }
            System.out.println();
        }
    }

    /**
     * 使用递归回溯来给小球找路
     * 说明：
     * 1. map 表示地图
     * 2. i ， j 表示从走出国门的哪个位置开始出发（1 ， 1）
     * 3. 如果小球能到 map[6][5] 位置，则说明通路找到
     * 4. 约定：当map[i][j] 为 0 表示该点没有走过，当为 1 的时候表示墙，如果
     *      2 表示通路可以走 ，3 表示该点走过，但是走不过
     * 5. 在迷宫时需要确定一个策略（方法），下 -》右 -》上-》左 ，如果该点走不能，再回溯
     * @param map 表示地图
     * @param i 哪个位置开始找
     * @param j
     * @return 如果找到通路，就返回 true，否则rclk false
     */
    public static boolean setWay(int[][] map, int i, int j){
        if (map[6][5] == 2){
            //说明通路已经找到
            return true;
        }else {
            //如果当前这个点还没有走过, 按照策略走 下 -》右 -》上-》左
            if (map[i][j] == 0){
                //假定该点是可以走通的
                map[i][j] = 2;
                if (setWay(map, i + 1, j)){
                    //向下走, 如果走到了 map[6][5] 那么这里就代表已经到达目的地了
                    return true;

                }else if (setWay(map, i, j + 1)){//向右走，理论同上
                    return true;
                }else if (setWay(map, i - 1, j)){//向上走，理论同上
                    return true;
                }else if (setWay(map, i, j - 1)){//向左走，理论同上
                    return true;
                }else {
                    //如果上下左右都走不能
                    map[i][j] = 3;
                    return false;
                }
            }else {
                //如果 map[i][j]  != 0 , 可能是1 ， 2 ， 3
                return false;
            }
        }
    }


    /**
     * 修改找路的策略，改成 上 -》 右 -》 下 -》 左
     * 找最短路径的思路，判断位置在哪里，根据位置所在判断上下左右执行
     * 没有更好的算法，
     * 把所有的策略用一个数组存起来，然后判断今后大小，这样最小的就是最好的策略
     * @param map
     * @param i
     * @param j
     * @return
     */
    public static boolean setWay2(int[][] map, int i, int j){
        if (map[6][5] == 2){
            //说明通路已经找到
            return true;
        }else {
            //如果当前这个点还没有走过, 按照策略走 上 -》 右 -》 下 -》 左
            if (map[i][j] == 0){
                //假定该点是可以走通的
                map[i][j] = 2;
                if (setWay2(map, i - 1, j)){//上
                    return true;

                }else if (setWay2(map, i, j + 1)){//右
                    return true;
                }else if (setWay2(map, i + 1, j)){//下
                    return true;
                }else if (setWay2(map, i, j - 1)){//左
                    return true;
                }else {
                    //如果上下左右都走不能
                    map[i][j] = 3;
                    return false;
                }
            }else {
                //如果 map[i][j]  != 0 , 可能是1 ， 2 ， 3
                return false;
            }
        }
    }
}
1854君
关注
01数组寻找通路c语言,迷宫算法 之 迷宫生成和迷宫寻路
weixin_34071707的博客
05-23 1555
迷宫算法 之 迷宫生成和迷宫寻路本文讲解迷宫生成和迷宫寻路算法。////////////////////////////////////////////////////////////////////////////////////////////////////一、三种迷宫生成算法1、 DFS(即深度优先)算法生成，分为递归和非递归方法。2、 十字分割算法生成，分为递归和非递归方法。3、随机 ...
【Java数据结构与算法】 递归及迷宫问题（回溯）
01-20
迷宫问题（回溯），递归（Recursion） 简单的递归使用 打印问题递归代码： public class RecursionTest { public static void main(String[] args) { //通过打印问题，来了解递归的调用机制 test(4); } ...
数据结构与算法04 路径回溯（递归）
weixin_41931400的博客
02-07 446
路径回溯（递归应用） 创建二维数组map 表示地图。 i,j 表示从地图的哪个位置开始出发 (1,1)。 如果小球能到 map[6][5] 位置，则说明通路找到。 约定： 当 map[i][j] 为 0 表示该点没有走过 当为 1 表示墙； 2 表示通路可以走 ； 3 表示该点已经走过，但是走不通。 在走迷宫时，需要确定一个策略(方法) 下->右->上->左 , 如果该点走不通...
数据结构与算法-递归（迷宫问题）
m0_62988332的博客
03-01 1734
迷宫通常被建模为一个二维网格，其中每个格子代表一个可行走的位置，墙或障碍物则用特定值标识。目标是找到从起点到终点的最短路径（或任何通路）。递归作为一种强大的编程工具，在解决这类问题时表现出了独特的魅力。递归求解迷宫问题不仅展示了递归算法的强大之处，也让我们深刻理解了回溯这一重要概念。在实践中，我们应根据具体需求选择合适的算法和数据结构以提高效率。无论是递归还是非递归解决方案，都反映出计算机科学中解决问题的创新思维和系统化方法论。通过研究迷宫问题及其解决方案，程序员可以进一步提升自己的算法设计和分析能力。
数据结构与算法 - 递归回溯（迷宫问题）
chun的博客
10-07 2572
递归的概念 简单说就是方法自己调用自己，每次调用时传入不同的变量，递归有助于编程者解决复杂的问题，同时可以让代码简介 递归的调用机制 递归能解决什么问题 递归需要遵守的重要规则 下面用代码来实现一个迷宫问题 主要代码（这里用到了回溯，也就是在if(setWay())）假如是先想下走了，这里开辟个新栈运行setWay如果上下左右都走不通，会把当前坐标设置成3，然后回到上一个坐标的程序里，继续...
数据结构与算法-----------递归之迷宫回溯问题
m0_71060858的博客
12-11 63
1)递归就是方法自己调用自己,每次调用时传入变量.
数据结构+算法--迷宫回溯问题分析和实现（递归回溯）
xiaotian的博客
01-28 203
迷宫回溯问题思路代码实现 思路 上图中代码的执行策略是：下->右->上->左 代码实现 public class MiGong { public static void main(String[] args) { //先创建一个二维数组 模拟迷宫 //地图 int[][] map = new int[8][7]; //使用1表示墙 //上下全部置为1 for(int i = 0;
数据结构与算法-递归
weixin_54232666的博客
09-21 246
数据结构与算法之递归，想弄懂递归，这一篇就够用了！包含小球走迷宫和八皇后问题，让你快速弄懂递归、回溯算法。
基本算法-回溯法（迷宫问题）
热门推荐
翟天保的博客
04-22 2万+
本文介绍一种经典算法——回溯法，以下是本篇文章正文内容，包括算法简介、算法流程和C++代码实现。
数据结构与算法--Python实现递归经典问题：Python实现迷宫回溯问题 Python实现八皇后问题
storyfull
12-21 1269
Python实现递归经典问题：迷宫回溯问题、八皇后问题
Java数据结构与算法-笔记-代码-课件-资料
05-17
稀疏数组、单向队列、环形队列、单向链表、双向链表、环形链表、约瑟夫问题、栈、前缀、中缀、后缀表达式、中缀表达式转换为后缀表达式、递归与回溯、迷宫问题、八皇后问题、算法的时间复杂度、冒泡排序、选择排序、...
Python-用于使用深度优先搜索和递归回溯算法生成和解决随机可解迷宫的Python脚本
08-11
用于使用深度优先搜索和递归回溯算法生成随机可解迷宫的Python脚本。 该代码还实现了用于解决生成的迷宫的递归回溯寻路算法。 这里是一个生成的迷宫及其计算解决方案的例子。
漫画算法-小灰的算法之旅_漫画算法-小灰的算法之旅_算法_
09-29
3. **图论算法**：小灰在旅途中可能会遇到复杂的关系网络，如迷宫或交通网络，这时会引入图的表示、深度优先搜索（DFS）、广度优先搜索（BFS）、最短路径算法（Dijkstra、Floyd-Warshall）等。这些算法帮助解决节点...
数据结构应试-1
最新发布
Nozomi9967的博客
09-20 717
Head(L)：返回广义表L的第一个元素。Tail(L)：返回除了第一个元素之外的剩余部分组成的广义表。
【数据结构和算法实践-树-LeetCode113-路径总和Ⅱ】
Mao_c的博客
09-14 1063
leetcode b树
数据结构—栈
2301_80151359的博客
09-17 465
/定义栈的结构//栈的空间大小int top;//栈顶}ST;
【JavaScript】数据结构之字典 & 哈希表
票票的博客
09-14 638
数据结构之字典和哈希表
数据结构中线性表的定义和特点
2401_83201682的博客
09-15 430
数据结构中线性表的有关介绍，欢迎观看，欢迎点评。
迷宫路径算法解析与数据结构应用-计算机科学视角
"本文主要介绍了数据结构的基本概念和迷宫路径算法的思想，强调了数据结构在编程中的重要性，特别是对于解决复杂问题如路径搜索的支撑作用。文章以Java为背景，探讨了如何利用数据结构来实现迷宫路径的搜索算法。" ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值