算法 - 递归

1. 如何理解“递归”

例子：周末你带着女朋友去电影院看电影，女朋友问你，咱们现在坐在第几排啊？电影院里面太黑了，看不清，没法数，现在你怎么办？

递归就开始排上用场了。于是你就问前面一排的人他是第几排，你想只要在他的数字上加一，就知道自己在哪一排了。但是，前面的人也看不清啊，所以他也问他前面的人。就这样一排一排往前问，直到问到第一排的人，说我在第一排，然后再这样一排一排再把数字传回来。直到你前面的人告诉你他在哪一排，于是你就知道答案了。

这就是一个非常标准的递归求解问题的分解过程，去的过程叫“递”，回来的过程叫“归”。基本上，所有的递归问题都可以用递推公式来表示。公式如下：

f(n) = f(n-1)+1 其中，f(1) = 1

f(n) 表示你想知道自己在哪一排，f(n-1) 表示前面一排所在的排数，f(1)=1 表示第一排的人知道自己在第一排。有了这个递推公式，我们就可以很轻松地将它改为递归代码，如下：

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

2. 使用 递归的三个条件

用递归来解决，需同时满足下面三个条件：

1. 一个问题的解可以分解为几个子问题解决
2. 这个问题与分解之后的子问题，除了数据规模不同，求解思路完全一样
3. 存在递归终止条件：不能存在无限循环，这就需要有终止条件。

3. 编写递归代码

写递归代码最关键的是写出递推公式，找到终止条件。

例子：假如这里有 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);

再来看下终止条件，最后到达第 n 个台阶有两种走法，一种是走一个台阶到第 n 个台阶；一种是走两个台阶到第 n 个台阶。所以，递归终止条件就是 f(1)=1，f(2)=2。

递推公式放到一起就是这样的：

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

最终的递归代码是这样的：

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

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

对于递归代码，试图想清楚整个递和归过程的做法，实际上是进入了一个思维误区。编写递归代码的关键是，只要遇到递归，就把它抽象成一个递推公式，不用想一层层的调用关系，不要试图用人脑去分解递归的每个步骤。

4. 递归代码的注意点

4.1 递归代码需要警惕堆栈溢出

编写递归代码时，会遇到很多问题，比如堆栈溢出。而堆栈溢出会造成系统性崩溃，后果会非常严重。

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

如果将系统栈或者 JVM 堆栈大小设置为 1KB，在求解 f(19999) 时便会出现如下堆栈报错：

Exception in thread "main" java.lang.StackOverflowError

如何避免出现堆栈溢出：

通过在代码中限制递归调用的最大深度的方式来解决这个问题。递归调用超过一定深度（比如 1000）之后，就不继续往下再递归了，直接返回报错。如电影院的例子，大致可写为：

// 全局变量，表示递归的深度
int dept = 0;
int f(int n) {
	++dept;
	if (dept > 1000) {
		throw exception;
	}
	if (n == 1) {
		return 1;
	}
	return f(n - 1);
}

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

4.2 递归代码需要警惕重复计算

第二个递归代码的例子，吧整个递归过程分解一下：

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

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

改造后的代码：

public int f(int n) {
    if (n == 1) {
        return 1;
    }
    if (n == 2) {
        return 2;
    }
    // hasSolvedList可以理解为 Map，key 是n，而 value 是 f(n)
    if (hasSolvedList.containsKey(n)) {
        return hasSolvedList.get(n);
    }
    int res = f(n-1) + f(n-2);
    hasSolvedList.put(n, res);
    return res;
}

在时间效率上，递归代码里多了很多函数调用，当这些函数调用的数量较大时，就会积聚成一个可观的时间成本。在空间复杂度上，因为递归调用一次就会在内存栈中保存一次现场数据，所以在分析递归代码空间复杂度时，需要额外考虑这部分的开销，比如前面讲到的电影院递归代码，空间复杂度并不是 O(1)，而是 O(n)。

5. 将递归代码改写为非递归代码

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

如果递归弊大于利，可以将递归代码改写为非递归代码。如电影院的例子，可以改写为：

int f(int n) {
    int res = 1;
    for (int i = 2; i < n; ++i) {
        res = res + 1;
    }
    return res;
}

第二个例子可以改写为：

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

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

6. 递归场景

推荐注册返佣金的功能：用户 A 推荐用户 B 来注册，用户 B 又推荐了用户 C 来注册。用户 C 的“最终推荐人”为用户 A，用户 B 的“最终推荐人”也为用户 A，而用户 A 没有“最终推荐人”。

求解：给定一个用户 ID，如何查找这个用户的“最终推荐人”

过数据库来记录这种推荐关系：

代码如下：

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

这里面有两个问题：

1. 如果递归很深，可能会有堆栈溢出的问题。
2. 如果数据库里存在脏数据，还需要处理由此产生的无限递归问题。比如 demo 环境下如果 A 的推荐人是 B，B 的推荐人是 C，C 的推荐人是 A，这样就会发生死循环。

第一个问题，可以用限制递归深度来解决。

第二个问题，也可以用限制递归深度来解决。不过，还有一个更高级的处理方法，就是自动检测 A-B-C-A 这种“环”的存在。比如使用一个 Set 集合存放推荐人，每次都添加进 Set 中，添加前需判断是否已经存在，如果已经存在则说明存在“环”。

来源

• 极客时间《数据结构与算法之美》 (opens new window)专栏笔记