用大白话理解递归

先来个场景：

你带着女友去电影院看电影~

女友问，咱两现在坐在第几排啊？电影院里面太黑了，看不清，没法数，现在你怎么办？

于是你开始展示你智慧的一面了，先问前排的人他是第几排，你想只要在他的数字上加一，就知道自己在哪一排了。

但是，前面的人也看不清啊，所以他也问他前面的人。就这样一排一排往前问~ 直到问到第一排的人，说我在第一排，然后再这样一排一排再把数字传回来。直到你前面的人告诉你他在哪一排，于是你就知道答案了。

这就是一个非常标准的递归求解问题的分解过程，去的过程叫“递”，回来的过程叫“归”，所以叫“递归”。

递归的本质：将原来的问题，转化为更小的同一问题。问题一点点变小，当问题变成最小级别之后，先解决最小级别的问题的答案，然后大一点的问题也有了答案，一点点的往上，这样原来的问题也就有了答案~

举例理解递归：数组求和

举个代码的例子理解下递归：对数组求和。

假设对 [1,2,3,4]求和，可以转化为 [2,3,4]的求和，这样问题就变得更小，直到转为空数组，空数组就是最小级别的问题，先解决最小级别的问题，然后大一点的问题也有了答案，一点点的，这样原来的问题也就有了答案~

function sum(arr) {
  // 先解决最小级别的问题
  if (arr.length === 0) {
    return 0;
  }
  // 大的问题 转化为 更小的问题
  return arr[0] + sum(arr.slice(1));
}

怎么写递归

两步：

• 找到递归边界：找到最小级别的问题，并搞定答案
• 找到递归式：将大问题转化为更小的同一问题（假设更小的问题有了答案，只想到第一层就行）

再举个例子：

有一组数：1,1,2,3,5,8,13,21…

问第 n 个数是什么？

细细看看，其实就是斐波拉契数列，后面一个数等于前两数之和。

• 找到递归边界：找到最小级别的问题，并搞定答案

f(1) = 1;
f(2) = 1;

• 找到递归式：将大问题转化为更小的同一问题（假设更小的问题有了答案，只想到第一层就行）

第n个数就是前两数之和

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

即

function f(n) {
  // 最小级别的问题，务必搞定答案
  if (n === 1) return 1;
  if (n === 2) return 1;
  // 假设n-1和n-2都知道的话
  return f(n - 1) + f(n - 2);
}

递归的缺陷和解决方案

两个大缺陷：

• 堆栈溢出
• 重复计算度高

对于堆栈溢出，这种缺陷的一个解决办法是：提前规定最大深度，超过深度之后直接报错。
当然这个最大深度不一定好估计。

// 全局变量，表示递归的深度。
let depth = 0;

function f(n) {
  ++depth；
  if (depth > 1000) throw Error('递归层次超过范围了');
  if(n === 1) return 1
  if(n === 2) return 1
  return f(n-1) + f(n-2)
}

重复计算度高怎么理解呢？

比如计算第 5 个数，等价于 f(3)+f(4)，而f(4)等价于f(3)+f(2)，注意这里的 f(3)出现了两次，这还只是计算第 5 个数，如果更大的话，会重复计算更多次！

这种缺陷的一个解决办法是：用哈希表保存已经求解过的 f(k)，调用到 f(k) 时，哈希表有则直接返回，不需要重复计算了。当然代价是，空间复杂度变高。

let resolvedList = {};

function f(n) {
  if (n === 1) return 1;
  if (n === 2) return 1;
  // 保存过的话直接返回
  if (resolvedList[n]) {
    return resolvedList[n];
  }
  const res = f(n - 1) + f(n - 2);
  // 没保存过的，保存下
  resolvedList[n] = res;
  return res;
}

怎么将递归代码改写为非递归代码

递归的好处是代码简洁易理解，坏处就是上面的。能不能将其转化为非递归代码呢？答案是肯定的！递归的过程可以理解为函数调用栈的过程，我们可以手动模拟进栈出栈，也就是迭代循环！

// 数组求和：
/*
function sum(arr) {
  if (arr.length === 0) return 0;
  return arr[0] + sum(arr.slice(1));
}
*/
function sum(arr) {
  if (n === 0) return 0;
  let res = 0;
  for (let i = 0; i <= arr.length; i++) {
    // 手动迭代res
    res = arr[i] + res;
  }
}

// 斐波拉契数列：
/*
function f(n) {
  if (n === 1) return 1;
  if (n === 2) return 2;
  return f(n - 1) + f(n - 2);
}
*/
function f(n) {
  if (n === 1) return 1;
  if (n === 2) return 1;

  let res = 0;
  let pre = 1;
  let prepre = 1;
  for (let i = 3; i <= n; ++i) {
    // 手动迭代res
    res = pre + prepre;
    prepre = pre;
    pre = res;
  }
  return res;
}

“手动”递归，并不是说没有缺点，虽然没有那么多函数调用，但是重复计算度依然很高。另外，迭代循环，对于线性结构的还好理解些，对于非线性结构的理解起来会更困难。