Java 算法

Java 算法 - 递归算法

目录

• Java 算法 - 递归算法
  • 1. 如何编写递归
    • 1.1 递归的条件
    • 1.2 如何编写递归代码
  • 2. 总结
    • 2.1 注意事项
    • 2.2 非递归改写
    • 2.3 递归调试

数据结构与算法之美目录(https://www.cnblogs.com/binarylei/p/10115867.html)

递归本质是借助栈的数据结构，加上一个简单的逻辑算法实现。

递归是一种应用非常广泛的算法，很多数据结构和算法都要用到递归，比如 DFS 深度优先搜索、前中后序二叉树遍历等等。所以，搞懂递归非常重要，否则，后面复杂一些的数据结构和算法学起来就会比较吃力。

我们以斐波那契数列分析一下递归算法。

# 斐波那契数列：后一个数等于前两个数之和
1 1 2 3 5 8 13 21 34 ...

1. 如何编写递归

1.1 递归的条件

究竟什么样的问题可以用递归来解决呢？只要同时满足以下三个条件，就可以用递归来解决：

1. 一个问题的解可以分解为几个子问题的解，这些分解后的子问题，除了数据规模不同，求解思路完全一样。

   何为子问题？子问题就是数据规模更小的问题。在斐波那契数列中，就是求出前两个数之和。

2. 根据分解后的子问题，写出递归公式。

   在斐波那契数列中，就是 f(n) = f(n -1) + f(n -2)。

3. 存在递归终止条件。

   把问题分解为子问题，把子问题再分解为子子问题，一层一层分解下去，不能存在无限循环，这就需要有终止条件。在斐波那契数列中，存在多个终止条件，也就是 f(1) = 1 和 f(2) = 1，这就是递归的终止条件。

1.2 如何编写递归代码

写递归代码的关键就是找到如何将大问题分解为小问题的规律，并且基于此写出递推公式，然后再推敲终止条件，最后将递推公式和终止条件翻译成代码。只要遇到递归，我们就把它抽象成一个递推公式，不用想一层层的调用关系，不要试图用人脑去分解递归的每个步骤。

public int fibonacci(int n) {
    if (n == 1 || n == 2) {
        return 1;
    }
    return fibonacci(n - 1) + fibonacci(n - 2);
}

2. 总结

2.1 注意事项

（1）警惕堆栈溢出

编写递归代码时，如果递归层次太深，会出现堆栈溢出。而堆栈溢出会造成系统性崩溃，后果会非常严重。

为什么递归代码容易造成堆栈溢出呢？函数调用会使用栈来保存临时变量。每调用一个函数，都会将临时变量封装为栈帧压入内存栈，等函数执行完成返回时，才出栈。系统栈或者虚拟机栈空间一般都不大。如果递归求解的数据规模很大，调用层次很深，一直压入栈，就会有堆栈溢出的风险。

我们又该如何预防堆栈溢出呢？我们可以通过限制递归调用的最大深度来解决堆栈溢出问题。但这种做法并不能完全解决问题，因为最大允许的递归深度跟当前线程剩余的栈空间大小有关，事先无法计算。如果实时计算，代码过于复杂，就会影响代码的可读性。

• 如果限制深度比较小，可以限制递归深度。比如 10、50，就可以用这种方法，否则这种方法并不是很实用。
• 如果限制深度比较大，就只能自己模拟一个栈，用非递归代码实现

（2）警惕重复计算

如上的斐波那契数列，计算 f(5) 时需要计算 f(4) 和 f(3)，计算 f(4) 又要计算 f(4) 和 f(2)，这样会造成大量的重复计算，效率非常低。我们可以将中间计算结果缓存起来，这样可以避免大量重复计算。

// 递归，动态规划。将计算的中间结果缓存起来。
public int fibonacci(int n) {
    return fibonacci(n, new HashMap<>());
}
private int fibonacci(int n, Map<Integer, Integer> resolved) {
    if (resolved.containsKey(n)) {
        return resolved.get(n);
    }
    
    int value;
    if (n == 1 || n == 2) {
        value = 1;
    } else {
        value = fibonacci(n - 1, resolved) + fibonacci(n - 2, resolved);
    }
    resolved.put(n, value);
    return value;
}

（3）警惕死循环

如果递归的数据出现 A-B-C-D-A，则会让递归陷入死循环中。

2.2 非递归改写

递归有利有弊，利是递归代码的表达力很强，写起来非常简洁；而弊就是空间复杂度高、有堆栈溢出的风险、存在重复计算、过多的函数调用会耗时较多等问题。所以，在开发过程中，我们要根据实际情况来选择是否需要用递归的方式来实现。

public int fibonacci(int n) {
    int num1 = 1;
    int num2 = 1;
    if (n == 1 || n == 2) return 1;

    for (int i = 3; i <= n; i++) {
        int tmp = num1;
        num1 = num2;
        num2 = tmp + num2;
    }
    return num2;
}

那是不是所有的递归代码都可以改为这种迭代循环的非递归写法呢？

笼统地讲，是的。因为递归本身就是借助栈来实现的，只不过我们使用的栈是系统或者虚拟机本身提供的，我们没有感知罢了。如果我们自己在内存堆上实现栈，手动模拟入栈、出栈过程，这样任何递归代码都可以改写成看上去不是递归代码的样子。但是这种思路实际上是将递归改为了 ”手动“ 递归，本质并没有变，而且也并没有解决前面讲到的某些问题，徒增了实现的复杂度。

2.3 递归调试

我们平时调试代码喜欢使用 IDE 的单步跟踪功能，像规模比较大、递归层次很深的递归代码，几乎无法使用这种调试方式。对于递归代码，你有什么好的调试方法呢？

1. 打印日志发现，递归值。
2. 结合条件断点进行调试。

调试递归就像写递归一样，不要被每一步的细节所困，重点在于确认递推关系与结束条件是否正确，用条件断点着重调试最初两步与最终两步即可。

推荐文章：

1. 《如何将递归调用转化为非递归代码》：https://mp.weixin.qq.com/s/Ki3WN2AJ5HhxxmaQ0lVh3Q

---

每天用心记录一点点。内容也许不重要，但习惯很重要！