关于递归的一些经验

可能不少人在大一的时候，就已经接触递归了，不过，我相信不少人刚开始接触递归的时候，都是一脸懵逼的，由于我当初也是懵逼，递归给个人感受就是真的太神奇太奇妙了！

可能也有一大部分人知道递归，也能看的懂递归，但在实际作题过程当中，殊不知道怎么使用，由于不容易理解因此有时候还容易被搞晕。所以，我想写一篇文章，谈谈个人一些经验，或许，可以给大家带来一些帮助。这里我就从易到难开始讲解。

递归的三大要素

第一要素：明确你这个函数想要干什么

对于递归，我认为很重要的一件事就是，这个函数的功能是什么，它要完成什么样的一件事，而这个，是彻底由你本身来定义的。即，咱们先无论函数里面的代码是什么，而是要先明白，这个函数是要用来干什么。

例如，我定义了下面这个函数：

// 算 n 的阶乘(假设n不为0)
int f(int n) {

}

这个函数的功能是算 n 的阶乘。好了，咱们已经定义了一个函数，而且定义了它的功能是什么，接下来咱们看第二要素。

第二要素：寻找递归结束条件

所谓递归，就是会在函数内部代码中，调用这个函数自己，因此，咱们必需要找出递归的结束条件，否则的话，会一直调用本身，致使栈溢出。也就是说，咱们须要找出当参数为某个值时，递归结束，而后直接把结果返回，这个时候咱们必须能根据这个参数的值，可以直接知道函数的结果是什么。

例如，上面那个例子，当 n = 1 时，f(1) = 1。完善咱们函数内部的代码，把第二要素加进代码里面，以下:

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

有人可能会说，当 n = 2 时，那咱们能够直接知道 f(n) 等于多少啊，那我能够把 n = 2 做为递归的结束条件吗？

固然能够，只要你以为当参数为什么值时，可以直接知道函数的结果的时候，那么你就能够把这个参数做为结束的条件，因此下面这段代码也是能够的：

// 算 n 的阶乘(假设n>=2)
int f(int n) {
    if(n == 2) 
        return 2;
}

注意我代码里面写的注释，假设 n >= 2，由于若是 n = 1时，会被漏掉，当 n <= 2时，f(n) = n，因此为了更加严谨，咱们能够写成这样：

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

第三要素：找出函数的等价关系式

第三要素就是咱们要不断缩小参数的范围，缩小以后，咱们能够经过一些辅助的变量或操做，使原函数的结果不变。

例如，f(n) 这个范围比较大，咱们可让 f(n) = n * f(n - 1)。这样，范围就由 n 变成了 n-1 ，范围变小了，而且为了让原函数f(n)的结果不变，咱们须要让 f(n-1) 乘以 n。

说白了，就是要找到原函数的一个等价关系式，f(n) 的等价关系式为 n * f(n - 1)，即f(n) = n * f(n - 1)。

找出了这个等价，继续完善咱们的代码，咱们把这个等价式写进函数里。以下：

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

至此，递归三要素都已经写进了代码里，因此这个 f(n) 功能的内部代码咱们已经写好了。

这就是递归最重要的三要素，每次作递归的时候，你就强迫本身试着去寻找这三个要素。

下面来看几个案例。

案例一：斐波那契数列

斐波那契数列的是这样一个数列：一、一、二、三、五、八、1三、2一、34….，即第一项 f(1) = 1,第二项 f(2) = 1…..,第 n 项目为 f(n) = f(n-1) + f(n-2)。求第 n 项的值是多少。

一、递归函数的功能

假设 f(n) 的功能是求第 n 项的值，代码以下：

int f(int n) {

}

二、找出递归结束的条件

显然，当 n = 1 或者 n = 2 ,咱们能够轻易着知道结果 f(1) = f(2) = 1。因此递归结束条件能够为 n <= 2。代码以下：

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

三、找出函数的等价关系式

题目已经把等价关系式给咱们了，因此咱们很容易就可以知道 f(n) = f(n - 1) + f(n - 2)。

因此最终代码以下：

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

搞定，是否是很简单？

案例二：小青蛙跳台阶

一只青蛙一次能够跳上1级台阶，也能够跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法。

一、递归函数的功能

假设 f(n) 的功能是求青蛙跳上一个n级的台阶总共有多少种跳法，代码以下：

int f(int n) {

}

二、找出递归结束的条件

我说了，求递归结束的条件，你直接把 n 压缩到很小很小就好了，由于 n 越小，咱们就越容易直观着算出 f(n) 的多少，因此当 n = 1时，你知道 f(1) 为多少吧？够直观吧？即 f(1) = 1。代码以下：

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

三、找出函数的等价关系式

每次跳的时候，小青蛙能够跳一个台阶，也能够跳两个台阶，也就是说，每次跳的时候，小青蛙有两种跳法。

第一种跳法：第一次跳了一个台阶，那么还剩下n-1个台阶还没跳，剩下的n-1个台阶的跳法有f(n-1)种。

第二种跳法：第一次跳了两个台阶，那么还剩下n-2个台阶还没，剩下的n-2个台阶的跳法有f(n-2)种。

因此，小青蛙的所有跳法就是这两种跳法之和了，即 f(n) = f(n - 1) + f(n - 2)。至此，等价关系式就求出来了。因而写出代码：

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

    return f(n - 1) + f(n - 2);
}

你们以为上面的代码对不对？

答是不大对，当 n = 2 时，显然会有 f(2) = f(1) + f(0)。咱们知道，f(0) = 0，按道理是递归结束，不用继续往下调用的，但咱们上面的代码逻辑中，会继续调用 f(0) = f(-1) + f(-2)。这会致使无限调用，进入死循环。

这也是我要和大家说的，关于递归结束条件是否够严谨的问题，有不少人在使用递归的时候，因为结束条件不够严谨，致使出现死循环。也就是说，当咱们在第二步找出了一个递归结束条件的时候，能够把结束条件写进代码，而后进行第三步，可是须要注意的是，当咱们第三步找出等价函数以后，还得再返回去第二步，根据第三步函数的调用关系，会不会出现一些漏掉的结束条件。就像上面，f(n-2)这个函数的调用，有可能出现 f(0) 的状况，致使死循环，因此咱们把它补上。代码以下：

int f(int n) {
    //f(0) = 0,f(1) = 1，等价于 n<=1时，f(n) = n。
    if(n <= 1)
        return n;

    ruturn f(n - 1) + f(n - 2);
}

有人可能会说，我不知道个人结束条件有没有漏掉怎么办？别怕，多练几道就知道怎么办了。

案例3：反转单链表。

反转单链表。例如链表为：1->2->3->4，反转后的链表为： 4->3->2->1

链表的节点定义以下：

class Node{
    int data;
    Node next;
}

一、递归函数的功能

假设函数 reverseList(head) 的功能是反转单链表，其中 head 表示链表的头节点。代码以下：

Node reverseList(Node head) {

}

2. 寻找结束条件

当链表只有一个节点，或者若是是空表时，直接把 head 返回。代码以下：

Node reverseList(Node head) {
    if(head == null || head.next == null) 
        return head;
}

3. 寻找等价关系

这个题目的等价关系不像 n 是个数值那样，比较容易寻找。可是我告诉你，在等价关系中，必定是范围不断在缩小的。对于链表来讲，就是链表的节点个数不断在变少。因此，若是你实在找不出，你就先对 reverseList(head.next) 递归走一遍，看看结果是怎样的。例若有链表节点以下：

咱们就缩小范围，先对 2->3->4递归下试试，即代码以下

Node reverseList(Node head) {
    if(head == null || head.next == null)
        return head;
    
    // 咱们先把递归的结果保存起来，先不返回，由于咱们还不清楚这样递归是对仍是错
    Node newList = reverseList(head.next);
}

咱们在第一步的时候，就已经定义了 reverseList函数的功能：把一个单链表反转。所以，咱们对 2->3->4反转以后的结果应该是这样的：

咱们把 2->3->4 递归成 4->3->2。不过，1 这个节点咱们并无去碰它，因此 1 的 节点仍然是链接2节点。

接下来呢？该怎么办？

其实，接下来就简单了，咱们接下来只须要把节点 2 的 next 指向 1，而后把 1 的 next 指向 null,不就好了？，即经过改变 newList 链表以后的结果以下：

也就是说，reverseList(head) 等价于 reverseList(head.next) + 改变一下1，2两个节点的指向。好了，等价关系就这样找出来了，代码以下(有详细的解释)：

//用递归的方法反转链表
 public static Node reverseList2(Node head) {
     // 1.递归结束条件，当head只有一个节点或为空时，直接返回head
     if (head == null || head.next == null) 
              return head;
          
         // 递归反转 子链表
         Node newList = reverseList2(head.next);
         // 改变 1，2节点的指向
         // 经过 head.next获取节点2
         Node t1  = head.next;
         // 让 2 的 next 指向 1
         t1.next = head;
         // 1 的 next 指向 null
         head.next = null;
         // 最后把反转以后的链表直接返回
         return newList;
    }

这道题的第三步看的很懵？正常，由于你作仍是太少，可能没有想到还能够这样，多练几道就能够了。可是，我但愿经过这三道题，给了你之后用递归作题时的一些思路，你之后作题能够按照我这个模式去想。经过一篇文章是不可能掌握递归的，还得多练，我相信，只要你认真看个人这篇文章，多看几回，必定能找到一些思路！

接下来我讲讲有关递归的一些优化。

有关递归的一些优化思路

1. 考虑是否重复计算

若是你使用递归的时候不进行优化，是有很是多的子问题被重复计算的。

啥是子问题？ f(n-1),f(n-2)….就是 f(n) 的子问题了。

例如对于案例2那道题，f(n) = f(n-1) + f(n-2)。递归调用的状态图以下：

当进行递归计算的时候，重复计算了两次 f(4)，五次 f(2）...... 这是很是恐怖的，n 越大，重复计算的就越多，因此咱们必须进行优化。

如何优化？通常咱们能够把咱们计算的结果保存起来，例如把 f(4) 的计算结果保存起来，当再次要计算 f(4) 的时候，咱们先判断一下，以前是否计算过，若是计算过，直接把 f(4) 的结果取出来就能够了，没有计算过的话，再递归计算。

用什么保存呢？能够用数组或者 HashMap 保存，咱们用数组来保存把，把 n 做为咱们的数组下标，f(n) 做为值，例如 arr[n] = f(n)。f(n) 尚未计算过的时候，咱们让 arr[n] 等于一个特殊值，例如 arr[n] = -1。

当咱们要判断的时候，若是 arr[n] = -1，则证实 f(n) 没有计算过，不然， f(n) 就已经计算过了，且 f(n) = arr[n]。直接把值取出来就好了。代码以下：

// 咱们假定arr数组已经初始化好了
int f(int n) {
    if(n <= 1)
        return n;
    
    //先判断有没计算过
    if(arr[n] != -1)
        //计算过，直接返回
        return arr[n];
    else {
        // 没有计算过，递归计算,而且把结果保存到arr数组里
        arr[n] = f(n - 1) + f(n - 1);
        reutrn arr[n];
    }
}

也就是说，使用递归的时候，必需要考虑有没有重复计算，若是重复计算了，必定要把计算过的状态保存起来。

2. 考虑是否能够自底向上

对于递归问题，咱们通常都是从上往下递归的，直到递归到最底，再一层一层着把值返回。

不过，有时候当 n 比较大的时候，例如当 n = 10000 时，那么必需要往下递归10000层直到 n <=1 才将结果慢慢返回，若是n太大的话，可能栈空间会不够用。

对于这种状况，其实咱们是能够考虑自底向上的作法的。例如我知道f(1) = 1和f(2) = 2，那么咱们就能够推出 f(3) = f(2) + f(1) = 3。从而能够推出f(4),f(5)等直到f(n)。所以，咱们能够考虑使用自底向上的方法来取代递归，代码以下：

public int f(int n) {
       if(n <= 2)
           return n;
    
       int f1 = 1;
       int f2 = 2;
       int sum = 0;

       for (int i = 3; i <= n; i++) {
           sum = f1 + f2;
           f1 = f2;
           f2 = sum;
       }
       return sum;
   }

这种方法被称之为递推，也叫迭代循环。

最后总结

其实，递归不必定老是从上往下，也是有不少是从下往上的，例如 n = 1 开始，一直递归到 n = 1000，例如一些排序组合。对于这种从下往上的，也是有对应的优化技巧，不过，我就先不写了，后面再慢慢写。