递归

邀请好友返红包这个功能想必你应该并不陌生吧？现在很多 App 都有这个功能。这个功能中，用户 A 邀请 用户 B 来注册，用户 B 又邀请了用户 C 来注册。我们可以说，用户 C 的 “最终邀请人” 是用户 A，用户 B 的 “最终邀请人” 也是用户 A，而用户 A 没有 “最终邀请人”。

一般来说，我们会通过数据库来记录这种推荐关系。在数据库表中，我们可以记录两行数据，其中 actor_id 表示用户 id，invite_id 表示邀请人 id。

基于这个背景，我们可以提出一个问题，给定一个用户 ID，如何查找这个用户的 “最终邀请人”。带着这个问题，我们来学习今天的内容，递归（Recursion）。

递归是什么

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

递归求解分为两个过程，去的过程叫 “递”，回来的过程叫 “归”。基本上，所有的递归问题都可以用递归公式来表示。

递归需要满足三个条件

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

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

何为子问题？子问题就是数据规模更小的问题。

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

存在递归终止条件

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

如何编写递归代码

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

首先你要记住这个理论。然后可以根据下面的例子，帮助理解。

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

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

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

有了递归公式，递归代码基本就完成一半。我们再来看下终止条件。当有一个台阶时，我们不需要递归，就只有一种走法。所以 f(1) = 1。这个递归条件并不够，我们还可以用 n = 1, n = 3 这样比较小的数试一下。

n = 2 时，f(2) = f(1) + f(0)。如果递归条件只有一个 f(1) = 1，那 f(2) 就无法求解了。所以除了 f(1) = 1 这个递归条件外，还要有 f(0) = 1，表示走 0 个台阶有一种走法，不过这样子看起来就不符合正常的逻辑思维。所以，我们可以把 f(2) = 2 作为一种终止条件，表示走 2 个台阶，有两种走法，一步走完或者分两步来走。

所以，递归终止条件就是 f(1) = 1，f(2) = 2。这个时候，你可以拿 n = 1，n = 4 来验证这个终止条件是否足够并且正确。

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

f(1) = 1;
f(2) = 2;
f(3) = 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);
}

总结一下，写递归代码的关键就是找到如何将大问题分解为小问题的规律，并且基于此写出递归公式，然后再推敲出终止条件，最后将递归公式和终止条件翻译成代码。

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

对于递归代码，这种试图想清楚整个递和归过程的做法，实际上是进入了一个思维误区。很多时候，我们理解起来比较吃力，主要原因就是自己给自己制造了这种理解障碍。

如果一个问题 A 可以分解为若干子问题 B、C、D，你可以假设子问题 B、C、D 已经解决，在此基础上思考如何解决问题 A。而且，你只需要思考问题 A 与 子问题 B、C、D 两层之间的关系即可，不需要一层一层往下思考与子问题之间的关系。屏蔽掉细节，理解起来就简单多了。

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

警惕堆栈溢出

在实际的项目开发中，编写递归代码时，可能会遇到很多问题，比如堆栈溢出。堆栈溢出会导致系统性崩溃，后果非常严重。为什么递归代码容易造成堆栈溢出？该如何预防堆栈溢出？

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

那么，如何避免堆栈溢出？

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

警惕重复计算

使用递归时还会出现重复计算的问题。下图是刚才递归代码例子的递归过程。

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

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

const cache = new Map();

function f (n) {
  if (n === 1) return 1;
  if (n === 2) return 2;
  
  if (cache.has(n)) {
    return cache.get(n);
  }

  const ret = f(n - 1) + f(n - 2);
  cache.set(n, ret);
  
  return ret;
}

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

在时间效率上，递归代码里多了很多函数调用，当这些函数调用的数量较大时，就会积聚成一个可观的时间成本。在空间复杂度上，因为递归调用一次就会在内存栈中保存一次现场数据，所以在分析递归代码空间复杂度时，需要额外考虑这部分的开销。

如何把递归代码改写为非递归代码

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

我们是否可以把递归代码改为非递归代码？刚才的例子就可以改为非递归代码。

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

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

笼统地讲，是的。因为递归本身就是借助栈来实现的，只不过我们使用的栈是系统或者虚拟机提供的，我们感知不到。如果我们自己在内存堆上实现栈，手动模拟入栈、出栈过程，这样任何递归代码都可以改写成看上去不是递归代码的样子。

但是这种思路实际上是将递归改为 “手动” 递归，本质并没有变，而且也没有解决前面讲的问题，还增加了复杂度。

总结

递归是一种非常高效、简洁的编程技巧。只要满足 “三个条件” 的问题就可以通过递归代码来解决。

不过递归代码也比较难写、难理解。编写递归代码的关键就是不要把自己绕进去，正确姿势是写出递归公式，找出终止条件，然后再翻译成代码。

递归代码虽然简单高效，但是，递归代码也有很多弊端。比如，堆栈溢出、重复计算、函数调用耗时多、空间复杂度高等，所以，在编写递归代码的时候，一定要控制好这些副作用。

技术拓展

最终邀请人

寻找最终邀请人，大概代码如下：

function findRootInviteId (actorId) {
  const inviteId = select invite_id from [table] where actor_id = actorId;
  if (inviteId == null) return actorId;
  return findRootInviteId(inviteId);
}

是不是非常简洁明了，三行代码就可以搞定。但是实际项目中，上面的代码并不能工作。

第一，如果递归很深，可能存在堆栈溢出的问题。

第二，如果数据库里存在脏数据，还需要处理由此产生的无限递归问题。

第一个问题可以用限制递归深度来解决，第二个也可以用限制递归深度来解决。不过，还有一个更高级的处理方法，就是自动检测 “环” 的存在（双指针解法）。除此之外还可以通过散列表缓存已经存在的值，如果发现重复值，表示已经存在环。

递归代码如何调试

打印日志发现，递归值。

结合条件断点进行调试。