递归

扫码关注公众号，获取更多内容

 

目录

一、什么是递归？

二、递归需要满足的三个条件

三、如何编写递归代码？

四、递归代码要警惕堆栈溢出

五、递归代码要警惕重复计算

---

一、什么是递归？

程序调用自身的编程技巧称为递归，光看定义可能不是很理解，我们举一个例子：

周末你和女朋友去电影院看电影，女朋友问你现在坐在第几排，电影院里太黑看不清，这时候怎么办？

这时候递归就可以派上用场了，你开始问前面一排的人，他是第几排，你只要在他的数字上加1，就知道自己在第几排了，但是前面的人也不知道自己在第几排，所以他也去问前面的人，就这样一排一排的往前问，直到问到第一排的人说自己在第一排，然后再这样一排一排把数字传回来，直到你前面的人告诉他在哪一排，于是你就知道答案了。

上述是一个非常标准的递归求解问题分解过程，去的过程叫“递”，回来的过程叫“归”，上述例子我们用递归公式将它表示出来：

f(n)=f(n-1)+1 其中，f(1)=1

f(n)表示你想知道自己在哪一排，f(n-1)表示前面一排所在的排数，f(1)=1表示第一排的人知道自己在第一排，有了这个递推公式，我们可以实现如下的递归代码：

function f1(n) {
    if (n === 1) return 1
    return f1(n - 1) + 1
}

 

二、递归需要满足的三个条件

1、一个问题的解可以分解为几个子问题的解

什么是子问题？子问题就是数据规模更小的问题，比如前面讲到的电影院的例子，你要知道，“自己在哪一排”的问题，可以分解为“前一排的人在哪一排”这样一个子问题。

2、这个问题与分解之后的子问题，除了数据规模不同，求解思路完全一样

比如前面电影院的那个例子，你求解“自己在哪一排”的思路，和前面一排人求解“自己在哪一排”的思路，是一模一样的。

3、存在递归终止条件

把问题分解成子问题，再把子问题分解成子子问题，一层一层分解下去，不能存在无限循环，这就需要终止条件，还是电影院的例子，第一排的人不需要再继续询问任何人，就知道自己在哪一排，也就是 f(1)=1，这就是递归的终止条件。

 

三、如何编写递归代码？

我们要抓住两个重点：写出递推公式，找到终止条件，之后将递推公式转化为代码就很简单了。

我们来看下面的例子：

假如这里有 n 个台阶，每次你可以跨 1 个台阶或者 2 个台阶，请问走这 n 个台阶有多少种走法？如果有 7 个台阶，你可以 2，2，2，1 这样子上去，也可以 1，2，1，1，2 这样子上去，总之走法有很多，那如何用编程求得总共有多少种走法呢？

仔细思考，我们可以根据第一步的走法把所有走法分为两类，第一类是第一步走了一个台阶，另一类是第一步走了两个台阶，所以n个台阶的走法就等于先走1阶后，n-1个台阶的走法加上先走2阶后，n-2个台阶的走法，用公式表示如下：

f(n) = f(n-1)+f(n-2)

有了递推公式后，我们来看终止条件，当只有（剩）一个台阶时，我们就不需要再递归了，只有一种走法，所以f(1) = 1，但只有这一个递归条件是不足够的，当n=2时，f(2) = f(1)+f(0)，如果只有一个递归终止条件f(1) = 1，那么f(2)就无法求解了，所以除了f(1) = 1这个终止条件外，还要有f(0) = 1这个终止条件，表示0个台阶有一种走法，不过这样子看起来不太符合逻辑，所以，我们可以把f(2) = 2作为一种终止条件，表示两个台阶有两种走法：每次一步，走两步或者每次两步，走一次。当n再增大时，我们上述的两个递归终止条件已经满足了。

我们把递归终止条件和刚刚得到的递推公式放到一起就是这样的：

f(1) = 1;
f(2) = 2;
f(n) = f(n-1)+f(n-2)

根据公式，转变为递归代码如下：

function f(n) {
    if (n === 1) return 1
    if (n === 2) return 2
    return f(n - 1) + f(n - 2)
}

总结上面的方法步骤：找到将大问题分解为小问题的规律 -> 基于此写出递推公式 -> 推敲终止条件 -> 将递推公式和终止条件翻译成代码。

编写递归代码的关键：只要遇到递归，我们就把它抽象成一个递推公式，不用想一层层的调用关系，不要试图用人脑去分解递归的每个步骤。

 

四、递归代码要警惕堆栈溢出

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

比如前面的讲到的电影院的例子，如果我们将系统栈或者 JVM 堆栈大小设置为 1KB，在求解 f(19999) 时便会出现如下堆栈报错（java代码）：

Exception in thread "main" java.lang.StackOverflowError

如何避免堆栈溢出呢？

我们可以通过在代码中限制递归调用的最大深度的方式来解决这个问题。递归调用超过一定深度（比如 1000）之后，我们就不继续往下再递归了，直接返回报错。还是电影院那个例子，我们可以改造成下面这样子，就可以避免堆栈溢出了。不过，我写的代码是伪代码，为了代码简洁，有些边界条件没有考虑，比如 n<=0。

let deep = 0

function f1(n) {
     deep++
     if (deep > 1000) throw new Error('超出最大调用深度')
     if (n === 1) return 1
     return f1(n - 1) + 1
}

但这种做法并不能完全解决问题，因为最大允许的递归深度跟当前线程剩余的栈空间大小有关，事先无法计算。如果实时计算，代码过于复杂，就会影响代码的可读性。所以，如果最大深度比较小，比如 10、50，就可以用这种方法，否则这种方法并不是很实用。

 

五、递归代码要警惕重复计算

除此之外，使用递归时还会出现重复计算的问题。刚才我讲的第二个递归代码的例子，如果我们把整个递归过程分解一下的话，那就是这样的：

从图中，我们可以直观地看到，想要计算 f(5)，需要先计算 f(4) 和 f(3)，而计算 f(4) 还需要计算 f(3)，因此，f(3) 就被计算了很多次，这就是重复计算问题。

为了避免重复计算，我们可以通过一个数据结构（比如散列表）来保存已经求解过的 f(k)。当递归调用到 f(k) 时，先看下是否已经求解过了。如果是，则直接从散列表中取值返回，不需要重复计算，这样就能避免刚讲的问题了。

按照上面的思路，我们来改造一下刚才的代码：

let map = new Map()

function f(n) {
    if (n === 1) return 1
    if (n === 2) return 2
    if (typeof map.get(n) !== "undefined") return map.get(n)
    let ret = f(n - 1) + f(n - 2)
    map.set(n, ret)
    return ret
}

除了堆栈溢出、重复计算这两个常见的问题。递归代码还有很多别的问题。

在时间效率上，递归代码里多了很多函数调用，当这些函数调用的数量较大时，就会积聚成一个可观的时间成本。在空间复杂度上，因为递归调用一次就会在内存栈中保存一次现场数据，所以在分析递归代码空间复杂度时，需要额外考虑这部分的开销，比如我们前面讲到的电影院递归代码，空间复杂度并不是 O(1)，而是 O(n)。

 

参考：数据结构与算法之美