算法通关村第七关——一篇理解递归（青铜）

最新推荐文章于 2024-05-30 16:17:47 发布
最新推荐文章于 2024-05-30 16:17:47 发布
阅读量77 收藏
点赞数
分类专栏： 数据结构 算法 文章标签： 算法 笔记 java 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Hai_Helloyou/article/details/132162141
版权

算法通关村第七关——一篇理解递归（青铜）

递归的特征

递归是一种在计算机科学中经常使用的重要技术，它能够解决许多问题。本文将对递归的特征进行深入探讨，并通过适当的图示来进行解释。

首先，我们来了解什么是递归。递归是指一个函数在其定义中调用自身的过程。简而言之，递归就是通过把一个大问题不断地分解为更小的子问题来解决问题的方法。

递归有以下几个特征：

  1. 基本情况：递归函数必须有一个基本情况，即递归终止条件。这是因为如果没有终止条件，递归就会无限地进行下去，导致堆栈溢出。基本情况通常是最小的、不需要再次递归的情况。
  2. 问题规模缩小：递归函数必须能够将原问题转化为一个或多个规模更小的子问题。这是通过参数的改变来实现的。每次递归调用都会使问题的规模减小，直到达到基本情况。
  3. 递归调用：递归函数在其定义中调用自身。这是递归的核心部分，通过递归调用来解决问题。在每次递归调用中，函数的参数会发生变化，这样就能处理不同的子问题。
  4. 合并结果：递归函数在解决完所有子问题后，需要将各个子问题的结果合并得到最终的解。这是通过递归函数的返回值来实现的。每次递归调用都会返回一个结果，这些结果最终会被合并起来。

例子讲解：

那么我用一个例子来讲解递归的这个特征：

让我们以计算阶乘为例来说明递归的特征。

假设我们要计算一个整数n的阶乘，可以使用递归函数来解决。

  1. 首先，我们需要定义递归函数。在这个例子中，我们可以定义一个名为factorial的函数，它接受一个整数n作为参数，并返回n的阶乘。

  2. 其次，我们需要确定基本情况。对于阶乘来说，最基本的情况是当n等于0或1时，阶乘的结果都是1。所以我们可以将基本情况定义为：当n等于0或1时，直接返回1。

  3. 接下来，我们需要缩小问题的规模。在计算阶乘时，我们可以将问题转化为计算(n-1)的阶乘，然后再将结果乘以n。所以我们可以通过递归调用来缩小问题的规模。

  4. 最后，我们需要将各个子问题的结果合并得到最终的解。在这个例子中，我们可以将递归调用的结果乘以n，然后返回。

下面是一个简单的Java代码实现：

public class Factorial {
    public static int factorial(int n) {
        // 基本情况
        if (n == 0 || n == 1) {
            return 1;
        }
        
        // 缩小问题规模，并递归调用
        int result = factorial(n - 1);
        
        // 合并结果
        return result * n;
    }
    
    public static void main(String[] args) {
        int n = 5;
        int result = factorial(n);
        System.out.println(result);
    }
}

在这个例子中，我们调用factorial(5)，首先判断基本情况，由于n不等于0或1，所以将问题转化为计算factorial(4)的结果。然后继续递归调用，直到达到基本情况。

递归调用的过程如下图所示：

factorial(5) -> factorial(4) -> factorial(3) -> factorial(2) -> factorial(1)
   |               |               |               |               |
   V               V               V               V               V
return 120      return 24       return 6        return 2         return 1

最终，我们将各个子问题的结果合并得到最终的解：5 * 4 * 3 * 2 * 1 = 120，所以factorial(5)的结果是120。

通过这个例子，我们可以看到递归函数具有基本情况、问题规模缩小、递归调用和合并结果这几个特征。在实际编程中，可以根据具体问题的特点使用递归来解决。

如何写递归

例子1：计算斐波那契数列

好的，下面将逐步详细讲解递归算法的实现：

  1. 定义递归函数的参数和返回值：
public int fibonacci(int n) {
    //...
}

这里定义了一个递归函数fibonacci，它接受一个整数参数n，并返回斐波那契数列的第n项。

  1. 定义递归的结束条件：
if (n == 0 || n == 1) {
    return n;
}

在上述代码中，判断n是否为0或1，如果是，则直接返回n。这表示当n为0或1时，递归不再继续执行，而是直接返回结果。

  1. 缩小问题规模：
int result = fibonacci(n - 1) + fibonacci(n - 2);

在这段代码中，通过调用自身来求解斐波那契数列的前两项的和。通过将问题规模缩小，即通过计算第n-1项和第n-2项的和，来求解第n项。

  1. 调用递归函数：
int result = fibonacci(n - 1) + fibonacci(n - 2);

在上述代码中，通过调用递归函数fibonacci，传入参数n-1和n-2，来求解第n项。

  1. 处理递归结果：
return result;

最后，在递归函数中通过返回变量result来返回计算得到的第n项的值。

综合起来，完整的代码如下：

public class Fibonacci {
    public int fibonacci(int n) {
        // 递归结束条件
        if (n == 0 || n == 1) {
            return n;
        }
        
        // 调用递归函数
        int result = fibonacci(n - 1) + fibonacci(n - 2);
        
        // 处理递归结果
        return result;
    }
}

这个递归算法通过不断调用自身，将求解问题的规模从n缩小到n-1和n-2，直到达到递归结束条件为止。

例子2：计算阶乘为例

当然，接下来我们将以经典的例子——计算阶乘为例，详细讲解递归算法的步骤：

  1. 定义递归函数的参数和返回值：
public int factorial(int n) {
    //...
}

这里定义了一个递归函数factorial，它接受一个整数参数n，并返回n的阶乘。

  1. 定义递归的结束条件：
if (n == 0 || n == 1) {
    return 1;
}

在上述代码中，判断n是否为0或1，如果是，则直接返回1。这表示当n为0或1时，递归不再继续执行，而是直接返回结果1。

  1. 缩小问题规模：
int result = n * factorial(n - 1);

在这段代码中，通过调用自身来求解n的阶乘。通过将问题规模缩小，即通过计算n * (n-1)!，来求解n!

  1. 调用递归函数：
int result = n * factorial(n - 1);

在上述代码中，通过调用递归函数factorial，传入参数n-1，来求解n的阶乘。

  1. 处理递归结果：
return result;

最后，在递归函数中通过返回变量result来返回计算得到的n的阶乘的值。

综合起来，完整的代码如下：

public class Factorial {
    public int factorial(int n) {
        // 递归结束条件
        if (n == 0 || n == 1) {
            return 1;
        }
        
        // 调用递归函数
        int result = n * factorial(n - 1);
        
        // 处理递归结果
        return result;
    }
}

这个递归算法通过不断调用自身，将求解问题的规模从n缩小到n-1，直到达到递归结束条件为止。通过乘以n来计算阶乘，最终得到结果。

例子3：二叉树的遍历

当然，还可以举一个例子来讲解递归算法的实现。这次我们以二叉树的遍历为例，详细讲解步骤：

假设有如下定义的二叉树节点类：

class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;
    
    TreeNode(int val) {
        this.val = val;
    }
}
  1. 定义递归函数的参数和返回值：
public void inorderTraversal(TreeNode root) {
    //...
}

这里定义了一个递归函数inorderTraversal，它接受一个二叉树的根节点作为参数，没有返回值。

  1. 定义递归的结束条件：
if (root == null) {
    return;
}

在上述代码中，判断根节点是否为空，如果是，则直接返回。这表示当遍历到空节点时，递归不再继续执行，而是直接返回。

  1. 缩小问题规模：
inorderTraversal(root.left);
System.out.println(root.val);
inorderTraversal(root.right);

在这段代码中，通过调用自身来遍历左子树和右子树。通过将问题规模缩小，即分别遍历左子树和右子树，来遍历整个二叉树。

  1. 调用递归函数：
inorderTraversal(root.left);

在上述代码中，通过调用递归函数inorderTraversal，传入参数root.left，来遍历左子树。

  1. 处理递归结果：
System.out.println(root.val);

在递归函数中，对于每个节点的值进行处理，可以通过打印节点的值，来实现中序遍历。

综合起来，完整的代码如下：

public class BinaryTreeTraversal {
    public void inorderTraversal(TreeNode root) {
        // 递归结束条件
        if (root == null) {
            return;
        }
        
        // 调用递归函数
        inorderTraversal(root.left);
        System.out.println(root.val);
        inorderTraversal(root.right);
    }
}

这个递归算法通过不断调用自身，将二叉树的遍历问题转化为对左子树和右子树的遍历问题，直到达到递归结束条件为止。通过打印节点的值，实现了中序遍历。

怎么看懂递归代码

当你要理解递归代码时，可以按照以下步骤来进行：

  1. 理解递归函数的功能和作用：首先要明确递归函数的目的是什么，它要解决什么问题。在例子中，我们以计算斐波那契数列的第n项为例。

  2. 理解递归结束条件：找到递归函数中的结束条件，即满足这个条件时不再继续递归执行，直接返回结果。在例子中，当n为0或1时，递归结束，直接返回n。

  3. 理解递归函数的调用过程：理解递归函数在每次调用时的具体操作。在例子中，每次调用fibonacci(n - 1)和fibonacci(n - 2)来求解前两项的和。

  4. 理解递归函数的参数传递：注意递归函数每次调用时传入的参数是如何发生变化的，这是问题规模缩小的关键。在例子中，每次传入的参数是n-1和n-2。

  5. 理解递归函数的返回值处理：了解递归函数每次调用后返回的结果如何被处理。在例子中，返回的结果通过相加得到最终的结果。

下面结合计算斐波那契数列的第n项的代码来一步步详细讲解：

public class Fibonacci {
    public int fibonacci(int n) {
        // 递归结束条件
        if (n == 0 || n == 1) {
            return n;
        }
        
        // 调用递归函数
        int result = fibonacci(n - 1) + fibonacci(n - 2);
        
        // 处理递归结果
        return result;
    }
}

假设要计算斐波那契数列的第5项，即调用fibonacci(5)。

  1. 首先进入fibonacci(5)函数。
  2. 因为5不满足递归结束条件，继续执行下面的代码。
  3. 首先调用fibonacci(4)，继续向下递归。
  4. fibonacci(4)不满足递归结束条件，继续执行下面的代码。
  5. 调用fibonacci(3)并向下递归。
  6. fibonacci(3)不满足递归结束条件，继续执行下面的代码。
  7. 调用fibonacci(2)并向下递归。
  8. fibonacci(2)不满足递归结束条件，继续执行下面的代码。
  9. 调用fibonacci(1)并向下递归。
  10. fibonacci(1)满足递归结束条件，直接返回1。

下面满足递归结束条件：

  1. 回到上一层递归，继续执行fibonacci(2)后面的代码。

  2. 调用fibonacci(0)并向下递归。

  3. fibonacci(0)满足递归结束条件，直接返回0。

  4. 回到上一层递归，继续执行fibonacci(2)后面的代码。

  5. 将fibonacci(1)的结果和fibonacci(0)的结果相加，得到结果1。

  6. 回到上一层递归，继续执行fibonacci(3)后面的代码。

  7. 将fibonacci(2)的结果和fibonacci(1)的结果相加，得到结果2。

  8. 回到上一层递归，继续执行fibonacci(4)后面的代码。

  9. 将fibonacci(3)的结果和fibonacci(2)的结果相加，得到结果3。

  10. 回到上一层递归，继续执行fibonacci(5)后面的代码。

  11. 将fibonacci(4)的结果和fibonacci(3)的结果相加，得到结果5。

  12. 最终返回结果5。

通过以上步骤，我们可以看到递归函数的调用过程，每次调用都在问题规模上做了缩小，直到满足递归结束条件为止。然后根据递归结果进行处理，最终得到计算斐波那契数列第n项的结果。

XiaoZhi-paperfly
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
算法图解——递归
01-07
如果使用递归，程序可能更容易理解” 基线条件和递归条件 编写递归函数时，必须告诉他停止的条件 基线条件：函数不再调用自己即停止 递归条件：调用自己 def countdown(i): print(i, end=' ') if i <= 1: # ...
java算法——汉诺塔经典的递归
07-15
汉诺塔——经典的递归 *实现移动函数 *递归实现汉诺塔函数
算法通关村第七关——理解递归（青铜）
m0_63497607的博客
09-04 43
递归的本质是方法调用，自身调用自身，系统维护了不同调用之间的保存和返回。如果观察递归代码的结构，如图所示：这个调用过程不能一直持续，一定要在满足某个要求之后返回结果，否则就会抛出 StackOverFlow 问题。1.执行时范围不断缩小。2.终止判断在调用之前。所以要先考虑什么情况下终止，再考虑递归的逻辑。
算法通关村第七关青铜挑战——一图理解递归
m0_74469506的博客
10-10 213
一分钟了解递归
算法通关村第8关——轻松搞定二叉树的反转（青铜）
Brime的博客
08-31 70
题解：对于此类问题，我们的解题思路在于先只考虑。，翻转这棵二叉树，并返回其根节点。给你一棵二叉树的根节点。
《算法通关村第一关——链表白银挑战笔记》
qwquu的博客
08-30 404
主要介绍链表基本的操作，可以借用Hash表来解决相同重复等问题，倒转链表可以考虑栈的数据结构，巧妙的使用双指针找到中间元素，使用双指针找到倒数第k个元素。
算法通关村第二关——链表反转笔记（青铜挑战）
Hai_Helloyou的博客
07-20 153
链表反转实现的详细过程，通过图与代码结合说明，本次包括递归的实现三要素结合代码和图详细的讲解
《算法通关村第一关——链表青铜挑战笔记》Java
WaterBird的博客
08-28 228
其实就是一个节点dummyNode，其next指针指向head。在算法中要获取head节点，或者从方法（函数）里返回的时候，则应使用dummyNode。另外注意，dummmyNode的值不会被使用，可以初始化为0或-1，它的作用只是用来处理首部节点。链表中，每个节点由值和指向下一个节点的地址组成，也称为结点。第一个节点称作头结点。知道了头结点就可以遍历整个链表。它在单项链表的基础上新增了对向前指向的结点。双向循环从前往后循环。双向链表从后往前递归。
《算法通关村第一关——链表青铜挑战笔记》
qwquu的博客
08-29 446
1.利用虚拟头节点保存第一个节点的地址，避免"黑瞎子掰苞米"的问题2.插入（删除）节点时要想好循环次数与插入（删除）位置的关系3.在遍历链表到尾部时，控制好边界，避免指向空。
算法通关村第六关——理解树的结构（青铜）
Hai_Helloyou的博客
08-01 78
定义二叉树定义树的原理与前面讲的链表本质上是一样的，只不过多了一个指针，如果是二叉树，只要在链表的定义上增加一个指针就可以了// 节点的数据 private BinaryTreeNode leftChild;// 左子节点 private BinaryTreeNode rightChild;// 右子节点 }本质上就是有两个引用，分别指向两个位置，为了便于理解，我们分别命名为左孩子和右孩子。如果是N叉树该如何定义呢？
算法通关村第一关——链表青铜挑战笔记
qq_49727819的博客
07-16 661
在中部添加元素:4 15 7 40，在7前面插入， 当cur.next==node(7)就停下来，此时cur.val==15，先new.next=node(15).next 再node(15).next=new 顺序不能错，先后再前。一个结点包含当前数据域，指向上一个结点的引用和指向下一个结点的引用。删除首部元素只需要head = head.next，head向前移动一次之后，原来的结点不可达，会被JVM回收。链表的实现形式很像方法的递归，结点套结点，每个结点包含数据域和指向下一个结点的引用。
什么是递归算法:对递归的理解
03-23
什么是递归算法:对递归的理解！递归算法是一种直接或者间接调用自身函数或者方法的算法。Java递归算法是基于Java语言实现的递归算法。递归算法的实质是把问题分解成规模缩小的同类问题的子问题， 　一、基本概念 　...
教你彻底学会递归——《进阶篇》
12-21
因此这一篇文章，我将通过一些经典的通过递归算法实现的实例来更深入的了解递归算法。 汉诺塔问题 汉诺塔（又称河内塔）问题是源于印度一个古老传说的益智玩具。大梵天创造世界的时候做了三根金刚石柱子，在一根...
算法面试通关40讲完整课件 22-24 分治、递归、回溯
07-06
算法面试通关40讲完整课件 22-24 分治、递归、回溯 算法面试通关40讲完整课件 22-24 分治、递归、回溯 算法面试通关40讲完整课件 22-24 分治、递归、回溯 算法面试通关40讲完整课件 22-24 分治、递归、回溯 算法面试...
Leecode---347：输出前k个高频元素（使用unordered_map）
最新发布
qq_41920323的博客
05-30 251
unordered_map实现输出前k个高频元素
算法训练营day41
stmfresher的博客
05-27 332
动态规划理论基础（主要就是确定动态规划的几个步骤）
算法每日一题（python,2024.05.24) day.6
L613Z的博客
05-27 462
数字比较型可以用双指针法寻找数字相同（或构成其他关系）的俩个数值（或其他类型），涉及到与数值有关的列表问题可以思考到sort()排序方法加以辅助。
一千题，No.0037（组个最小数）
2301_76783671的博客
05-29 593
给定数字 0-9 各若干个。你可以以任意顺序排列这些数字，但必须全部使用。目标是使得最后得到的数尽可能小（注意 0 不能做首位）。例如：给定两个 0，两个 1，三个 5，一个 8，我们得到的最小的数就是 10015558。输入在一行中给出 10 个非负整数，顺序表示我们拥有数字 0、数字 1、……整数间用一个空格分隔。10 个数字的总个数不超过 50，且至少拥有 1 个非 0 的数字。现给定数字，请编写程序输出能够组成的最小的数。在一行中输出能够组成的最小的数。
汉诺塔问题——递归算法
10-07
汉诺塔问题是一个经典的递归问题。它是一个益智游戏，目标是将一堆圆盘从一个柱子移动到另一个柱子，并且在移动过程中保持大盘子永远在小盘子上方。问题可以分解为三个子问题：将n-1个圆盘从起始柱子移动到辅助柱子，将最大的圆盘从起始柱子移动到目标柱子，然后再将n-1个圆盘从辅助柱子移动到目标柱子。通过递归调用自身来解决这些子问题，最终完成整个移动过程。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值