十、递归

最新推荐文章于 2025-05-13 14:42:58 发布
最新推荐文章于 2025-05-13 14:42:58 发布
阅读量111 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 数据结构与算法分析
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/a2231476020/article/details/98600707
本文探讨了递归算法的基本概念及其在解决迷宫路径问题中的应用。通过两个示例，详细展示了如何使用递归算法寻找从起点到终点的路径，包括算法的实现细节和运行过程。

简单递归：

package com.liaoxiang.recursion;

/**
 * @auther Mr.Liao
 * @date 2019/8/5 19:44
 */
public class SimpleRecursionDemo {
    public static void main(String[] args) {
        test1(4);
        System.out.println();
        test2(4);
        System.out.println();
        int res = factorial(3);
        System.out.println("res=" + res);
    }

    /**
     * 简单递归调用
     * @param n
     */
    public static void test1(int n){
        if (n > 2) {
            test1(n - 1);
        }
        System.out.println("n=" + n);
    }

    /**
     * 简单递归调用
     * @param n
     */
    public static void test2(int n){
        if (n > 2) {
            test2(n - 1);
        } else {
            System.out.println("n=" + n);
        }

    }

    /**
     * 阶乘
     * @param n
     * @return
     */
    public static int factorial(int n) {
        if (n == 1){
            return 1;
        } else {
            return factorial(n - 1) * n;
        }
    }
}
n=2
n=3
n=4

n=2

res=6

在这里插入图片描述
使用递归找迷宫路径

package com.liaoxiang.recursion;

/**
 * @auther Mr.Liao
 * @date 2019/8/5 20:28
 */
public class MiGong {
	/**
     * 使用二维数组表示迷宫地图
     * map[i][j] = 0 表示该点没有走过，为1表示碰到障碍，2表示可行通路，3表示该点已经走过，且走不通
     * map[1][1] = 0 为起始位置，map[2][2] = 2 为终点位置
     * 路径策略：下->右->上->左
     */
    public static void main(String[] args) {
        int[][]  map = new int[4][4];
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {
                map[i][j] = 1;
            }
        }
        map[1][1]=0;
        map[1][2]=0;
        map[2][2]=0;
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {
                System.out.print(map[i][j]+" ");
            }
            System.out.println();
        }
        boolean b = setWay(map, 1, 1);
        System.out.println("是否找到路径："+b);
        System.out.println("路径路线：");
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {
                System.out.print(map[i][j]+" ");
            }
            System.out.println();
        }

    }
    public static boolean setWay(int[][] map, int i, int j) {
        if (map[2][2] == 2) {
            return true;
        } else {
            if (map[i][j] == 0) {
                map[i][j] = 2;
                if (setWay(map, i + 1, j)){
                    System.out.println(i+"-"+j);
                    return true;
                } else if (setWay(map, i, j+1)){
                    System.out.println(i+"-"+j);
                    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 {
                return false;
            }
        }
    }
}
迷宫：
1 1 1 1 
1 0 0 1 
1 1 0 1 
1 1 1 1 
2-2
1-2
1-1
是否找到路径：true
路径路线：
1 1 1 1 
1 2 2 1 
1 1 2 1 
1 1 1 1

在这里插入图片描述

package com.liaoxiang.recursion;

/**
 * @auther Mr.Liao
 * @date 2019/8/5 20:28
 */
public class MiGong {
    /**
     * 使用二维数组表示迷宫地图
     * map[i][j] = 0 表示该点没有走过，为1表示碰到障碍，2表示可行通路，3表示该点已经走过，且走不通
     * map[1][1] = 0 为起始位置，map[2][2] = 2 为终点位置
     * 路径策略：下->右->上->左
     */
    public static void main(String[] args) {
        // 构建一个8行7列的二维数组表示地图
        int[][]  map = new int[8][7];
        //数组元素 1 表示墙，将上下边界元素设为1 第0行和第7行
        for (int i = 0; i < 7; i++) {
            map[0][i] = 1;
            map[7][i] = 1;
        }
        // 将左右边界设置为1，第0列和第6列
        for (int i = 0; i < 8; i++) {
            map[i][0] = 1;
            map[i][6] = 1;
        }
        //设置障碍
        map[3][1] = 1;
        map[3][2] = 1;
        // 遍历输出
        System.out.println("迷宫：");
        for (int i = 0; i < 8; i++) {
            for (int j = 0; j < 7; j++) {
                System.out.print(map[i][j]+" ");
            }
            System.out.println();
        }
        boolean b = setWay(map, 1, 1);
        System.out.println("是否找到路径："+b);
        System.out.println("路径：");
        // 遍历输出
        for (int i = 0; i < 8; i++) {
            for (int j = 0; j < 7; j++) {
                System.out.print(map[i][j]+" ");
            }
            System.out.println();
        }
    }
    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)){
                    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 {
                return false;
            }
        }
    }
}
迷宫：
1 1 1 1 1 1 1 
1 0 0 0 0 0 1 
1 0 0 0 0 0 1 
1 1 1 0 0 0 1 
1 0 0 0 0 0 1 
1 0 0 0 0 0 1 
1 0 0 0 0 0 1 
1 1 1 1 1 1 1 
是否找到路径：true
路径：
1 1 1 1 1 1 1 
1 2 0 0 0 0 1 
1 2 2 2 0 0 1 
1 1 1 2 0 0 1 
1 0 0 2 0 0 1 
1 0 0 2 0 0 1 
1 0 0 2 2 2 1 
1 1 1 1 1 1 1

修改迷宫为如下样式：

迷宫：
1 1 1 1 
1 0 1 1 
1 0 1 1 
1 1 1 1

package com.liaoxiang.recursion;

/**
 * @auther Mr.Liao
 * @date 2019/8/5 20:28
 */
public class MiGong {
    /**
     * 使用二维数组表示迷宫地图
     * map[i][j] = 0 表示该点没有走过，为1表示碰到障碍，2表示可行通路，3表示该点已经走过，且走不通
     * map[1][1] = 0 为起始位置，map[2][2] = 2 为终点位置
     * 路径策略：下->右->上->左
     */
    public static void main(String[] args) {
        int[][]  map = new int[4][4];
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {
                map[i][j] = 1;
            }
        }
        map[1][1]=0;
        map[2][1]=0;
        System.out.println("迷宫：");
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {
                System.out.print(map[i][j]+" ");
            }
            System.out.println();
        }
        boolean b = setWay(map, 1, 1);
        System.out.println("是否找到路径："+b);
        System.out.println("路径路线：");
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {
                System.out.print(map[i][j]+" ");
            }
            System.out.println();
        }

    }
    public static boolean setWay(int[][] map, int i, int j) {
        if (map[2][2] == 2) {
            return true;
        } else {
            if (map[i][j] == 0) {
                map[i][j] = 2;
                if (setWay(map, i + 1, j)){
                    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 {
                return false;
            }
        }
    }
}
迷宫：
1 1 1 1 
1 0 1 1 
1 0 1 1 
1 1 1 1 
是否找到路径：false
路径路线：
1 1 1 1 
1 3 1 1 
1 3 1 1 
1 1 1 1

递归过程：
在这里插入图片描述

递归
Sharing_的博客
08-20 2757
基本思想： 递归策略只需要少量的代码就可以描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。一般来说，构成递归需要具备以下两个条件：首先，子问题和原始问题要执行的操作应该是一致的，并且通常来说，子问题规模更小，更为简单；其次，不能无限制地调用自身，需要有一个出口，化简为非递归的情况进行处理。 斐波那契数列是一个比较典型的递归的例子，它指的是这样一个数列：0,1，1,2,3,5,8,13,21…。在数学上，斐波那契数列以如下方式定义：F[0]=0,F[1]=1,F[N]=F[N-1]+F[N-2]
java递归1加到10,算法（1）：递归
weixin_36060917的博客
03-10 1324
脑抽的我上个文章烂尾，又开新坑，，，，我只能对自己前面开的烂坑说一句：青山不改，绿水长流，我们有缘再见！这次我想刷一刷算法题(对，我又叒叕换目标了)，把常见的基础算法做一个总结(千万别又是起个头就扔那里不管了，真的是废人一个了。。。)好，话不多说，递归(Recursion)走起！概念理解：首先我们分析一下定义，递归是一种使用某种函数来解决问题的方法(当然你可以忽略这句废话)，特殊之处便在于该函数会...
python递归十进制转化二进制_如何用递归的方法把二进制转换成十进制？
weixin_39604139的博客
12-02 787
你让这件事变得更复杂了。无需功率计算。在def binary_to_decimal(bstring):if not bstring:return 0return binary_to_decimal(bstring[:-1]) * 2 + int(bstring[-1])# Testfor i in range(16):b = format(i, 'b')n = binary_to_decimal(...
Python递归函数
wyy202206174248的博客
05-10 887
递归函数是指在函数定义中直接或间接调用自身的函数。它通过将大问题分解为相似的小问题来解决问题，直到达到一个可以直接解决的简单情况（称为基线条件）。生活中的递归例子俄罗斯套娃：每个娃娃里面都有一个更小的同类娃娃镜子中的镜子：无限反射的效果数学中的阶乘：5!= 5 × 4!，4!= 4 × 3!，依此类推递归是一种强大的编程技术，需要时间和练习才能掌握。开始时可能会觉得难以理解，但随着实践，你会逐渐体会到它的优雅和强大。记住：每个递归问题都有基线条件和递归条件，确保每次调用都更接近基线条件。学习建议。
mysql 递归
global_coding的博客
05-17 536
递归
C语言递归解决十进制转换二进制
热门推荐
weixin_45766199的博客
02-09 1万+
C语言利用十进制转换为二进制的方法
C#之递归
Major_S的博客
05-13 1266
递归是一种编程技术，其中函数调用自身来解决问题。递归通常用于解决可以分解为相似子问题的问题。明确基本情况和递归情况：确保递归能够终止考虑性能影响：对于深度递归或重复计算，考虑优化注意栈溢出风险：对于大输入，可能需要转换为迭代利用记忆化：缓存中间结果提高效率保持代码可读性：适当的注释和日志有助于理解递归过程通过合理应用递归，您可以编写出简洁、优雅且功能强大的C#代码。记住，递归不是万能的，但在适当的问题域中，它能提供比迭代更直观的解决方案。
递归程序设计
qq_43407321的博客
06-01 294
递归程序设计 一．实验目的 掌握递归程序设计的方法。明确递归的概念，通过对问题的分析，找出递归关系以及递归出口以对问题进行递归结构设计； 掌握递归程序转换为非递归程序的方法。 实验内容 用递归方法设计下列各题，并给出每道题目的递归出口（递归结束的条件）和递归表达式。同时考虑题目可否设计为非递归方法，如果可以，设计出非递归的算法。 1.一个人赶着鸭子去每个村庄卖，每经过一个村子卖去...
Java——递归
Stewie Lee的博客
06-13 7760
回溯算法是一种系统化地搜索问题解空间的方法，主要用于解决组合优化问题。它通过递归地构建候选解，并在发现候选解不满足问题条件时回溯，从而尝试其他可能的选择。回溯算法的核心思想是不断尝试和撤销选择，直到找到所有可能的解决方案或者确认无解。
十、函数递归
weixin_58543820的博客
07-05 516
什么是递归？程序调用自身的编程技巧称为递归（ recursion）。递归做为一种算法在程序设计语言中广泛应用。一个过程或函数在其定义或说明中有直接或间接调用自身的 一种方法，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解。递归策略：只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。递归的主要思考方式在于：把大事化小递归的两个必要条件 ：存在限制条件，当满足这个限制条件的时候，递归便不再继续。每次递归调用之后越来越接近这个限制条件。
纯C语言:递归二进制转十进制源码分享
09-04
在这个二进制转十进制的例子中，递归的核心在于从最高位到最低位依次处理每一位二进制数字，并累加它们的权重。 代码中定义了一个名为`change`的函数，它接受三个参数：`n`(当前处理的位数)，`sum`(累加的十进制值)...
c++递归实现十进制数转二进制（输入式
12-06
数据结构，递归实现十进制数转二进制数，C++实现，可多次输入数
【数据分析】时间序列 递归量化分析（相空间重构、递归矩阵、递归图模式、交叉递归图、递归量化分析）
风高秋月白，雨霁晚霞红
08-24 2183
递归量化分析。
数组相关题目
a2231476020的博客
03-07 605
文章目录一、数组实现栈二、数组实现队列三、稀疏数组四、数组中的最大差值01. 两数之和04. 有序数组的中位数11. 盛最多水的容器15. 三数之和26. 删除排序数组中多余重复元素27. 删除数组中指定的元素53. 最大子序和74. 搜索二维矩阵88. 合并两个有序数组121. 买卖股票的最佳时机1122. 买卖股票的最佳时机2169. 多数元素189. 旋转数组_和恢复229. 求众数 II（...
布隆过滤器
a2231476020的博客
02-27 520
如果一个黑名单网站包含100亿个黑名单网页，每个网页最多占64B，设计一个系统，判断当前的URL是否在这个黑名单当中，要求额外空间不超过30GB，允许误差率为万分之一。 布隆过滤器其中重要的实现就是位图的实现，也就是位数组，并且在这个数组中每一个位置只占有1个bit，而每个bit只有0和1两种状态。如上图bitarray所示！bitarray也叫bitmap，大小也就是布隆过滤器的大小。 假设一...
排序算法的应用
a2231476020的博客
01-06 464
一、利用归并排序求小和 public class MergeSortSmallSum { public static void main(String[] args) { int[] arr = {1, 3, 4, 2, 5}; System.out.println(mergeSort(arr, 0, arr.length - 1)); } ...
二分法相关题目
a2231476020的博客
03-01 453
704. 给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。 class Solution { /** * 二分法模板 * @param arr * @param target * @return */ publ...
字符串相关题目
a2231476020的博客
03-07 417
3. 无重复字符的最长子串 public static int lengthOfLongestSubstring(String s) { int n = s.length(), ans = 0; Map<Character, Integer> map = new HashMap<>(); for (int end = 0, start = 0; e...
排序算法总结
a2231476020的博客
03-08 333
文章目录一、快速排序二、归并排序2.1 求数组的小和2.1 求数组的逆序对三、堆排序四、插入排序 一、快速排序 public class QuickSort { public static void main(String[] args) { int[] arr = {6, 3, 5, 4, 9, 1, 7, 8, 2}; quickSort(arr, 0...
八进制转十进制递归
最新发布
08-07
我们使用递归方法将八进制数转换为十进制数。基本思路是：从八进制数的最高位（最左边的数字）开始，每次处理一位数字，将其乘以8的相应次幂，然后与后续递归结果相加。 递归函数设计： 设我们有一个八进制数字...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值