数据结构与算法之美——递归——学习笔记

一、前言

        先说一下递归的几个常见应用：一是裴波那契数列，二是注册返佣金，找最终推荐人，三是青蛙跳台阶。

二、如何理解“递归”

        作者从它学习数据结构与算法的经历来看，作者认为有两个最难理解的知识点，一个是动态规划另一个就是递归。

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

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

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

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

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

        3、存在递归终止条件

        把问题分解为子问题，把子问题再分解为子子问题，一层一层分解下去，不能存在无限循环，这就需要有终止条件

四、如何编写递归代码

        如何来写递归代码？写递归代码最关键的是写出递推公式，找到终止条件，剩下将递推公式转为代码就很简单了。

来看一下“青蛙跳台阶”问题：一只青蛙一次可以跳1级台阶，也可以跳上两级台阶。求该青蛙跳上n级台阶共有多少种跳法。

我们可以把跳法分为两类：第一类是第一步跳了1个台阶，另一类是第一步跳了2个台阶。所以n个台阶的走法就相当于先走1阶后，n-1个台阶的跳法加上先跳2阶后，n-2个台阶的跳法。用公式表示就是(递归公式为)：

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

       有了递推公式，递归代码基本就完成了一半。接下来需要看终止条件。

       1个台阶有1种跳法，也就是f(1)=1

       2个台阶有2种跳法  ,也就是f(2)=2

所以，递归终止条件就是f(1)=1,f(2)=2。再拿n=3和n=4来验证一下，这个终止条件是否足够并且正确。

        有了递推公式和终止条件，转化为递归代码就简单容易多了。所以最终的递归代码如下：    

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

        总结如下，写递归代码的关键就是：

        ①找到将大问题分解为小问题的规律

        ②基于规律写出递推公式

        ③推敲终止条件，将递推公式和终止条件翻译成代码

        计算机擅长做重复的事情，所以递归正合它的胃口。而我们人脑更喜欢平铺直述的思维方式。当我们看到递归时，我们总想把递归平铺展开，脑子里就会循环，一层一层往下调用，然后再一层一层返回，试图搞清楚计算机每一步都是怎么执行的，这样就很容易被绕进去。那正确的思维方式应该是怎样的呢？

        如果一个问题A可以分解为若干个子问题B、C、D，可以假设B、C、D已经解决，在此基础上如何解决问题A。而且只需要思考问题A与子问题B、C、D两层之间的关系即可，不需要一层一层往下思考子问题与子问题，子子问题与子子子问题之间的关系。屏蔽掉递归细节。这样就容易理解。因此，编写递归代码的关键是，只要遇到递归，我们就把它抽象成一个递推公式，不用想一层一层的调用关系，不要试图用人脑分解递归的每个步骤。

四、递归代码注意事项

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

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

Exception in thread "main" java.lang.StackOverflowError

      可以通过限制递归调用的深度来解决这个问题。但这种做法不能完全解决问题，因为最大允许的递归深度根当前线程剩余的栈空间大小有关，事先无法计算。如果最大深度比较小，比如10,、50。  

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

                                      

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

       为了避免重复计算，我们可以通过散列表来保存已经求解过的f(k)。key为k，value为f(k)对应的值。当递归调用f(k)时，先看下是否已经求解过了。如果是，则直接从散列表中取值返回，不需要重复计算。

        

public class FibonacciSequence {
    Map hasSolvedMap = new HashMap();

    public int f(int n) {
        if (n == 1) {
            return 1;
        }
        if (n == 2) {
            return 2;
        }
        //hasSolvedMap可以理解为1个map，key是n，value是f(n)
        if (hasSolvedMap.containsKey(n)) {
            return hasSolvedMap.get(n);
        }
        int ret = f(n - 1) + f(n - 2);
        hasSolvedMap.put(n, ret);
        return ret;
    }
}

五、将递归代码改为非递归代码

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

       “青蛙跳台阶”问题改写为非递归代码如下：   

int f(int n) {
  if (n == 1) return 1;
  if (n == 2) return 2;
  
  int ret = 0;
  int pre = 2;
  int prepre = 1;
  for (int i = 3; i <= n; ++i) {
    ret = pre + prepre;
    prepre = pre;
    pre = ret;
  }
  return ret;
}

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

       是的，因为递归本身就是借助栈来实现的，只不过我们使用的栈是系统或虚拟机栈，我们没有感知罢了。我们可以在内存堆上事先栈，手动模拟入栈、出栈过程，这样任何递归代码都可以改成看上去不是递归代码的样子。

六、找到最终推荐人

long findRootReferrerId(long actorId) {
  Long referrerId = select referrer_id from [table] where actor_id = actorId;
  if (referrerId == null) return actorId;
  return findRootReferrerId(referrerId);
}

      三行代码搞定最终推荐人，是不是很简洁呢？在实际项目中这三行代码并不能工作，为什么？

       ①如果递归很深，可能会有堆栈溢出问题

       ②如果存在增数据，可能会死循环

七、递归代码，调试方法

        1、打印日志发现递归值

        2、结合条件断点进行调试