斐波那契数列的几种求解方式及复杂度分析

斐波那契数列:

f(n)=f(n-1)+f(n-2); n>=2
f(0)=0; f(1)=1;
即有名的兔子繁衍问题。

现在我们去面试，面试官要求我们写出求解斐波那契数列指定项的函数，可能乍一听很简单，我们在大一的c语言课上就学过递归求解斐波那契数列的指定项，于是大笔一挥，写下如下的第一种解法：

一、递归求解

int fibonacci(int n)
{
    if (n<=0) {
        return  0;
    }
    if (n==1) {
        return 1;
    }
    return fb(n-1)+fb(n-2);
}

我们考虑了代码的鲁棒性，考虑了n小于0时候的特殊处理，我们也能通过这个函数算出斐波那契数列指定项，但是面试官一定不会满意。我们来分析以下这个代码的缺点：

• 1、递归本质上是栈，当参数达到一定大小的时候会发生栈移出；
• 2、从算法实现上来分析，我们要计算fibonacci(n)就需要计算fibonacci(n-1)和fibonacci(n-2)，计算fibonacci(n-1)需要计算fibonacci(n-2)和fibonacci(n-3)，计算fibonacci(n-2)需要计算fibonacci(n-3)和fibonacci(n-4)…实际上把这个递归算法的递归树画出来，我们会发现很多树结点是重复，也就是我们本来可以不重复计算那么多次
  
  很明显：f(n)=f(n-1)+f(n-2)
  这就转化为了数学上的二阶常系数差分方程，并且为其次方程。
  即转化为了求f(n)的值，f(n)=f(n-1)+f(n-2)且f(0)=0; f(1)=1;
  特征方程为：x^2-x-1=0
  得 x=(1±√5)/2
  因而f(n)的通解为:
  
  由f(0)=0; f(1)=1可解得c_1，c_2
  最终可得
  

因而它的时间复杂度为Ω(ф^n)，其中ф为黄金分割数(√5 + 1)/2，Ω表示算法复杂度最小是这么多。也就是说这个算法的复杂度为指数级的复杂度，指数级的时间复杂度我们怎么能容忍？
因此这样的算法只适合帮助我们理解递归，不适合用来真正求解斐波那契数列。

二、从下往上计算，根据f(0)和f(1)计算出f(2)，根据f(1)和f(2)计算出f(3)，直到计算出第n项——非递归算法

int Fibonacci(int n) 
{
      	if (n<=0) 
      	{
            return 0;
        }
        if (n==1)
        {
            return 1;
        }
        int min=0;
        int max=1;
        int i=2;
        int result=0;
        while (i<=n) 
        {
            result=min+max;//即为F[i]
            min=max;
            max=result;
            ++i;
        }
        return result;
}

使用这种方式，我们杜绝了大量的重复计算。这样优化之后的算法时间复杂度为O(n)，也就是最多为n，明显比递归要好上不少。但是到这里就结束了吗？不是的，我们还有第三种思路。

三、利用数学公式的时间复杂度O(logn)的算法

根据上面的递归公式，我们可以得到

因而计算f(n)就简化为了计算矩阵的(n-2)次方，而计算矩阵的(n-2)次方，我们又可以进行分解，即计算矩阵(n-2)/2次方的平方，逐步分解下去，由于折半计算矩阵次方，因而时间复杂度为 O(log n)

//
//  main.cpp
//  Fibonacci-log(n)
//
//  Created by MacBook Pro on 2022/1/20.
//

#include <iostream>
using namespace std;

class Matrix
{
public:
    int n;
    int **m;
    Matrix(int num)
    {
        m=new int*[num];
        for (int i=0; i<num; i++)
        {
            m[i]=new int[num];
        }
        n=num;
        clear();
    }
    void clear()
    {
        for (int i=0; i<n; ++i)
        for (int j=0; j<n; ++j)
            m[i][j]=0;
    }
    void unit()
    {
        clear();
        for (int i=0; i<n; ++i)//单位阵
            m[i][i]=1;
        
    }
    Matrix operator=(const Matrix mtx)//重载运算符=
    {
        Matrix(mtx.n);
        for (int i=0; i<mtx.n; ++i)
        for (int j=0; j<mtx.n; ++j)
            m[i][j]=mtx.m[i][j];
        return *this;
    }
    Matrix operator*(const Matrix &mtx)//重载运算符*
    {
        Matrix result(mtx.n);
        result.clear();
        for (int i=0; i<mtx.n; ++i) {
            for (int j=0; j<mtx.n; ++j) {
                for (int k=0; k<mtx.n; ++k) {
                    result.m[i][j]+=m[i][k]*mtx.m[k][j];
                }
            }
        }
        return result;
    }
};
int main()
{
    unsigned int num=2;
    Matrix first(num);//建立2*2的矩阵
    first.m[0][0]=1;
    first.m[0][1]=1;
    first.m[1][0]=1;
    first.m[1][1]=0;
    
    int t;
    cin>>t;
    Matrix result(num);
    result.unit();
    int n=t-2;
    while(n)
    {
        if(n%2==1)//奇数
        {
            result=result*first;
        }
        first=first*first;
        n=n/2;
    }
    cout<<(result.m[0][0]+result.m[0][1])<<endl;
    return 0;
}