数据结构和算法面试题系列—递归算法总结

这个系列是我多年前找工做时对数据结构和算法总结，其中有基础部分，也有各大公司的经典的面试题，最先发布在CSDN。现整理为一个系列给须要的朋友参考，若有错误，欢迎指正。本系列完整代码地址在 这里。

注：此刻，我正在从广州回家的绿皮火车上整理的这篇文章，火车摇摇晃晃，颠簸的满是乡愁，忍不住又想翻翻周云蓬的《绿皮火车》了。———记于2018年9月30日夜22:00分。

0 概述

前面总结了随机算法，此次再把之前写的递归算法的文章梳理一下，这篇文章主要是受到宋劲松老师写的《Linux C编程》的递归章节启发写的。最能体现算法精髓的非递归莫属了，但愿这篇文章对初学递归或者对递归有困惑的朋友们能有所帮助，若有错误，也恳请各路大牛指正。二叉树的递归示例代码请参见仓库的 binary_tree 目录，本文其余代码在 这里。

1 递归算法初探

本段内容主要摘自《linux C一站式编程》，做者是宋劲松老师，这是我以为目前看到的国内关于Linux C编程的最好的技术书籍之一，强烈推荐下！

关于递归的一个简单例子是求整数阶乘，n!=n*(n-1)!，0!=1 。则能够写出以下的递归程序：

int factorial(int n)
{
	if (n == 0)
		return 1;
	else {
		int recurse = factorial(n-1);
		int result = n * recurse;
		return result;
	}
}
复制代码

factorial这个函数就是一个递归函数，它调用了它本身。本身直接或间接调用本身的函数称为递归函数。若是以为迷惑，能够把 factorial(n-1) 这一步当作是在调用另外一个函数－－另外一个有着相同函数名和相同代码的函数，调用它就是跳到它的代码里执行，而后再返回 factorial(n-1) 这个调用的下一步继续执行。

为了证实递归算法的正确性，咱们能够一步步跟进去看执行结果。记得刚学递归算法的时候，总是有丈二和尚摸不着头脑的感受，那时候老是想着把递归一步步跟进去看执行结果。递归层次少还算好办，可是层次一多，头就大了，彻底不知道本身跟到了递归的哪一层。好比求阶乘，若是只是factorial(3)跟进去问题还不大，可是如果factorial(100)要跟进去那真的会烦死人。

事实上，咱们并非每一个函数都须要跟进去看执行结果的，好比咱们在本身的函数中调用printf函数时，并无钻进去看它是怎么打印的，由于咱们相信它能完成打印工做。 咱们在写factorial函数时有以下代码：

int recurse = factorial(n-1);
int result = n * recurse;
复制代码

这时，若是咱们相信factorial是正确的，那么传递参数为n-1它就会返回(n-1)!，那么result=n*(n-1)!=n!，从而这就是factorial(n)的结果。

固然这有点奇怪：咱们还没写完factorial这个函数，凭什么要相信factorial(n-1)是正确的？若是你相信你正在写的递归函数是正确的，并调用它，而后在此基础上写完这个递归函数，那么它就会是正确的，从而值得你相信它正确。

这么说仍是有点玄乎，咱们从数学上严格证实一下 factorial 函数的正确性。刚才说了，factorial(n) 的正确性依赖于 factorial(n-1) 的正确性，只要后者正确，在后者的结果上乘个 n 返回这一步显然也没有疑问，那么咱们的函数实现就是正确的。所以要证实factorial(n) 的正确性就是要证实 factorial(n-1) 的正确性，同理，要证实factorial(n-1) 的正确性就是要证实 factorial(n-2) 的正确性，依此类推下去，最后是：要证实 factorial(1) 的正确性就是要证实 factorial(0) 的正确性。而factorial(0) 的正确性不依赖于别的函数调用，它就是程序中的一个小的分支return 1; 这个 1 是咱们根据阶乘的定义写的，确定是正确的，所以 factorial(1) 的实现是正确的，所以 factorial(2) 也正确，依此类推，最后 factorial(n) 也是正确的。

其实这就是在中学时学的数学概括法，用数学概括法来证实只须要证实两点：Base Case正确，递推关系正确。写递归函数时必定要记得写Base Case，不然即便递推关系正确，整个函数也不正确。若是 factorial 函数漏掉了Base Case，那么会致使无限循环。

2 递归经典问题

从上一节的一个关于求阶乘的简单例子的论述，咱们能够了解到递归算法的精髓：要从功能上理解函数，同时你要相信你正在写的函数是正确的，在此基础上调用它，那么它就是正确的。 下面就从几个常见的算法题来看看如何理解递归，这是个人一些理解，欢迎你们提出更好的方法。

2.1）汉诺塔问题

题： 汉诺塔问题是个常见问题，就是说有n个大小不等的盘子放在一个塔A上面，自底向上按照从大到小的顺序排列。要求将全部n个盘子搬到另外一个塔C上面，能够借助一个塔B中转，可是要知足任什么时候刻大盘子不能放在小盘子上面。

解： 基本思想分三步，先把上面的 N-1 个盘子经 C 移到 B，而后将最底下的盘子移到 C，再将 B 上面的N-1个盘子经 A 移动到 C。总的时间复杂度 f(n)=2f(n-1)+1，因此 f(n)=2^n-1。

/**
 * 汉诺塔
 */
void hano(char a, char b, char c, int n) {
    if (n <= 0) return;

    hano(a, c, b, n-1);
    move(a, c);
    hano(b, a, c, n-1);
}

void move(char a, char b)
{
    printf("%c->%c\n", a, b);
}
复制代码

2.2）求二叉树的深度

这里的深度指的是二叉树从根结点到叶结点最大的高度，好比只有一个结点，则深度为1，若是有N层，则高度为N。

int depth(BTNode* root)  
{  
    if (root == NULL)  
        return 0;  
    else {  
        int lDepth = depth(root->left);  //获取左子树深度  
        int rDepth = depth(root->right); //获取右子树深度  
        return lDepth>rDepth? lDepth+1: rDepth+1; //取较大值+1即为二叉树深度  
    }  
}  
复制代码

那么如何从功能上理解 depth 函数呢？咱们能够知道定义该函数的目的就是求二叉树深度，也就是说咱们要是完成了函数 depth，那么 depth(root) 就能正确返回以 root 为根结点的二叉树的深度。所以咱们的代码中 depth(root->left) 返回左子树的深度，而depth(root->right) 返回右子树的深度。尽管这个时候咱们尚未写完 depth 函数，可是咱们相信 depth 函数可以正确完成功能。所以咱们获得了 lDepth 和rDepth，然后经过比较返回较大值加1为二叉树的深度。

若是很差理解，能够想象在 depth 中调用的函数 depth(root->left) 为另一个一样名字完成相同功能的函数，这样就好理解了。注意 Base Case，这里就是当 root==NULL 时，则深度为0，函数返回0。

2.3）判断二叉树是否平衡

一颗平衡的二叉树是指其任意结点的左右子树深度之差不大于1。判断一棵二叉树是不是平衡的，可使用递归算法来实现。

int isBalanceBTTop2Down(BTNode *root)
{
    if (!root) return 1;

    int leftHeight = btHeight(root->left);
    int rightHeight = btHeight(root->right);
    int hDiff = abs(leftHeight - rightHeight);

    if (hDiff > 1) return 0;

    return isBalanceBTTop2Down(root->left) && isBalanceBTTop2Down(root->right);
}
复制代码

该函数的功能定义是二叉树 root 是平衡二叉树，即它全部结点的左右子树深度之差不大于1。首先判断根结点是否知足条件，若是不知足，则直接返回 0。若是知足，则须要判断左子树和右子树是否都是平衡二叉树，若都是则返回1，不然0。

2.4）排列算法

排列算法也是递归的典范，记得当初第一次看时一层层跟代码，头都大了，如今从函数功能上来看确实好理解多了。先看代码：

/**
 * 输出全排列，k为起始位置，n为数组大小
 */
void permute(int a[], int k, int n)
{
    if (k == n-1) {
        printIntArray(a, n); // 输出数组
    } else {
        int i;
        for (i = k; i < n; i++) {
            swapInt(a, i, k); // 交换
            permute(a, k+1, n); // 下一次排列
            swapInt(a, i, k); // 恢复原来的序列
        }
    }
}
复制代码

首先明确的是 perm(a, k, n) 函数的功能:输出数组 a 从位置 k 开始的全部排列，数组长度为 n。这样咱们在调用程序的时候，调用格式为 perm(a, 0, n)，即输出数组从位置 0 开始的全部排列，也就是该数组的全部排列。基础条件是 k==n-1，此时已经到达最后一个元素，一次排列已经完成，直接输出。不然，从位置k开始的每一个元素都与位置k的值交换(包括本身与本身交换)，而后进行下一次排列，排列完成后记得恢复原来的序列。

假定数组a aan na a =3，则程序调用 perm(a, 0, 3) 能够以下理解： 第一次交换 0，0，并执行perm(a, 1, 3)，执行完再次交换0，0，数组此时又恢复成初始值。 第二次交换 1，0（注意数组此时是初始值），并执行perm(a, 1, 3), 执行完再次交换1，0，数组此时又恢复成初始值。 第三次交换 2，0，并执行perm(a, 1, 3)，执行完成后交换2，0，数组恢复成初始值。

也就是说，从功能上看，首先肯定第0个位置，而后调用perm(a, 1, 3)输出从1开始的排列，这样就能够输出全部排列。而第0个位置可能的值为a[0], a[1],a[2]，这经过交换来保证第0个位置可能出现的值，记得每次交换后要恢复初始值。

如数组 a={1,2,3}，则程序运行输出结果为：1 2 3 ，1 3 2 ，2 1 3 ，2 3 1 ，3 2 1 ，3 1 2。即先输出以1为排列第一个值的排列，然后是2和3为第一个值的排列。

2.5）组合算法

组合算法也能够用递归实现，只是它的原理跟0-1背包问题相似。即要么选要么不选，注意不能选重复的数。完整代码以下：

/*
 * 组合主函数，包括选取1到n个数字
 */ 
void combination(int a[], int n)
{
    int *select = (int *)calloc(sizeof(int), n); // select为辅助数组，用于存储选取的数
    int k;
    for (k = 1; k <= n; k++) {
        combinationUtil(a, n, 0, k, select);
    }
}

/*
 * 组合工具函数：从数组a从位置i开始选取k个数
 */
void combinationUtil(int a[], int n, int i, int k, int *select)
{
    if (i > n) return; //位置超出数组范围直接返回，不然非法访问会出段错误

    if (k == 0) {  //选取完了，输出选取的数字
        int j;
        for (j = 0; j < n; j++) {
            if (select[j])
                printf("%d ", a[j]);
        }
        printf("\n");
    } else {
        select[i] = 1;  
        combinationUtil(a, n, i+1, k-1, select); //第i个数字被选取，从后续i+1开始选取k-1个数
        select[i] = 0;
        combinationUtil(a, n, i+1, k, select); //第i个数字不选，则从后续i+1位置开始还要选取k个数
    }
}
复制代码

2.6) 逆序打印字符串

这个比较简单，代码以下：

void reversePrint(const char *str) 
{
    if (!*str)
        return;

    reversePrint(str + 1);
    putchar(*str);
}
复制代码

2.7) 链表逆序

链表逆序一般咱们会用迭代的方式实现，可是若是要显得特立独行一点，可使用递归，以下，代码请见仓库的 aslist 目录。

/**
 * 链表逆序，递归实现。
 */
ListNode *listReverseRecursive(ListNode *head)
{
    if (!head || !head->next) {
        return head;
    }

    ListNode *reversedHead = listReverseRecursive(head->next);
    head->next->next = head;
    head->next = NULL;
    return reversedHead;
}
复制代码

参考资料

• 宋劲松老师《Linux C编程》递归章节
• 数据结构与算法-C语言实现