数据结构与算法系列——递归

递归的理解

在学习数据结构和算法的过程中，递归可能是比较难理解的一个知识点，每次都试着用自己的大脑去把一步一步去想清楚，结果最后把自己都绕晕了。

我们很多人都遇到过这种情况，读源码的时候，我们想弄清楚一个方法的具体实现，然后跟进去发现里边还有一个方法，然后我们又跟到新的方法里边，结果发现里边还有另一个新的方法……这样跟了一层又一层，终于到了最后一层没有再调用其他的方法，然后我们再一层一层返回去，最终弄明白了最初想了解的方法的作用（实际中这种方式是不推荐的，因为嵌套很多层，最后搞得头都大了，却忘记了最初是要干什么）。其实这就是一个递归的过程，通过一层一层的去了解方法的作用，然后到最后再一层一层返回去，明白最初方法的作用。

到这里，我想大家其实对递归也有一定了解了。其实递归就是可以把原来一个大型复杂的任务，分解成一个或几个与原任务有相类似求解方法的小任务，然后最后有一个终止条件。

递归的条件

由此我们可以总结出几个使用递归需要满足的条件：

• 一个问题可以分解为一个或几个子问题
• 子问题和原来问题的求解方式相同，只是规模比原问题小
• 存在终止条件，否则会变成无限循环

举一个例子

前几天刷剑指offer题库，碰到了好多题都可以用递归的方法计算。比如其中一个经典的跳台阶问题。

题目描述

一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法（先后次序不同算不同的结果）。

解题思路

每次跳台阶都有两个选择，要么跳1级，要么跳2级。只有1级台阶的时候只有跳1级1种跳法，有2级时有每次1级1级跳两次和直接跳2级两种跳法，当有3级台阶的时候，我们可以从第2级跳1级到第3级，也可以从第1级跳2级到第3级，所以3级台阶的总跳法，就是1级台阶的总跳法和2级台阶的总跳法的总和，由此我们就发现了一个规律从3级之后的算法为 f(n)=f(n-1)+f(n-2)，发现我们要求得结果符合斐波那契数列。所以我们想知道 n 级台阶总共有多少跳法，只要将 n-1 的跳法加上 n-2 的跳法就可以了。

代码实现

public class Solution {
    public int JumpFloor(int target) {
        if(target<3){
            return target;
        }
        return JumpFloor(target - 1) + JumpFloor(target - 2);
    }
}

怎么使用递归

我们现在也对递归有一定的了解了，那递归该怎么用呢？其实在上边例子中其实已经给出了答案。首先，我们要通过规律推导出递归的公式，然后找到递归的终止条件，然后把公式转化为代码就很容易了。就比如上边例子中的解题思路中就是这一过程的实现。

有人觉得递归难以理解，可能是走入误区，就像我一开始举得读源码的例子。一定要在脑子里把递归展开，一层一层去调用，然后一层层的返回，试图去弄明白每一个过程，这其实就有点钻牛角尖了，尤其是当一个问题分解成好几个子问题，然后嵌套层数比较多的时候，我们的大脑是没办法把每一个过程都能想出来的。相反计算机却很擅长这种重复的事情，所以我们没必要在大脑中去分解每一个步骤，我们只需要找到规律公式和终止条件，剩下的交给计算就行了。

使用递归需要注意

在实际程序设计的时候，我们使用递归的时候要注意几个问题。

栈溢出问题

我们都知道函数调用时会用栈来保存临时变量，每调用一个函数，都会将临时变量封装为栈帧压入内存栈，等函数执行结束才出栈。一般系统栈和虚拟机栈都不是很大，当递归嵌套的次数较多的时候，就会有栈溢出的风险。

所以如果递归的次数比较小的时候我们可以考虑使用递归，否则我们就要考虑其他的方法。

重复计算问题

还是以跳台阶的例子来说明，假如我们要计算 5 级台阶有多少种跳法，我们用我们推导出来公式来计算，f(5)=f(4)+f(3)，然后我们分别要求 f(4)=f(3)+f(2)，f(3)=f(2)+f(1)，我们可以看到在求解 f(5) 的时候我们计算过 f(3)，而在计算 f(4) 的时候我们又计算了一遍 f(3)，同样 f(2) 也被计算了多次，这就是重复计算的问题。

我们可以用散列表来储存已经计算过的 f(n)，然后在每次计算的时候先去散列表里查有没有被计算过，如果有那么直接使用；如果没有那把计算后的值存到散列表中，这样就能避免重复计算的问题。

我们按这个办法修改一下上边例子的代码。

public class Solution {
    Map resultMap = new HashMap();
    public int JumpFloor(int target) {
        if(target < 3){
            return target;
        }
        if(resultMap.containsKey(target)){
            return resultMap.get(target);
        }
        int result = JumpFloor(target - 1) + JumpFloor(target - 2);
        resultMap.put(target, result);
        return result;
    }
}

效率问题

由于多层递归的嵌套，所以会多次调用函数，当次数达到一定数量的时候，就会有很高的时间成本。在空间复杂度上，因为递归每调用一次就会在栈中保存一次现场数据，所以每次都要产生这种额外的开销。

所以，虽然递归的代码看上去非常简洁，但是也会有很多问题，我们在实际使用的时候一定要注意递归可能会带来的问题。