斐波那契数列三种解法及分析

什么是斐波那契数列？

       一个函数．输入n，将返回斐波那契(Fibonacci)数列的第n项。波那契数列的定义如下

           F(0) = 0;

           F(1) = 1;

           F(n) = F(n-1) + F(n-2) n>1;

       解法一：效率低下

       很多C语言教科书在讲述递归函数的时候，都会用Fibonacci作为例子，因此很多同学对该数列的递归解法都很熟悉。他们看到这个算法解法的时候心中会忍不住一阵窃喜，于是能很快写出如F代码：

long long Fibonacci_Solution1(unsigned int n)
{
    if (n <= 0)
        return 0;

    if (n == 1)
        return 1;

    return Fibonacci_Solution1(n - 1) + Fibonacci_Solution1(n - 2);
}

       我们的教科书上反复用这个问题来讲解递归函数，并不能说明递归的解法最适合这道题目。于是在面试的时候，面试官会提示我们，上述递归的解法有很严重的效率问题并要求我们分析原因。

       我们以求解f(10)为例来分析递归的求解过程。想求得f(10)，需要先求得f(9)和f(8)。同样，想求得f(9)，需要先求得f(8)和f(7)……我们可以用树形结构来表示这种依赖关系，如图所示。

       我们不难发现在这棵树中有很多结点是重复的，而且重复的结点数会随着n的增大而急剧增加，这意味计算量会随着n的增大而急剧增大。事实上，用递归方法计算的时间复杂度是以n的指数的方式递增的。读者不妨求Fibonacci的第100项试试，感受一下这样递归会慢到什么程度。

       解法二：时间复杂度为O(n),着重推荐

       其实改进的方法并不复杂。上述递归代码之所以慢是因为重复的计算太多，我们只要想办法避免重复计算就行了。比如我们可以把已经得到的数列中问项保存起来，如果下次需要计算的时候我们先查找一下，如果前面已经计算过就不用再重复计算了。

       更简单的办法是从下往上计算，首先根据f(0)和f(1)算出f(2)，再根据f(1)和f(2)算出f(3)……依此类推就可以算出第n项了。很容易理解，这种思路的时间复杂度是O(n)。实现代码如下：

long long Fibonacci_Solution2(unsigned n)
{
    int result[2] = {0, 1};
    if (n < 2)
        return result[n];

    long long  fibNMinusOne = 1;
    long long  fibNMinusTwo = 0;
    long long  fibN = 0;
    for (unsigned int i = 2; i <= n; ++ i)
    {
        fibN = fibNMinusOne + fibNMinusTwo;

        fibNMinusTwo = fibNMinusOne;
        fibNMinusOne = fibN;
    }

     return fibN;
}

       解法三：时间复杂度为O(logn),但不实用。

       尽管我们还有比这更快的O(logn)算法。由于这种算法需要用到一个很生僻的数学公式，因此很少有面试官会要求我们掌握。不过以防不时之需，我们还是简要介绍一下这种算法。

       在介绍这种方法之前，我们先介绍一个数学公式：

       这个公式用数学归纳法不难证明，感兴趣的读者不妨自己证明一下。有了这个公式，我们只需要求得矩阵即可得到f(n)。现在的问题转为如何求矩阵的乘方。如果只是简单地从0开始循环，n次方需要n次运算，那其时间复杂度仍然是O(n)，并不比前面的方法快。但我们可以考虑乘方的如下性质：

   从上面的公式我们可以看出，我们想求得n次方，就要先求得n/2次方，再把n/2次方的结果平方一下即可。这可以用递归的思路实现。代码如下：

#include

struct Matrix2By2
{
    Matrix2By2
    (
        long long m00 = 0,
        long long m01 = 0,
        long long m10 = 0,
        long long m11 = 0
    )
    :m_00(m00), m_01(m01), m_10(m10), m_11(m11)
    {
    }

    long long m_00;
    long long m_01;
    long long m_10;
    long long m_11;
};

Matrix2By2 MatrixMultiply
(
    const Matrix2By2& matrix1,
    const Matrix2By2& matrix2
)
{
    return Matrix2By2(
        matrix1.m_00 * matrix2.m_00 + matrix1.m_01 * matrix2.m_10,
        matrix1.m_00 * matrix2.m_01 + matrix1.m_01 * matrix2.m_11,
        matrix1.m_10 * matrix2.m_00 + matrix1.m_11 * matrix2.m_10,
        matrix1.m_10 * matrix2.m_01 + matrix1.m_11 * matrix2.m_11);
}

Matrix2By2 MatrixPower(unsigned int n)
{
    assert (n > 0);

    Matrix2By2 matrix;
    if (n == 1)
    {
        matrix = Matrix2By2(1, 1, 1, 0);
    }
    else if (n % 2 == 0)
    {
        matrix = MatrixPower(n / 2);
        matrix = MatrixMultiply(matrix, matrix);
    }
    else if (n % 2 == 1)
    {
        matrix = MatrixPower((n - 1) / 2);
        matrix = MatrixMultiply(matrix, matrix);
        matrix = MatrixMultiply(matrix, Matrix2By2(1, 1, 1, 0));
    }

    return matrix;
}

long long Fibonacci_Solution3(unsigned int n)
{
    int result[2] = {0, 1};
    if (n < 2)
        return result[n];

    Matrix2By2 PowerNMinus2 = MatrixPower(n - 1);
    return PowerNMinus2.m_00;
}

       解法比较：用不同的方法求解斐波那契数列的时间效率大不相间。第一种基于递归的解法虽然直观但时间效率很低，在实际软件开发中不会用这种方法，也不可能得到面试官的青睐。第二种方法把递归的算法用循环实现，极大地提高了时间效率。第三种方法把求斐波那契数列转换成求矩阵的乘方，是一种很有创意的算法。虽然我们可以用 O(logn)求得矩阵的n次方，但由于隐含的时间常数较大，很少会有软件采用这种算法。另外。实现这种解法的代码也很复杂，因此第三种方法不是一种实用的算法。

 public class Fibonacci {
    public static void main(String[] args) {
        int n = 4;
        System.out.println(getFibonacci(n));
    }
   
    public static  long getFibonacci(int n) {
        if( n < 0 )
            return -1;
           
        int[] result = {0, 1};
        if(n < 2)
            return result[n];
     
        long  fibN1 = 0;
        long  fibN2 = 1;
        long  fibN = 0;
        for(int i = 2; i <= n; i++) {
            fibN = fibN1 + fibN2;
            fibN1 = fibN2;
            fibN2 = fibN;
        }
     
         return fibN;
    }
}