本专栏是学习王争老师的《数据结构与算法之美》的学习总结,详细内容可以去学习王争老师的专栏,希望大家都能够有所收获。同时也欢迎大家能够与我一起交流探讨!
目前许多App都有推荐注册返佣金这个功能。这个功能中,用户 A 推荐用户 B 来注册,用户 B 又推荐了用户 C 来注册。即用户 C 的“最终推荐人”为用户 A,用户 B 的“最终推荐人”也为用户 A,而用户 A 没有“最终推荐人”。
上述情况,会通过数据库来记录这种推荐关系。在数据库表中,可以记录两行数据,其中 actor_id 表示用户 id,referrer_id 表示推荐人 id。
在给定一个用户ID,如何如何查找这个用户的“最终推荐人”?
一、如何理解“递归”?
递归是一种应用非常广泛的算法(或者编程技巧)。
例如在电影院看电影,当你想知道当前坐在第几排,该如何判断?这时候递归就派上用场。你可以询问前一排的人他在第几排,只要在他的数字上加一即可知道自己在第几排。如果前一排的人也不知道,但他也可以问前一排的人。就这样一排一排往前问,直到问到第一排的人,说我在第一排,然后再这样一排一排再把数字传回来。直到你前面的人告诉你他在哪一排,于是你就知道答案了。
这个案例就是非常标准的递归求解问题的分解过程,递”,回来的过程叫“归”。基本上,所有的递归问题都可以用递推公式来表示。刚才的例子,用递推公式将它表示出来:
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;
}
二、递归需要满足的三个条件
1、一个问题的解可以分解为几个子问题的解
何为子问题?子问题就是数据规模更小的问题。例如上述例子,想要知道“自己在哪一排”,可以分解为“前一排的人在哪一排”这样的子问题、
2、这个问题与分解之后的子问题,除了数据规模不同,求解思路完全一样
上述电影院的例子,在求解“自己在哪一排”的思路,和前面一排人求解“自己在哪一排”的思路,是一模一样的。
3、存在递归终止条件
把问题分解为子问题,把子问题再分解为子子问题,一层一层分解下去,不能存在无限循环,这就需要有终止条件。
还是电影院的例子,第一排的人不需要再继续询问任何人,就知道自己在哪一排,也就是 f(1)=1,这就是递归的终止条件。
三、如何编写递归代码?
如何来写递归代码?写递归代码最关键的是写出递推公式,找到终止条件,剩下将递推公式转化为代码。
举个例子,例如有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=2,n=3 这样比较小的数试验一下。
当n = 2 时,f(2) = f(1) + f(0)。如果递归终止条件只有一个 f(1)=1,那 f(2) 就无法求解了。而f(0)=1,表示走 0 个台阶有一种走法,不符合正常的逻辑思维。所以,可以把 f(2) = 2 作为一种终止条件,表示走 2 个台阶,有两种走法,一步走完或者分两步来走。
所以,递归终止条件就是 f(1)=1,f(2)=2。可以再拿 n=3,n=4 来验证一下,这个终止条件是否足够并且正确。
将递归终止条件和刚刚得到的递推公式放到一起就是这样的:
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);
}
总结:写递归代码的关键就是找到如何将大问题分解为小问题的规律,并且基于此写出递推公式,然后再推敲终止条件,最后将递推公式和终止条件翻译成代码。
编写递归代码的关键是,只要遇到递归,我们就把它抽象成一个递推公式,不用想一层层的调用关系,不要试图用人脑去分解递归的每个步骤。
四、递归代码要警惕堆栈溢出
在实际的软件开发中,编写递归代码时,会遇到很多问题,比如堆栈溢出。而堆栈溢出会造成系统性崩溃,后果会非常严重。
为什么递归代码容易造成堆栈溢出呢?又该如何预防堆栈溢出呢?
函数调用会使用栈来保存临时变量。每调用一个函数,都会将临时变量封装为栈帧压入内存栈,等函数执行完成返回时,才出栈。系统栈或者虚拟机栈空间一般都不大。如果递归求解的数据规模很大,调用层次很深,一直压入栈,就会有堆栈溢出的风险。
那么,如何避免出现堆栈溢出呢?
可以通过在代码中限制递归调用的最大深度的方式来解决这个问题。递归调用超过一定深度(比如 1000)之后,我们就不继续往下再递归了,直接返回报错。
上述例子中,可以改造成如下代码,就可以避免堆栈溢出,以下是伪代码:
// 全局变量,表示递归的深度。
int depth = 0;
int f(int n) {
++depth;
if (depth > 1000) throw exception;
if (n == 1) return 1;
return f(n-1) + 1;
}
但这种做法并不能完全解决问题,因为最大允许的递归深度跟当前线程剩余的栈空间大小有关,事先无法计算。如果实时计算,代码过于复杂,就会影响代码的可读性。所以,如果最大深度比较小,比如 10、50,就可以用这种方法,否则这种方法并不是很实用。
五、递归代码要警惕重复计算
除此之外,使用递归时还会出现重复计算的问题。例如在爬楼梯的例子中,如果把整个递归分解,如下图:
从图中,我们可以直观地看到,想要计算 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 ret = f(n-1) + f(n-2);
hasSolvedList.put(n, ret);
return ret;
}
除了堆栈溢出、重复计算这两个常见的问题。递归代码还有很多别的问题。
- 在时间效率上,递归代码里多了很多函数调用,当这些函数调用的数量较大时,就会积聚成一个可观的时间成本。
- 在空间复杂度上,因为递归调用一次就会在内存栈中保存一次现场数据,所以在分析递归代码空间复杂度时,需要额外考虑这部分的开销,比如我们前面讲到的电影院递归代码,空间复杂度并不是 O(1),而是 O(n)。
六、怎么将递归代码改写为非递归代码?
递归有利有弊,利是递归代码的表达力很强,写起来非常简洁;而弊就是空间复杂度高、有堆栈溢出的风险、存在重复计算、过多的函数调用会耗时较多等问题。
所以,在开发过程中,我们要根据实际情况来选择是否需要用递归的方式来实现。
是否可以把递归代码改写为非递归代码呢?电影院的例子,只看f(x) =f(x-1)+1 这个递推公式,可以改成:
int f(int n) {
int ret = 1;
for (int i = 2; i <= n; ++i) {
ret = ret + 1;
}
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);
}
上述代码非常的简洁,三行代码即可搞定,不过在实际项目中,上面的代码并不能工作,为什么呢?这里面有两个问题。
- 第一,如果递归很深,可能会有堆栈溢出的问题。
- 第二,如果数据库里存在脏数据,我们还需要处理由此产生的无限递归问题。比如 demo 环境下数据库中,测试工程师为了方便测试,会人为地插入一些数据,就会出现脏数据。如果 A 的推荐人是 B,B 的推荐人是 C,C 的推荐人是 A,这样就会发生死循环。
第一个问题,可以用限制递归深度来解决。第二个问题,也可以用限制递归深度来解决。不过,还有一个更高级的处理方法,就是自动检测 A-B-C-A 这种“环”的存在。