递归算法讲解和应用

说明       

       所谓递归，其实就是一个函数调用自身的一种方法。递归可以很大程度地缩短代码，使用较少的代码实现较复杂的问题。

       以前刚学习递归的时候总是感觉很难理解，配合实践后总算对递归有了一点的了解。递归的过程就是我们学英语时学习新单词一样的过程。即可以把递归过程比喻成“查单词”，当开始查一个单词，在单词的英文解析里发现又有新单词不认识，然后再查次单词；发现查的单词里又有不认识的单词，接着再次往下查，依次类推，终于查到了所有词都认识的结果；最后一步一步反向往上认识所查的单词，直到认识刚开始查的单词。

例1：

求n的阶乘

#include <iostream>
using namespace std;

int factorial(int n){
        if(n<1){
                cout << "parameter failed.";
                return 0;
        }
        return (n == 1) ? 1:n*factorial(n-1);
}

int main(){
        int n=0;
        cin >> n;
        cout << factorial(n);
        return 0;
}

设n输入5，这个推导过来如下所示：

1  ===> factorial(5)

2  ===> 5 * factorial(4)

3  = ==> 5 * (4 * factorial(3))

4  ===> 5 * (4 * (3 * factorial(2)))

5  ===> 5 * (4 * (3 * (2 * factorial(1))))

6  ===> 5 * (4 * (3 * (2 * 1)))

7  ===> 5 * (4 * (3 * 2))

8  ===> 5 * (4 * 6)

9  ===> 5 * 24

10===> 120

可以看出递归的过程就像是出入栈的过程，例中的1-5都是入栈过程，factorial(5)调用factorial(4)，依次类催，入栈的深度=5。6-10是出栈过程，factorial(1)做完出栈，factorial(2)做完出栈，重复做下去，最后计算出factorial(5)=120；这个过程就是不断从无知问到已知，再从已知一步步推出刚提出的无知，即factorial(5)问factorial(4)直到factorial(1)是已知的，然后在往回推出factorial(5)；

例2：

求n对应的斐波纳契数

# include <bits/stdc++.h>
using namespace std;

long fibonacci_v1(int n){
        times++;
        if(n<0) {
                cout << "parameter error.";
                return -1;
        }
        if(n==0)return 0;
        if(n==1)return 1;
        return fibonacci_v1(n-1)+fibonacci_v1(n-2);
}

n=5时：

fibonacci_v1

result:5

times:15 runTime:0.01ms

结果显示当n=5时，递归了15次，计算结果只用了0.01ms，表现还是可以的，其对应的递归树如下所示：

 

即：f(5)

=f(4)+f(3)=f(3)+f(2)+f(2)+f(1)

=f(2)+f(1)+f(1)+f(0)+f(1)+f(0)+f(1)

=f(1)+f(0)+f(1)+f(1)+f(0)+f(1)+f(0)+f(1)

=5

从图中可以看出有些过程调用了多次，如f(3)有两次，f(2)有三次；当n增大时，相同过程重复次数将变得越来越多，从而性能将会大打折扣。

当n=45时：

fibonacci_v1

result:1134903170

times:3672623805 runTime:23698.3ms

可以看出递归次数高达36亿多次，执行时间也长达23秒多，时间复杂度为O(2^n)，显然n较大时不适合使用次方法。我们需要对此方法进行改进，根据递归树得知很多过程是重复的，我们可以利用数组保存这些重复过程，然后判断如果此过程已经计算则直接返回，从而得出V2版本：

long fibonacci_v2(int n){
        times++;
        if(n<0) {
                cout << "parameter error.";
                return -1;
        }
        if(n==0)return 0;
        if(n==1)return 1;
        if(fib_value[n] == -1){
                fib_value[n] = fibonacci_v2(n-1)+fibonacci_v2(n-2);
        }
        return fib_value[n];
}

同样测试n=45时：

fibonacci_v2

result:1134903170

times:89 runTime:0.054ms

同样是n=45，两个版本不管是从递归次数还是从执行时间，v2版本都远远比v1版本要小很多。时间复杂度也从O(2^n)变成O(n)。其实v2版本实际上是利用了动态规划算法进行求解。

       动态规划（ dynamic programming ）算法是解决多阶段决策过程最优化问题的一种常用方法，难度比较大，技巧性也很强。利用动态规划算法，可以优雅而高效地解决很多贪婪算法或分治算法不能解决的问题。动态规划算法的基本思想是：将待求解的问题分解成若干个相互联系的子问题，先求解子问题，然后从这些子问题的解得到原问题的解；对于重复出现的子问题，只在第一次遇到的时候对它进行求解，并把答案保存起来，让以后再次遇到时直接引用答案，不必重新求解。《定义来自网络》