递归与回溯2：一文搞懂递归

递归，大部分人都知道怎么回事，但是代码就是写不出来，所谓”你讲的都对，但我就是不会“。递归的本质仍然是方法调用，不过是自己调用自己。系统给我们维护了不同调用之间的保存和返回等功能。

这种例子在现实中也有很多的，例如有一个笑话：

从前啊，有座山，山上有座庙，庙里有个老和尚和一个小和尚在讲故事，老和尚对小和尚说：

从前啊，有座山，山上有座庙，庙里有个老和尚和一个小和尚在讲故事，老和尚对小和尚说：

从前啊，有座山，山上有座庙，庙里有个老和尚和一个小和尚在讲故事，老和尚对小和尚说：

·····

 如果看代码的结构，就像下面这个样子，前面的每一层都去一模一样地调下一层，不同的只是输入和输出的参数。

当然这个过程不能一直持续下去，一定要在满足某个要求之后返回结果的，所以递归里总是有一个终止的代码。例如阶乘的递归调用结构如下，到了1之后就开始不断返回了。 

1.递归的特征

递归的问题，我们经常感觉很晕，有一种方式就是画一个栈结构图，看看到底执行的时候什么东西被压栈的。后面的题目我们会不断训练这一点。仅仅靠栈来理解递归还是不够的，因为简单的递归谁都知道，但是稍微复杂一些的特别容易想不明白，而且即使给出代码也经常看不明白。那该如何学习递归比较好呢？

笔者总结了递归的几个典型的特征：

①执行时范围不断缩小，这样才能触底反弹

②终止判断在调用递归的前面，一般都在最前面

③自己写的时候从小到大递推。

理解这这经验可以辅助我们更好的理解递归，我们一条条来看：

【1】执行范围不断缩小

执行范围不断缩小，是什么意思呢？递归就是数学里的递推，设计递归一般就是数学里的寻找递推公式，例如阶乘的递推公式就是f(n)=n*f(n-1)，很明显一定是要触底之后才能反弹。再比如斐波那契数列的递归公式为f(n)=f(n-1)+f(n-2)，n也在不断缩小。这条规律可以辅助我们检查递推公式对不对。

再比如青蛙跳台阶的递推公式为：f(n)= f(n-1) + f(n-2)，哎！怎么和斐波那契数列一样？是的，就是一样。

范围缩小不一定只体现n的变化上，在树的递归中我们会大量使用类似这样的结构：

 int leftDepth = getDepth(node.left); // 左
 int rightDepth = getDepth(node.right); // 右 

每递归一次，都将范围缩小到当前节点的左子树或者右子树，范围也是在缩小。

【2】终止判断在调用递归的前面，一般都在最前面

终止判断在最前面，也就是下面这样：

public void recursion(参数0) { 
  if (终止条件) {
    return ;
  }

 recursion(参数1);
    print（root.value）
}

理解这条规律，可以降低我们编写递归方法的难度，终止判断条件至少要在递归的前面，为什么呢？例如下面这一个例子，很明显这样会一直递归下去，无法退出来，直到抛出堆栈溢出异常 (StackOverflowError)：

public void recursion(参数0) { 
   recursion(参数1);
  if (终止条件) {
    return ;
  }
}

实际一个方法里的递归调用可能不止一次，还会加一些逻辑处理，比如下面这样，但是终止的条件仍然是在前面。

 public void recursion(参数0) {
        if (终止条件) {
            return;
        }
        //可能有一些逻辑运算1
        recursion(参数1);
        // 可能有一些逻辑运算1
        recursion(参数2);
        // ......3
        recursion(参数n);
        // 可能有一些逻辑运算
    }

这一特点启示我们，假如要写递归了，可以先考虑清楚什么情况下要终止，这一点明白了，递归就完成一半了。后面我们分析递归的实现方法，每个题都有大量的篇幅在分析什么时候该让递归停止。

【3】写的时候从小到大递推

递归该怎么写呢？递归源自数学里的归纳法，这个在高中数学中学过，大致就是你先猜测出存在递归关系，f(n)=δf(n-1)，然后只你只要证明当n增加一个时，f(n+1)=δf(n)也是成立就说明你的猜测是对的。不过呢，我们写递归一般不需要证明，验证的时候也可以先选几个比较小的，再选择几个比较大的验证即可。

我们写递归的一个重要工作就是确定这个递推关系。那该如何猜测出递推关系呢？很明显从n=1，2，3开始写最简单。例如斐波那契序列为 1 1 2 3 5 8，...，我们很明显能够看到从n=3开始都满足f(n)= f(n-1) + f(n-2)，然后我们再选择3个更大的n来验证即可。

这个思路也是我们后面实现树的递归算法的重要法宝之一。不过在写的时候不仅仅要从小到大考虑，还可能要分情况讨论，我们后面遇到相关问题了再说。

确定递推公式无疑是最重要的问题，根据笔者的经验，最好先从小到大递推一下看看什么情况，不要上来就将n设置很大，因为我们大部人的抽象能力没那么好，直接写n的递推公式会非常容易和n-1的处理杂糅在一起。

我们还是从简单的开始一步步分析递归的过程。我们仍然以阶乘和斐波那契数列为例来看。斐波那契数列的是这样一个数列：1、1、2、3、5、8、13、21、34….，即第一项 f(1) = 1,第二项 f(2) = 1…..，很明显就是第 n 项目为 f(n) = f(n-1) + f(n-2)。求第 n 项的值是多少。

阶乘也一样：

n=1 f(1)=1
n=2 f(2)=2*f(1)=2
n=3 f(3)=3*f(2)=6
n=4 f(4)=4*f(3)=24
....

由此我们可以推测递推公式是f(n)=n*f(n-1)。大部分递归问题，不管是树还是什么 ，都可以从小到大逐步分析。必要的时候将能想到的情况都列举一下看看怎么做。这样能让我们逐步写出合理的递归程序。

2.如何写递归

从前面的分析我们可以看到，要写出递归，需要解决几个问题：

①递推公式是什么，这是递归的灵魂， 我们必须先明确了才可以下手。

②入参和出参是什么，怎么保证递归时入参能不断缩小。

③递归在什么情况下可以终止，此时要返回什么，先明确终止条件可以降低实现难度。

④将递推公式转换成方法调用，组装成完整的实现代码。

⑤怎么验证写的递归对不对。一般的方法我们debug一下就行，但是递归很难，debug几次之后可能自己就晕了，特别是再加上回溯过程就彻底歇菜。

这基本步骤是相辅相成的，顺序也不一定是上面的一二三四，但是我们可以不断思考这四个问题。我们已经明确了什么 还没明确什么 ，从而将问题步步拆解。

第一步：从小到大递推，分情况讨论

如上一节所述从小到头递推，可以大大降低编写难度，可以方便总结出递推公式什么 ，会有几种情况，这样也能总结出结束条件是什么。

第二步：明确结束条件，初步确定入参

我们说过递归里终止条件一定是靠前的，而大部分递归的终止条件不过是n最小开始触底反弹时的几种情况。例如n=0，n=1，必要的时候加个n=2时要返回哪种固定结果。例如对于1+2+3+..累加的话，终止条件就是

int f(int n){
    if(n ==0){
        return 0;
    }
}

你也可以这么写：

int f(int n){
    if(n ==1){
        return 1;
    }
}

因为n=0的时候白白递归一次，有和没有都行。但是阶乘的话就不行了，当 n = 1 时你就应该知道 f(1) = 1，也就是下面这样子：

// 算 n 的阶乘(假设n不为0)
int f(int n){
    if(n == 1){
        return 1;
    }
}

不能再让n=0，否则就都变成0了。

有时候需要考虑的终止条件不止一个，例如斐波那契数列的递推公式f(n) = f(n-1) + f(n-2)里，如果n=1时会出现f(2)=f(1)+f(0)，很明显这里是没有f(0)的，所以我们要将n==2也给限制住，所以结束条件是这样的：

int f(int n){
    if(n <=2){
        return 1;
    }
}

有些情况不一定是触底才开始反弹，而是达到某种要求就停止，这就是递归剪枝的核心思想。解决这类问题最直接的方式就是枚举，将可能的情况列举一下，再逐步优化。只有列举清楚了才可能将终止条件写完整，所以在面试的时候千万不要上来就写，而应该先和面试官讨论你的设计方案，不要害怕与面试官讨论！假如有明显的缺陷他甚至会提醒你的，所以这也是借力打力的一个技巧。

为什么说要初步确定入参和出参呢？平时写工程代码我们也会发现很多方法很难上来就将入参想清楚，都是先写 ，缺了什么再补，递归对此要求更高，不仅要满足当前需要，还要满足递归的需要，所以这个很难一下子想出来，我们可以先将能想到的参数都大胆的写上去，然后一边写一边改。笔者面试时一般第一次写的都非常随意，而且有大量的涂改，所以写完后会和面试官说，刚刚写的比较随意，我马上重抄一遍。重抄一遍的会比较工整，让别人能看清楚。一般面试官是允许你这么做的。

第三步：将等价关系变成方法调用，完成代码

同一个问题，不同的人实现差异可能会非常大，甚至只用一行就将所有操作都包含进去了。我们不用迷信那些骚操作，而应先分情况逐个先写出来，之后再看能否精简优化，不要步子太大，否则会扯到Dan。这里的阶乘和斐波那契数列还是能比较容易找到的，继续完善我们的代码，如下：

// 算 n 的阶乘(假设n不为0)
int f(int n){
    if(n ==1){
        return n;
    }
    // 把 f(n) 的等价操作写进去
    return f(n-1) * n;
}

斐波那契数列的为：

int f(int n){
    // 1.先写递归结束条件
    if(n <= 2){
        return 1;
    }
    // 2.接着写等价关系式
    return f(n-1) + f(n - 2);
}

这么说没什么问题，但是真正想清楚还是有些难度的。每次写递归的时候，你就强迫自己试着去从这几个方面来考虑。后面我们会不断通过题目来感受上面这个过程。

第四步 从大到小 画图推演

如果时间还够，特别是平时自己练习的时候，可以再画图推演一遍。递归的代码很难调试，因为走几步之后自己就晕了。笔者总结发现一个比较好的方式是从大到小，画图推演一下。

我们知道递归本质上仍然是递归调用，我们仍然可以按照方法调用的方式来分析我们写的对不对。下面这个图完整的表示了求阶乘的调用关系过程，你会发现递归不过是被调用的方法写四次，然后n逐步减小，一直向下调用，这就是递进的过程。到底之后，也就是满足结束条件之后就开始返回了。每次的n自然是不一样的，所以回归的过程中重新拿到当前这一层n的值完成计算即可。

通过这个图你会发现所谓的递归与普通的方法调用没什么区别，只不过我们平时是f(n)里调用g(m)，这里是f(n)继续调用自己而已，没有任何神秘的。