作者 | kunge
责编 | Elle
![d968bca1a61190d935514e56eb97c902.png](https://i-blog.csdnimg.cn/blog_migrate/baca3b8b3fd1d485e470a452bfdba941.png)
前言
递归是算法中一种非常重要的思想,应用也很广,小到阶乘,再在工作中用到的比如统计文件夹大小,大到 Google 的 PageRank 算法都能看到,也是面试官很喜欢的考点
最近看了不少递归的文章,收获不小,不过我发现大部分网上的讲递归的文章都不太全面,主要的问题在于解题后大部分都没有给出相应的时间/空间复杂度,而时间/空间复杂度是算法的重要考量!递归算法的时间复杂度普遍比较难(需要用到归纳法等),换句话说,如果能解决递归的算法复杂度,其他算法题题的时间复杂度也基本不在话下。另外,递归算法的时间复杂度不少是不能接受的,如果发现算出的时间复杂度过大,则需要转换思路,看下是否有更好的解法 ,这才是根本目的,不要为了递归而递归!
本文试图从以下几个方面来讲解递归
什么是递归?
递归算法通用解决思路
实战演练(从初级到高阶)
力争让大家对递归的认知能上一个新台阶,特别会对递归的精华:时间复杂度作详细剖析,会给大家总结一套很通用的求解递归时间复杂度的套路,相信你看完肯定会有收获
![39e665afff3b7f88dd3432fe6855c8cc.png](https://i-blog.csdnimg.cn/blog_migrate/940c96c387713f5c90114a792afa9b3f.png)
简单地说,就是如果在函数中存在着调用函数本身的情况,这种现象就叫递归。
以阶乘函数为例,如下, 在 factorial 函数中存在着 factorial(n - 1) 的调用,所以此函数是递归函数
public int factorial(int n) {
if (n 1) {
return 1;
}
return n * factorial(n - 1)
}
进一步剖析「递归」,先有「递」再有「归」,「递」的意思是将问题拆解成子问题来解决, 子问题再拆解成子子问题,...,直到被拆解的子问题无需再拆分成更细的子问题(即可以求解),「归」是说最小的子问题解决了,那么它的上一层子问题也就解决了,上一层的子问题解决了,上上层子问题自然也就解决了,....,直到最开始的问题解决,文字说可能有点抽象,那我们就以阶层 f(6) 为例来看下它的「递」和「归」。
求解问题 f(6), 由于 f(6) = n * f(5), 所以 f(6) 需要拆解成 f(5) 子问题进行求解,同理 f(5) = n * f(4) ,也需要进一步拆分,... ,直到 f(1), 这是「递」,f(1) 解决了,由于 f(2) = 2 f(1) = 2 也解决了,.... f(n)到最后也解决了,这是「归」,所以递归的本质是能把问题拆分成具有相同解决思路的子问题,。。。直到最后被拆解的子问题再也不能拆分,解决了最小粒度可求解的子问题后,在「归」的过程中自然顺其自然地解决了最开始的问题。
![0265a7108e7d4efb0be33e2452cdb188.png](https://i-blog.csdnimg.cn/blog_migrate/9bc1e0d14bb91fc93a9f98ba89aec235.png)
我们在上一节仔细剖析了什么是递归,可以发现递归有以下两个特点
一个问题可以分解成具有相同解决思路的子问题,子子问题,换句话说这些问题都能调用同一个函数
经过层层分解的子问题最后一定是有一个不能再分解的固定值的(即终止条件),如果没有的话,就无穷无尽地分解子问题了,问题显然是无解的。
所以解递归题的关键在于我们首先需要根据以上递归的两个特点判断题目是否可以用递归来解。
经过判断可以用递归后,接下来我们就来看看用递归解题的基本套路(四步曲):
先定义一个函数,明确这个函数的功能,由于递归的特点是问题和子问题都会调用函数自身,所以这个函数的功能一旦确定了, 之后只要找寻问题与子问题的递归关系即可
接下来寻找问题与子问题间的关系(即递推公式),这样由于问题与子问题具有相同解决思路,只要子问题调用步骤 1 定义好的函数,问题即可解决。所谓的关系最好能用一个公式表示出来,比如 f(n) = n * f(n-) 这样,如果暂时无法得出明确的公式,用伪代码表示也是可以的, 发现递推关系后,要寻找最终不可再分解的子问题的解,即(临界条件),确保子问题不会无限分解下去。由于第一步我们已经定义了这个函数的功能,所以当问题拆分成子问题时,子问题可以调用步骤 1 定义的函数,符合递归的条件(函数里调用自身)
将第二步的递推公式用代码表示出来补充到步骤 1 定义的函数中
最后也是很关键的一步,根据问题与子问题的关系,推导出时间复杂度,如果发现递归时间复杂度不可接受,则需转换思路对其进行改造,看下是否有更靠谱的解法
听起来是不是很简单,接下来我们就由浅入深地来看几道递归题,看下怎么用上面的几个步骤来套
![5519723704673d38b9c8a86c769b73ad.png](https://i-blog.csdnimg.cn/blog_migrate/d84236b6399c930d0d5217330de734a1.png)
实战演练(从初级到高阶)
热身赛
输入一个正整数n,输出n!的值。其中n!=123*…*n,即求阶乘
套用上一节我们说的递归四步解题套路来看看怎么解
定义这个函数,明确这个函数的功能,我们知道这个函数的功能是求 n 的阶乘, 之后求 n-1, n-2 的阶乘就可以调用此函数了
/**
* 求 n 的阶乘
*/
public int factorial(int n) {
}
2.寻找问题与子问题的关系阶乘的关系比较简单, 我们以 f(n) 来表示 n 的阶乘, 显然 f(n) = n * f(n - 1), 同时临界条件是 f(1) = 1,即
3.将第二步的递推公式用代码表示出来补充到步骤 1 定义的函数中
/**
* 求 n 的阶乘
*/
public int factorial(int n) {
// 第二步的临界条件
if (n 1) {
return 1;
}
// 第二步的递推公式
return n * factorial(n-1)
}
4.求时间复杂度由于 f(n) = n * f(n-1) = n * (n-1) * .... * f(1),总共作了 n 次乘法,所以时间复杂度为 n。
看起来是不是有这么点眉目, 当然这道题确实太过简单,很容易套路,那我们再来看进阶一点的题入门题
我们继续来按四步曲来看怎么套路 1.定义一个函数,这个函数代表了跳上 n 级台阶的跳法一只青蛙可以一次跳 1 级台阶或一次跳 2 级台阶,例如:跳上第 1 级台阶只有一种跳法:直接跳 1 级即可。跳上第 2 级台阶有两种跳法:每次跳 1 级,跳两次;或者一次跳 2 级。问要跳上第 n 级台阶有多少种跳法?
/**
* 跳 n 极台阶的跳法
*/
public int f(int n) {
}
2.寻找问题与子问题之前的关系这两者之前的关系初看确实看不出什么头绪,但仔细看题目,一只青蛙只能跳一步或两步台阶,自上而下地思考,也就是说如果要跳到 n 级台阶只能从 从 n-1 或 n-2 级跳, 所以问题就转化为跳上 n-1 和 n-2 级台阶的跳法了,如果 f(n) 代表跳到 n 级台阶的跳法,那么从以上分析可得 f(n) = f(n-1) + f(n-2),显然这就是我们要找的问题与子问题的关系,而显然当 n = 1, n = 2, 即跳一二级台阶是问题的最终解,于是递推公式系为
3.将第二步的递推公式用代码表示出来补充到步骤 1 定义的函数中补充后的函数如下
/**
* 跳 n 极台阶的跳法
*/
public int f(int n) {
if (n == 1) return 1;
if (n == 2) return 2;
return f(n-1) + f(n-2)
}
4.计算时间复杂度由以上的分析可知f(n) 满足以下公式
斐波那契的时间复杂度计算涉及到高等代数的知识, 这里不做详细推导,有兴趣的同学可以点击 这里 查看,我们直接结出结论![350bb26af314fca56836d0e79344aebf.png](https://i-blog.csdnimg.cn/blog_migrate/2bb5a59e1323c7c0ec375d289787dfd8.jpeg)
public int f(int n) {
if (n == 1) return 1;
if (n == 2) return 2;
// map 即保存中间态的键值对, key 为 n,value 即 f(n)
if (map.get(n)) {
return map.get(n)
}
return f(n-1) + f(n-2)
}
那么改造后的时间复杂度是多少呢,由于对每一个计算过的 f(n) 我们都保存了中间态 ,不存在重复计算的问题,所以时间复杂度是 O(n), 但由于我们用了一个键值对来保存中间的计算结果,所以空间复杂度是 O(n)。问题到这里其实已经算解决了,但身为有追求的程序员,我们还是要问一句,空间复杂度能否继续优化?
6.使用循环迭代来改造算法我们在分析问题与子问题关系(f(n) = f(n-1) + f(n-2))的时候用的是自顶向下的分析方式,但其实我们在解 f(n) 的时候可以用自下而上的方式来解决,通过观察我们可以发现以下规律
f(1) = 1
f(2) = 2
f(3) = f(1) + f(2) = 3
f(4) = f(3) + f(2) = 5
....
f(n) = f(n-1) + f(n-2)
最底层 f(1), f(2) 的值是确定的,之后的 f(3), f(4) ,...等问题都可以根据前两项求解出来,一直到 f(n)。所以我们的代码可以改造成以下方式
public int f(int n) {
if (n == 1) return 1;
if (n == 2) return 2;
int result = 0;
int pre = 1;
int next = 2;
for (int i = 3; i 1; i ++) {
result = pre + next;
pre = next;
next = result;
}
return result;
}
改造后的时间复杂度是 O(n), 而由于我们在计算过程中只定义了两个变量(pre,next),所以空间复杂度是O(1)
简单总结一下:分析问题我们需要采用自上而下的思维,而解决问题有时候采用自下而上的方式能让算法性能得到极大提升,思路比结论重要初级题
接下来我们来看下一道经典的题目: 反转二叉树将左边的二叉树反转成右边的二叉树![4647280d3e406cec0b2f0b1fcb63644a.png](https://i-blog.csdnimg.cn/blog_migrate/fb21e7d6f5af19d9e59197bfd38fd6b7.png)
public static class TreeNode {
int val;
TreeNode left;
TreeNode right;
TreeNode(int x) { val = x; }
}
public TreeNode invertTree(TreeNode root) {
}
2.查找问题与子问题的关系,得出递推公式我们之前说了,解题要采用自上而下的思考方式,那我们取前面的1, 2,3 结点来看,对于根节点 1 来说,假设 2, 3 结点下的节点都已经翻转,那么只要翻转 2, 3 节点即满足需求
![0a7066ceab8323a78cc1bff46419ac79.png](https://i-blog.csdnimg.cn/blog_migrate/485c524117fa768d8008e9baae462e4a.jpeg)
public TreeNode invertTree(TreeNode root) {
// 叶子结果不能翻转
if (root == null) {
return null;
}
// 翻转左节点下的左右节点
TreeNode left = invertTree(root.left);
// 翻转右节点下的左右节点
TreeNode right = invertTree(root.right);
// 左右节点下的二叉树翻转好后,翻转根节点的左右节点
root.right = left;
root.left = right;
return root;
}
4.时间复杂度分析由于我们会对每一个节点都去做翻转,所以时间复杂度是 O(n),那么空间复杂度呢,这道题的空间复杂度非常有意思,我们一起来看下,由于每次调用 invertTree 函数都相当于一次压栈操作, 那最多压了几次栈呢, 仔细看上面函数的下一段代码
TreeNode left = invertTree(root.left);
从根节点出发不断对左结果调用翻转函数, 直到叶子节点,每调用一次都会压栈,左节点调用完后,出栈,再对右节点压栈....,下图可知栈的大小为3, 即树的高度,如果是完全二叉树 ,则树的高度为logn, 即空间复杂度为O(logn)
![0b460f1fe3afb64a1aefc8760c5877af.png](https://i-blog.csdnimg.cn/blog_migrate/151a98b4314b00b9a132dfbe8c5e2116.png)
![29b8090a4fa8794fb434507a8d9dd3d3.png](https://i-blog.csdnimg.cn/blog_migrate/9d3e0479dbeca91b76338ad9c2df3beb.png)
![e975b36002eca0afd175b1fe67bc7b2f.png](https://i-blog.csdnimg.cn/blog_migrate/71a9ce64f531c643e5d51fd83703adfb.jpeg)
// 将 n 个圆盘从 a 经由 b 移动到 c 上
public void hanoid(int n, char a, char b, char c) {
}
2.查找问题与子问题的关系首先我们看如果 A 柱子上只有两块圆盘该怎么移
![219149498fe65622d7ddb7daed70fa9d.png](https://i-blog.csdnimg.cn/blog_migrate/9634eff65720e560f26c57f04edff5ab.png)
// 将 n 个圆盘从 a 经由 b 移动到 c 上
public void hanoid(int n, char a, char b, char c) {
if (n <= 0) {
return;
}
// 将上面的 n-1 个圆盘经由 C 移到 B
hanoid(n-1, a, c, b);
// 此时将 A 底下的那块最大的圆盘移到 C
move(a, c);
// 再将 B 上的 n-1 个圆盘经由A移到 C上
hanoid(n-1, b, a, c);
}
public void move(char a, char b) {
printf("%c->%c\n", a, b);
}
从函数的功能上看其实比较容易理解,整个函数定义的功能就是把 A 上的 n 个圆盘 经由 B 移到 C,由于定义好了这个函数的功能,那么接下来的把 n-1 个圆盘 经由 C 移到 B 就可以很自然的调用这个函数,所以明确函数的功能非常重要,按着函数的功能来解释,递归问题其实很好解析,切忌在每一个子问题上层层展开死抠,这样这就陷入了递归的陷阱,计算机都会栈溢出,何况人脑
4.时间复杂度分析从第三步补充好的函数中我们可以推断出 f(n) = f(n-1) + 1 + f(n-1) = 2f(n-1) + 1= 2(2f(n-2) + 1) + 1 = 2 * 2 * f(n-2) + 2 + 1 = 22 * f(n-3) + 2 + 1= 22 * f(n-3) + 2 + 1 = 22 * (2f(n-4) + 1) = 23 * f(n-4) + 22 + 1= .... // 不断地展开= 2n-1 + 2n-2 + ....+ 1 显然时间复杂度为 O(2n),很明显指数级别的时间复杂度是不能接受的,汉诺塔非递归的解法比较复杂,大家可以去网上搜一下进阶题
现实中大厂中的很多递归题都不会用上面这些相对比较容易理解的题,更加地是对递归问题进行相应地变形, 来看下面这道题细胞分裂 有一个细胞 每一个小时分裂一次,一次分裂一个子细胞,第三个小时后会死亡。那么n个小时候有多少细胞?照样我们用前面的递归四步曲来解 1.定义问题的递归函数,明确函数的功能我们定义以下函数为 n 个小时后的细胞数
public int allCells(int n) {
}
2.接下来寻找问题与子问题间的关系(即递推公式)首先我们看一下一个细胞出生到死亡后经历的所有细胞分裂过程
![359f3a3a7c6ccf21dcca56d311f037d6.png](https://i-blog.csdnimg.cn/blog_migrate/0438fc1a338dd43433596027d91667d6.png)
![2b2eff9a2ef67eb2b77f99c6baf64e3b.png](https://i-blog.csdnimg.cn/blog_migrate/aeb613afaa9b7c347d101d91020fd121.png)
![8f1010579dc568a4059e68e78879cadf.png](https://i-blog.csdnimg.cn/blog_migrate/e519d0e4f7cf63e555ad98407228de81.png)
public int allCells(int n) {
return aCell(n) + bCell(n) + cCell(n);
}
/**
* 第 n 小时 a 状态的细胞数
*/
public int aCell(int n) {
if(n==1){
return 1;
}else{
return aCell(n-1)+bCell(n-1)+cCell(n-1);
}
}
/**
* 第 n 小时 b 状态的细胞数
*/
public int bCell(int n) {
if(n==1){
return 0;
}else{
return aCell(n-1);
}
}
/**
* 第 n 小时 c 状态的细胞数
*/
public int cCell(int n) {
if(n==1 || n==2){
return 0;
}else{
return bCell(n-1);
}
}
只要思路对了,将递推公式转成代码就简单多了,另一方面也告诉我们,可能一时的递归关系我们看不出来,此时可以借助于画图来观察规律
4.求时间复杂度由第二步的递推公式我们知道f(n) = 2aCell(n-1) + 2aCell(n-2) + aCell(n-3) 之前青蛙跳台阶时间复杂度是指数级别的,而这个方程式显然比之前的递推公式(f(n) = f(n-1) + f(n-2)) 更复杂的,所以显然也是指数级别的![c169719f03b9faf79e3ac10e93ee47b5.png](https://i-blog.csdnimg.cn/blog_migrate/38981ea642e909a905be3587be6073a7.png)
总结
大部分递归题其实还是有迹可寻的, 按照之前总结的解递归的四个步骤可以比较顺利的解开递归题,一些比较复杂的递归题我们需要勤动手,画画图,观察规律,这样能帮助我们快速发现规律,得出递归公式,一旦知道了递归公式,将其转成递归代码就容易多了,很多大厂的递归考题并不能简单地看出递归规律,往往会在递归的基础上多加一些变形,不过万遍不离其宗,我们多采用自顶向下的分析思维,多练习,相信递归不是什么难事声明:本文为作者投稿,版权归作者个人所有。
【End】热
热 文 推 荐 文 推 荐
☞ 互联网诞生记:风起于青萍之末 ☞罗永浩回应“鲨鱼皮技术遭质疑”; 消息称马蜂窝开启裁员; Dart 2.7 发布 | 极客头条 ☞“弃用 Google AMP! ” ☞20行 Python 代码爬取王者荣耀全英雄皮肤 | 原力计划 ☞ 操作系统兴衰史☞图灵奖得主Bengio:深度学习不会被取代,我想让AI会推理、计划和想象
☞ 我在华为做外包的真实经历☞搞定面试算法系列 | 分治算法三步走
![670d35ce651329e169370104d9e43e65.png](https://i-blog.csdnimg.cn/blog_migrate/1140e22575af68546b10f2ee4729f840.png)