导论

 小编之前在分享有关的算法时，把递归这一重要的算法设计思想给遗漏了。递归的学习绝对是一个持久战，没有人可以一蹴而就。问题的复杂，加上递归本身的细节，我们想要“学会”、“学好”再到“用好”，是需要一个漫长的过程的。说实话，哪来那么多捷径啊！小编整理了下一些写的比较好的文章，希望对各位小伙伴有所帮助。
 本文试图从以下几个方面来讲解递归
 1、什么是递归？
 2、递归算法通用解决思路
 3、实战演练（从初级到高阶）
 4、递归函数调用栈
 5、递归算法时间复杂度分析与求解
 力争让大家对递归的认知能上一个新台阶，特别会对递归的精华:时间复杂度作详细剖析，会给大家总结一套很通用的求解递归时间复杂度的套路，相信你看完肯定会有收获。

什么是递归

 简单地说，就是如果在函数中存在着调用函数本身的情况，这种现象就叫递归。
 以阶乘函数为例,如下, 在 f 函数中存在着 f(n - 1) 的调用，所以此函数是递归函数。

\\求阶乘函数
int f(int n) {
    if (n < =1) {
        return 1;
    }
    return n * f(n - 1)
}

 进一步剖析「递归」，先有「递」再有「归」，「递」的意思是将问题拆解成子问题来解决， 子问题再拆解成子子问题，...，直到被拆解的子问题无需再拆分成更细的子问题（即可以求解），「归」是说最小的子问题解决了，那么它的上一层子问题也就解决了，上一层的子问题解决了，上上层子问题自然也就解决了,....,直到最开始的问题解决,文字说可能有点抽象，那我们就以阶层 f(6) 为例来看下它的「递」和「归」。

递与归

递归条件/临界条件

递归算法通用解决思路

 我们在上一节仔细剖析了什么是递归，可以发现递归有以下两个特点：
 1、一个问题可以分解成具有相同解决思路的子问题，子子问题，换句话说这些问题都能调用同一个函数
 2、经过层层分解的子问题最后一定是有一个不能再分解的固定值的（即终止条件）,如果没有的话,就无穷无尽地分解子问题了，问题显然是无解的。
 所以解递归题的关键在于我们首先需要根据以上递归的两个特点判断题目是否可以用递归来解。
 经过判断可以用递归后，接下来我们就来看看用递归解题的基本套路（四步曲）：
 1、先定义一个函数，明确这个函数的功能，由于递归的特点是问题和子问题都会调用函数自身，所以这个函数的功能一旦确定了， 之后只要找寻问题与子问题的递归关系即可
 2、接下来寻找问题与子问题间的关系（即递推公式），这样由于问题与子问题具有相同解决思路，只要子问题调用步骤 1 定义好的函数，问题即可解决。所谓的关系最好能用一个公式表示出来，比如 f(n) = n * f(n-) 这样，如果暂时无法得出明确的公式，用伪代码表示也是可以的, 发现递推关系后，要寻找最终不可再分解的子问题的解，即（临界条件），确保子问题不会无限分解下去。由于第一步我们已经定义了这个函数的功能，所以当问题拆分成子问题时，子问题可以调用步骤 1 定义的函数，符合递归的条件（函数里调用自身）
 3、 将第二步的递推公式用代码表示出来补充到步骤 1 定义的函数中
 4、最后也是很关键的一步，根据问题与子问题的关系，推导出时间复杂度,如果发现递归时间复杂度不可接受，则需转换思路对其进行改造，看下是否有更靠谱的解法。
 听起来是不是很简单，接下来我们就由浅入深地来看几道递归题，看下怎么用上面的几个步骤来套。

实战演练（从初级到高阶）

热身赛

 输入一个正整数n，输出n!的值，即求阶乘
 套用上一节我们说的递归四步解题套路来看看怎么解
 1、定义这个函数，明确这个函数的功能，我们知道这个函数的功能是求 n 的阶乘, 之后求 n-1, n-2 的阶乘就可以调用此函数了。

\\求阶乘函数
int f(int n) {
   
}

 2、寻找问题与子问题的关系 阶乘的关系比较简单， 我们以 f(n) 来表示 n 的阶乘， 显然 f(n) = n * f(n - 1), 同时临界条件是 f(1) = 1,即：

递推关系

 3、将第二步的递推公式用代码表示出来补充到步骤 1 定义的函数中。

\\求阶乘函数
int f(int n) {
    if (n < =1) {
        return 1;
    }
    return n * f(n - 1)
}

 4、求时间复杂度 由于 f(n) = n * f(n-1) = n * (n-1) * .... * f(1),总共作了 n 次乘法，所以时间复杂度为 n。
看起来是不是有这么点眉目， 当然这道题确实太过简单,很容易套路，那我们再来看进阶一点的题。

入门题

 一只青蛙可以一次跳 1 级台阶或者一次跳 2 级台阶，例如：跳上第 1 级台阶只有一种跳法：直接跳 1 级即可。 跳上第 2 级台阶有两种跳法：每次跳 1 级，跳两次；或者一次跳 2 级。 问要跳上第 n 级台阶有多少种跳法？
 我们继续来按四步曲来看怎么套路
 1、定义一个函数，这个函数代表了跳上 n 级台阶的跳法

/**
 * 跳 n 极台阶的跳法
 */
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 极台阶的跳法
 */
int f(int n) {
    if (n == 1) return 1;
    if (n == 2) return 2;
    return f(n-1) + f(n-2)
}

 4、计算时间复杂度：
 斐波那契的时间复杂度计算涉及到高等代数的知识， 这里不做详细推导，有兴趣的同学可以点击小编以前的文章查看,我们直接结出结论：

时间复杂度

 由些可知时间复杂度是指数级别，显然不可接受，那回过头来看为啥时间复杂度这么高呢,假设我们要计算 f(6),根据以上推导的递归公式，展示如下：

递归树

int helper(vector<int>& result,int n){
    if(n==1)return 1;
    if(n==2)return 2;
    if(result[n]!=0)return result[n];
    result[n]=helper(result,n-1)+helper(result,n-2);
    return result[n];
}
int f(int N){
    if(N<1) return 0;
    vector<int> result(N+1,0);
    return helper(result,N);
}

 "记忆化搜索"或者我们称"重叠子问题"的加缓存优化的实现，我们的思考路径是"自顶向下"。即为了解决数据规模大的问题，我们“假设”已经解决了数据规模较小的子问题。我们没有从最基本的问题开始求解，对于f(n)=f(n-1)+f(n-2)，我们假装f(n-1)和f(n-2)是已知的。那么改造后的时间复杂度是多少呢，由于对每一个计算过的 f(n) 我们都保存了中间态 ，不存在重复计算的问题，所以时间复杂度是 O(n), 但由于我们用了一个键值对来保存中间的计算结果，所以空间复杂度是 O(n)。
 6、优化算法2：
 我们可以使用动态规划的思想来编写程序，同样，其时间复杂度与空间复杂度都为O(n)。代码如下：

int f(int N){
    if(N<1) return 0;
    vector<int> result(N+1,0);
    result[1]=1;
    result[2]=2;
    for(int i=3;i<=N;i++){
        result[i]=result[i-1]+result[i-2];
    }
    return result[N];
}

 7、优化算法3：
 问题到这里其实已经算解决了，但身为有追求的程序员，我们还是要问一句,空间复杂度能否继续优化?这里直接给出代码，如下所示：

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<=N;i++){
        result=pre+next;
        pre=next;
        next=result;
    }
    return result;
}

 简单总结一下： 分析问题我们需要采用自上而下的思维，而解决问题有时候采用自下而上的方式能让算法性能得到极大提升,思路比结论重要。

初级题

 接下来我们来看下一道经典的题目: 反转二叉树：将左边的二叉树反转成右边的二叉树。

反转二叉树

struct BinaryTreeNode{
    char val;
    BinaryTreeNode *lchild;
    BinaryTreeNode *rchild;
};
typedef BinaryTreeNode *BinaryTree;

BinaryTree InvertBinaryTree(BinaryTree &root){
    
}

 2、查找问题与子问题的关系,得出递推公式 我们之前说了，解题要采用自上而下的思考方式，那我们取前面的1， 2，3 结点来看，对于根节点 1 来说，假设 2, 3 结点下的节点都已经翻转，那么只要翻转 2， 3 节点即满足需求。

查找关系

BinaryTree InvertBinaryTree(BinaryTree &root){
    if(root=NULL) return NULL;
    root->lchild=InInvertBinaryTree(root->lchild);
    root->rchild=InInvertBinaryTree(root->rchild);
    BinaryTree tempTree=root->lchild;
    root->lchild=root->rchild;
    root->rchild=tempTree;
    return root;
}

 4、时间复杂度分析
 由于我们会对每一个节点都去做翻转，所以时间复杂度是 O(n)，那么空间复杂度呢，这道题的空间复杂度非常有意思，我们一起来看下，由于每次调用InvertBinaryTree函数都相当于一次压栈操作， 那最多压了几次栈呢， 仔细看上面函数的下一段代码：

root->lchild=InInvertBinaryTree(root->lchild);

 从根节点出发不断对左结果调用翻转函数, 直到叶子节点，每调用一次都会压栈，左节点调用完后，出栈，再对右节点压栈....,下图可知栈的大小为3， 即树的高度，如果是完全二叉树 ，则树的高度为logn, 即空间复杂度为O(logn)。

空间复杂度

 最坏情况，如果此二叉树是如图所示(只有左节点，没有右节点)，则树的高度即结点的个数 n，此时空间复杂度为 O(n)。总的来看，空间复杂度为O(n)。

最坏情况

中级题

 接下来我们看一下大学时学过的汉诺塔问题：  
 如下图所示，从左到右有A、B、C三根柱子，其中A柱子上面有从小叠到大的n个圆盘，现要求将A柱子上的圆盘移到C柱子上去，期间只有一个原则：一次只能移到一个盘子且大盘子不能在小盘子上面，求移动的步骤和移动的次数。

汉诺塔

void hannoi (int n, char a, char b, char c)　　// 将 n 个圆盘从 A 经由 B 移动到 C 上
{
  
    
}

 2、查找问题与子问题的关系 首先我们看如果 A 柱子上只有两块圆盘该怎么移：

初始

步骤一：将A上方的第一个圆盘移到B

步骤二：将A上方的另一个圆盘移到C

步骤三：将B上方的圆盘移到C

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);
}

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
   = 2² f(n-2) + 2 + 1
   = 2²（2f(n-3)+1） + 2 + 1
   = 2³ f(n-3) + 2²+2 + 1
   =……
   = 2^n-1 + 2^n-2 + ....+ 1
 显然时间复杂度为 O(2ⁿ)，很明显指数级别的时间复杂度是不能接受的，汉诺塔非递归的解法比较复杂，大家可以去网上搜一下。

进阶题

 现实中大厂中的很多递归题都不会用上面这些相对比较容易理解的题，更加地是对递归问题进行相应地变形， 来看下面这道题：
 “细胞分裂 有一个细胞 每一个小时分裂一次，一次分裂一个子细胞，第三个小时后会死亡。那么n个小时候有多少细胞？”
 照样我们用前面的递归四步曲来解：
 1、定义问题的递归函数，明确函数的功能 我们定义以下函数为 n 个小时后的细胞数。

int allCells(int n) {

}

 2、接下来寻找问题与子问题间的关系（即递推公式） 首先我们看一下一个细胞出生到死亡后经历的所有细胞分裂过程。

关系寻找

n=4

A与B的联系

B与C联系

细胞分裂

int allCells(int n) {
    return aCell(n) + bCell(n) + cCell(n);
}

/**
 * 第 n 小时 a 状态的细胞数 
 */
int aCell(int n) {
    if(n==1){
        return 1;
    }else{
        return aCell(n-1)+bCell(n-1)+cCell(n-1);
    }
}

/**
 * 第 n 小时 b 状态的细胞数 
 */
int bCell(int n) {
    if(n==1){
        return 0;
    }else{
        return aCell(n-1);
    }
}

/**
 * 第 n 小时 c 状态的细胞数 
 */
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)) 更复杂的，所以显然也是指数级别的。

总结

 大部分递归题其实还是有迹可寻的， 按照之前总结的解递归的四个步骤可以比较顺利的解开递归题，一些比较复杂的递归题我们需要勤动手，画画图，观察规律，这样能帮助我们快速发现规律，得出递归公式，一旦知道了递归公式，将其转成递归代码就容易多了,很多大厂的递归考题并不能简单地看出递归规律，往往会在递归的基础上多加一些变形，不过万遍不离其宗，我们多采用自顶向下的分析思维，多练习，相信递归不是什么难事

递归函数调用栈

 我们经常可以在书上可以看到，如果递归的深度过大，算法的空间复杂度会很大，甚至会导致栈溢出。这又是为什么。接下来我们使用反汇编的方法，通过绘制堆栈图，来看看递归是怎样占用栈空间的。
 小编本次用的为window系统，采用Intel汇编语法格式，使用的是32位的编译器。当然，64位的也差不多。
 函数每次被调用时，要在调用栈(call stack)上占用一段空间，在这段空间上保存调用者栈帧的基址(ebp)、本函数的局部变量、调用其他函数时的返回地址，并在需要时保存调用者使用的寄存器值，被调函数结束后esp上移表示释放这段空间，然后回到调用者的占用的空间与代码位置继续执行，函数运行阶段在调用栈上占用的这段空间就叫做栈帧，是编译原理运行时空间组织中活动记录（activation record）的一种实现。
 栈帧主要通过 ebp、esp 两个寄存器维护，ebp 始终指向栈底，esp 始终指向栈顶。
 每个函数被调用时执行下面两条命令：

push        ebp; ebp入栈，保存调用者的栈帧基址，以便返回
mov         ebp,esp; 将当前 esp 的位置作为当前栈帧的基址

 这样在当前栈帧向上一栈帧退回时，只需要取出之前压栈的基址
 另一方面，调用过程的指令 call

call a_func

 会将 call 指令的下一条指令地址压栈，a_func 函数返回时执行指令。

mov         esp,ebp
pop         ebp
ret        ;返回到 call 压栈保存的地址, 即调用 a_func 的函数中

 这样被调函数返回调用函数前就可以将 ebp、esp 置回调用函数的栈帧位置，并返回 call 指令的下一条指令执行。
 此外，在 call 指令前，主调函数会将被调函数的参数保存到栈上，因此栈帧的图像如下图所示：

栈帧的图像

 这里我们先编写个递归实现斐波那契数列的C++程序，并插入相对应的断点。

#include <iostream>

using namespace std;

int Fib(int n)
{
    if (n == 0)
        return 0;
    else if (n == 1)
        return 1;
    else
        return Fib(n - 1) + Fib(n - 2);
}

int main()
{
   Fib(2); //在该处设置断点，进行调试

    return 0;
}

 下面是对应程序的反汇编代码以及寄存器当前存放的值的图片：

main

fib

寄存器

1.PNG

2.PNG

3.PNG

4.PNG

5.PNG

6.PNG

7.PNG

8.PNG

9.PNG

10.PNG

11.PNG

12.PNG

13.PNG

递归算法时间复杂度分析与求解

 在算法的分析中，当一个算法中包含递归调用时，其时间复杂度的分析会转化成为一个递归方程的求解。而对递归方程的求解，方法多种多样，不一而足。本文主要介绍目前主流的方法：代入法，迭代法，公式法，递归树法。

代入法

 实质上就是数学归纳法，先对一个小的值做假设，然后推测更大的值得正确性。
 1、猜测解的形式；
 2、用数学归纳法求出解中的常数，并证明解是正确的。
 （一）求解递归式T(n) = 2T(n/2)+n
 我们猜测解是O(nlgn),我们要寻找到一个常数c,使得T(n)<=cnlgn
 即T(n) <= 2c(n/2)lg(n/2)+n <= cnlgn-cnlg2+n = cnlgn-cn+n
 只要c>=1,T(n)<=cnlgn,所以我们的猜测是正确的。
 （二）求解递归式T(n) =T(n)=4T(n/2)+n
 我们首先预测时间复杂度为O(n³),,我们要寻找到一个常数c,使得T(n)<=cn³
 即T(n) <= 4T(n/2)+n<=4c(n/2)³+n=(c/2)n³+n=cn³-((c/2)n³-n)
 只要c>=2以及n>=1,T(n)=O(n³),所以我们的猜测是正确的。
 要注意的是，代入法全凭经验，通常用递归树来确定上界，然后用代入法再证明。

迭代法

 迭代法就是迭代的展开方程的右边，直到没有可以迭代的项为止，这时通过对右边的和进行估算来估计方程的解。比较适用于分治问题的求解，为方便讨论起见，给出其递归方程的一般形式：

用迭代法解决的递归方程一般形式

迭代过程

求解

公式法

 这个方法针对形如：T(n) = aT(n/b) + f(n)的递归方程。这种递归方程是分治法的时间复杂性所满足的递归关系，即一个规模为n的问题被分成规模均为n/b的a个子问题，递归地求解这a个子问题，然后通过对这a个子问题的解的综合，得到原问题的解。这种方法是对于分治问题最好的解法。
 对于上述类型的递推公式，我们有以下结论来对其阶进行估计：首先我们根据f(n)的形式不同分成以下两种不同的情况其中c，d为常数：
（1）f(n)=c
（2）f(n)=cn^d
 首先考虑f(n)=c

f(n)=c

f(n)=c*n^d

递归树法

 递归树是一棵结点带权值的树。初始的递归树只有一个结点，它的权标记为T(n)。然后按照递归树的迭代规则不断进行迭代，每迭代一次递归树就增加一层，直到树中不再含有权值为函数的结点【即叶节点都为T(1)】。下面以递归方程来讲述递归树的迭代原则。

T(n)

递归树

参考与部分转载：

1、【算法导论】算法分析：递归式的三种求解方法
2、一文看懂递归
3、x86函数调用过程与栈帧