递归算法总结

最新推荐文章于 2021-10-08 10:34:25 发布

深夜程序猿

最新推荐文章于 2021-10-08 10:34:25 发布

阅读量2.4k

点赞数 1

分类专栏：算法，数据结构文章标签：递归斐波那契数列算法

算法，数据结构专栏收录该内容

8 篇文章 0 订阅

订阅专栏

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) {
        hano(a, c, b, n-1);
        move(a, c);
        hano(b, a, c, n-1);
    }
}

void move(char a, char b)
{
    cout << a << "->" << b << endl;
}

2.2）求二叉树的深度

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

int depth(struct node* 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。判断一棵二叉树是否是平衡的，可以使用递归算法来实现。

bool is_balanced(BinaryTreeNode* pRoot)
{
    if(pRoot == NULL) //基本情况，为空的话，返回true
        return true;
 
    int left = depth(pRoot->m_pLeft);
    int right = depth(pRoot->m_pRight);
    int diff = left - right; //计算左右子树深度之差
    if(diff > 1 || diff < -1) //如果深度之差大于1返回false
        return false;
 
    return is_balanced(pRoot->m_pLeft) && is_balanced(pRoot->m_pRight); //递归判断左右子树，注意是&&，即左右子树都必须是平衡的这棵二叉树才是平衡的
}

该函数的功能定义是二叉树pRoot是平衡二叉树，即它所有结点的左右子树深度之差不大于1。首先判断根结点是否满足条件，如果不满足，则直接返回false。如果满足，则需要判断左子树和右子树是否都是平衡二叉树，若都是则返回true，否则false。

上面代码性能不高，会重复遍历结点，一个改进的算法是采用后序遍历的方式遍历树的结点，在遍历到本结点前我们已经遍历完了它的左右子树，我们只需要在遍历的时候记录结点的深度，就可以一边遍历一边判断该结点是否是平衡的。代码如下：

bool is_balanced_2(BinaryTreeNode* pRoot, int* pDepth)
{
    if(pRoot == NULL)
    {
        *pDepth = 0;
        return true;
    }
 
    int left, right;
    if(is_balanced_2(pRoot->m_pLeft, &left) //左子树平衡
        && is_balanced_2(pRoot->m_pRight, &right)) //右子树平衡
    {
        int diff = left - right;
        if(diff <= 1 && diff >= -1)
        {
            *pDepth = 1 + (left > right ? left : right);
            return true;
        }
    }
 
    return false;
}

该函数功能定义是返回以pRoot为根的二叉树是否是平衡二叉树，同时把树的深度保存在pDepth指向的值中。基本情况是树为NULL，则深度为0，返回true。否则只有左右子树都是平衡的情况下，深度分别存在变量left和right中，判断左右子树的深度之差是否不大于1，如果是则返回true，注意还要设置树的深度值。

调用的函数定义如下：

bool IsBalanced(BinaryTreeNode* pRoot)
{
    int depth = 0;
    return is_balanced_2(pRoot, &depth);
}

2.4）排列算法

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

void perm(int a[], int k, int N) { //k为起始位置，N为数组大小
    if (k == N-1) { 
        output(a, N); //输出排列
    } else {
        for (int i=k; i<N; i++) {
            swap(a, i, k); //交换
            perm(a, k+1, N); //下一次排列
            swap(a, i, k); //恢复原来的序列
        }
    }
}

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

假定数组a大小N=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背包问题类似。即要么选要么不选，注意不能选重复的数。完整代码如下：

#include<iostream>
using namespace std;
#define N 3  //数组大小为3
int select[N] = {0}; //选择数组，用于存储数组哪些数字被选中。
/*输出数组中选中的数*/
void output(int a[], int n)
{
    for (int i=0; i<n; i++) {
        if (select[i])
            cout << a[i] << " ";
    }
    cout << endl;
}
/*数组a从位置i开始选取k个数*/
void combination(int a[], int i, int k)
{
    if (i > N) return; //位置超出数组范围直接返回，否则非法访问会出段错误
    if (k == 0) {  //选取完了，输出选取的数字
        output(a, N);
    } else {
        select[i] = 1;  
        combination(a, i+1, k-1); //第i个数字被选取，从后续i+1开始选取k-1个数
        select[i] = 0;
        combination(a, i+1, k); //第i个数字不选，则从后续i+1位置开始还要选取k个数
    }
}

/*组合主函数，包括选取1到n个数字*/
void combination_helper(int a[], int n) {
    for (int k=1; k<=n; k++) {
        combination(a, 0, k);
    }
}

int main()
{
    int a[N] = {1, 2, 3};
    combination_helper(a, N);
    return 0;
}

2.6) 逆序打印字符串

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

void printReverse(const char *str) {
  if (!*str)
    return;
  printReverse(str + 1);
  putchar(*str);
}

3 多说一句

对递归有兴趣的，还可以看看这篇文章，用递归实现链表逆序。

参考资料

宋劲松《Linux C编程》递归章节

--------------------------------------------------------------------------------------------------------------------------------------------------

递归实现斐波那契数列（一）：

在数学上，斐波纳契数列以如下被以递归的方法定义：
F（0）=0，F（1）=1，F（n）=F(n-1)+F(n-2)（n≥2，n∈N*）

使用递归实现
很直观表示方式，用递归很容易实现：

function f($a)
{
if ($a == 0 || $a == 1) {
return 1;
}
return f($a-1) + f($a-2);
}

for($i = 0; $i < 70; ++$i)
{
echo f($i).' ';
}
1
2
3
4
5
6
7
8
9
10
11
12
但是运行的时候，发现上面代码运行会超时：

递归其实是方便了程序员难为了机器。它只要得到数学公式就能很方便的写出程序。优点就是易理解，容易编程。但递归是用栈机制实现的，每深入一层，都要占去一块栈数据区域，对嵌套层数深的一些算法，递归会力不从心，空间上会以内存崩溃或超时而告终，而且递归也带来了大量的函数调用，这也有许多额外的时间开销。所以在深度大时，它的时空性就不好了。

那么如果非要用递归，有什么办法可以改进呢？

可以看到，在打印的过程中，比如求 f(6) 调用 f(5) 和 f(4)时，之前的某次循环其实已经算出来了 f(5) 和 f(4) ，不需要再算了。

可以使用一个数组，来保存之前的结果

使用循环实现
<?php
$arr[1] = 1;
for($i = 2;$i < 100;$i++)
{
$arr[$i] = $arr[$i-1] + $arr[$i-2];
}
echo join(",",$arr); //将数组合并为一个字符串输出
?>
1
2
3
4
5
6
7
8
非递归实现比递归效率高很多。

递归和循环的简单比较：
1、从程序上看，递归表现为自己调用自己，循环则没有这样的形式。
2、递归是从问题的最终目标出发，逐渐将复杂问题化为简单问题，并且简单的问题的解决思路和复杂问题一样，同时存在基准情况，就能最终求得问题，是逆向的。而循环是从简单问题出发，一步步的向前发展，最终求得问题，是正向的。
3、任意循环都是可以用递归来表示的，但是想用循环来实现递归（除了单向递归和尾递归），都必须引入栈结构进行压栈出栈。
4、一般来说，非递归的效率高于递归。而且递归函数调用是有开销的，递归的次数受堆栈大小的限制。

递归实现斐波那契数列（二）：

简介
斐波那契数列（Fibonacci Sequence），又称黄金分割数列，指的是这样一个数列：1、1、2、3、5、8、13、21、……在数学上，斐波纳契数列以如下被以递归的方法定义：F0=0，F1=1，Fn=F(n-1)+F(n-2)（n>=2，n∈N*）。我用递归和迭代两种方法实现了斐波那契数列

实现代码(php)
<?php

class Fibonacci
{

/**
* Description:迭代方法获取fibonacci第n项数值
*
* @param int $n
* @return int
*/
public static function fib_interation ($n)
{
$fib = array(); // 定义fibonacci数组

if ($n < 0) {
return 0;
}

for ($fib[0] = 0, $fib[1] = 1, $i = 2; $i <= $n; $i ++) {
$fib[$i] = $fib[$i - 1] + $fib[$i - 2];
}

return $fib[$n];
}

/**
* Description:递归方法获取fibonacci第n项数值
*
* @param int $n
* @return int
*/
public static function fib_recursive ($n)
{
if ($n <= 0) {
return 0;
} elseif ($n == 1) {
return 1;
} else {
return self::fib_recursive($n - 1) + self::fib_recursive($n - 2);
}
}
}

$fib1 = Fibonacci::fib_interation(5);
echo $fib1 . "\n";

$fib2 = Fibonacci::fib_recursive(10);
echo $fib2 . "\n";

?>

运行结果

缺点
今天看道这篇博客浏览量还挺高，因此重构了一下代码，半年前的水平确实差，代码看着就恶心，今天重构一下！
其次，编程之美上介绍了一种分治策略求fibonacci的方法，不过我没掌握，有兴趣的同学可以贴出实现代码讨论一下，建议c或者php！

深夜程序猿

关注

1
点赞
踩
16

收藏

觉得还不错? 一键收藏
0
评论
递归算法总结

1 递归算法初探本段内容大部分摘自《linux C一站式编程》，作者是宋劲松老师，我认为这是目前看到的国内关于linux C编程的最好的一本技术书籍，强烈推荐！关于递归的一个简单例子是求整数阶乘，n!=n*(n-1)!，0!=1 。则可以写出如下的递归程序：int factorial(int n){ if (n == 0) return 1; els...
复制链接

扫一扫