斐波那契数列

前言

什么是斐波那契数列？
斐波那契数列（Fibonacci数列）是数学家斐波那契以研究兔子繁殖为例研究的数列，故称“兔子数列”，又称为黄金分割数列。 它的一提出就受到了社会的广泛关注，经过研究之后人们发现了这个神奇的数列有着不可估量的重要作用。1,1,2,3,5,8,13…这样一个数列就是斐波那契数列。

一、C语言实现：

输出斐波那契数列前n个数字：
1、普通算法

#include <stdio.h>

const int test2(void);

int main(void)
{
    while(1)
    {    
        int flag = test2();
        if(flag != 1)    break;
    }
    return 0;
}

const int test2(void)
{
    int t1 = 1, t2 = 1, n, next, i;
    
    printf("How many:");
    scanf("%d", &n);
    
    if(n <= 0)
    {
        printf("Program Terminated!\n");
        return -1;
    }
    
    for(i = 1; i <= n; i++)
    {
        printf("%d ", t1);
        next = t1 + t2;
        t1 = t2;
        t2 = next;
    }
    printf("\n");
    return 1;
}

2、递归实现

#include <stdio.h>

const int test3(const int);
const int test5(void);

int main(void)
{
    while(1)
    {    
        int flag = test5();
        if(flag != 1)    break;
    }
    return 0;
}

/* 使用递归方式 */
const int test3(const int index)
{
    if(index == 1 || index == 2)    return 1;
    return (test3(index -1) + test3(index -2));
}

const int test5(void)
{
    int i, n;
    printf("How many:");
    scanf("%d", &n);
    
    if(n <= 0)
    {
        printf("Program Terminated!\n");
        return -1;
    }
    
    for(i = 1; i <= n; i++)    
    {
        printf("%d ", test4(i));
    }
    printf("\n");
    return 1;
}

用递归的方法实现此数列简洁，方便理解。但是我们仔细观察上面的代码，就会发现此函数中存在着大量的冗余计算，并且n越大，冗余的越多。
输出数列中小于等于Max的数字

#include <stdio.h>

const int test6(void);

int main(void)
{
    while(1)
    {    
        int flag = test6();
        if(flag != 1)    break;
    }
    return 0;
}

const int test6(void)
{
    int t1  =1, t2 = 1, next, Max;
    
    printf("Max: ");
    scanf("%d", &Max);
    
    if(Max <= 0)
    {
        printf("Program Terminated!\n");
        return -1;
    }
    
    while(t1 <= Max)
    {
        printf("%d ", t1);
        next = t1 + t2;
        t1 = t2;
        t2 = next;
    }
    printf("\n");
    return 1;
}

二、 青蛙跳台阶

青蛙跳台阶问题就是斐波那契数列的实际应用，用递归的思路来解决

一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法。
分析如下：

1.假如现在台阶只有 1 级，n = 1，那么这只青蛙就在只有 1 种跳法：1（1 代表一次跳 1 级台阶）也就是 f(1) = 1 种跳法。
2.假如现在台阶只有 2 级，n = 2，那么这只青蛙可以有 2 种跳法：1 1、2（1 代表一次跳 1 级台阶，2 代表一次跳 2 级台阶），也就是 f(2) = 2 种跳法。
3.假如现在台阶有 3 级，n = 3，青蛙可以有几种跳法呢？
假如青蛙先跳了 1 级台阶，还剩下 2 级台阶，那它还有几种跳法呢？通过第 2 个情况分析知道有 2 种跳法；假如青蛙先跳了 2 级台阶，根据第 1 个情况分析知道有 1 种跳法，所以这时候得出 f(3) = 2 + 1 种方法。
4.假如现在台阶有 4 级，n = 4，我们利用上面的规律继续分析可得：f(4) = 3 + 2
综上所述，我们得出其实这个算法就是一个（变形）斐波那契数列问题，公式如下：

• n = 1, f(1) = 1 n = 2,
• f(2) = 2 n > 2,
• f(n) = f(n -1) + f(n -2)
所以至此明白了，青蛙跳台阶问题就是一个（变形）斐波那契数列问题。

#include <stdio.h>
/* 优化后的方法 */
long long Fibonacci(unsigned n)
{
    int result[2] = {0, 1, 2};
    if(n <= 2)
        return result[n];
    
    long long  fibNMinusOne = 2;
    long long  fibNMinusTwo = 1;
    long long  fibN = 0;
    for(unsigned int i = 3; i <= n; ++ i)
    {
        fibN = fibNMinusOne + fibNMinusTwo;
        
        fibNMinusTwo = fibNMinusOne;
        fibNMinusOne = fibN;
    }
    
    return fibN;
}

int main(int argc, const char * argv[]) {
    clock_t start, finish;
    double  duration;
    /* 测量一个事件持续的时间*/
    /* 起始 */
    start = clock();
    /* 要执行的代码，放在此处（两个clock方法的调用中间），方便测试出要执行的代码的执行时间 */
    printf("%lld\n", Fibonacci(11));
    /* 结束 */
    finish = clock();
    /* 时间 */
    duration = (double)(finish - start) / CLOCKS_PER_SEC;
    printf( "Use time is %f seconds.\n", duration );
    return 0;
}

tips：青蛙跳台阶与斐波那契数列有一点不同的是当n = 2时的结果不同，所以部分代码存在差别，但大思路是不变的。

总结

我们要充分理解递归和循环的思想, 在使用递归的时候, 虽然它的代码很简单, 易于理解, 但是如果数据量大的情况下, 它会有很严重的性能问题, 耗时也会指数增长. 所有的递归解法, 我们都可以转换成循环思想来替代实现. 因此我们要慎用递归, 巧用循环.