斐波那契數列的三種時間復雜度

/*前邊兩個為一種做法*/

/*后邊有另外的做法（差分方程以及利用矩陣去做）*/

 

 

//***************************************************//***************************************************//***************************************************

第一種做法

這是2018王道數據結構考研復習指導的第一章思維拓展的題目。

關於斐波那契數列的簡介：

　　斐波那契數列，又稱黃金分割數列，指的是這樣一個數列：0、1、1、2、3、5、8、13、21、34、……在數學上，斐波納契數列以如下被以遞歸的方法定義：F（0）=0，F（1）=1，F（n）=F(n-1)+F(n-2)（n≥2，n∈N*）在現代物理、准晶體結構、化學等領域，斐波納契數列都有直接的應用，為此，美國數學會從1963起出版了以《斐波納契數列季刊》為名的一份數學雜志，用於專門刊載這方面的研究成果。

 

具體題目：

求解斐波那契數列的F(n)有兩種常用算法：遞歸算法和非遞歸算法。試分析兩種算法的時間復雜度。

1.遞歸算法

#include<iostream>
using namespace std;

long Fibonacci(int n) {
    if (n == 0)
        return 0;
    else if (n == 1)
        return 1;
    else
        return Fibonacci(n - 1) + Fibonacci(n-2);
}

int main() {
    cout << "Enter an integer number:" << endl;
    int N;
    cin >> N;
    cout << Fibonacci(N) << endl;
    system("pause");
    return 0;
}

時間復雜度分析：

　　求解F(n),必須先計算F(n-1)和F(n-2),計算F(n-1)和F(n-2)，又必須先計算F(n-3)和F(n-4)。。。。。。以此類推，直至必須先計算F(1)和F(0),然后逆推得到F(n-1)和F(n-2)的結果，從而得到F(n)要計算很多重復的值，在時間上造成了很大的浪費，算法的時間復雜度隨着N的增大呈現指數增長，時間的復雜度為O(2^n)，即2的n次方

2.非遞歸算法

#include<iostream>
using namespace std;

long Fibonacci(int n) {
    if (n <= 2)
        return 1;
    else {
        long num1 = 1;
        long num2 = 1;
        for (int i = 2;i < n - 1;i++) {
            num2 = num1 + num2;
            num1 = num2 - num1;
        }
        return num1 + num2;
    }
}

int main() {
    cout << "Enter an integer number:" << endl;
    int N;
    cin >> N;
    cout << Fibonacci(N) << endl;
    system("pause");
    return 0;
}

時間復雜度分析：

　　　從n(>2)開始計算，用F(n-1)和F(n-2)兩個數相加求出結果，這樣就避免了大量的重復計算，它的效率比遞歸算法快得多，算法的時間復雜度與n成正比，即算法的時間復雜度為O(n).

 

 

 

/**************************************************************************************************************************************************************************************************************/

第二種做法。

應用網址：

https://blog.csdn.net/beautyofmath/article/details/48184331

斐波那契數列: f(n)=f(n-1)+f(n-2); n>=2
f(0)=0; f(1)=1;
即有名的兔子繁衍問題。
斐波那契數列共有三種解法，因而寫這篇文章總結一下。
1. 遞歸求解
遞歸求解比較簡單，是大家常見的一種解法。

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

關於這種解法，不再贅述，下面主要說下時間復雜度分析。
設f(n)為參數為n時的時間復雜度，很明顯：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
最終可得，時間復雜度為：

第一種解法比較簡單，但是多個元素重復計算，因而時間復雜度較高，為了避免重復計算，可進行循環計算減少時間復雜度

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;
min=max;
max=result;
++i;
}
return result;
}

 第二種算法時間復雜度為O(n) 
3. 還有一種時間復雜度更低的算法。 
根據上面的遞歸公式，我們可以得到 

 

因而計算f(n)就簡化為了計算矩陣的(n-2)次方，而計算矩陣的(n-2)次方，我們又可以進行分解，即計算矩陣(n-2)/2次方的平方，逐步分解下去，由於折半計算矩陣次方，因而時間復雜度為O(log n) 
具體代碼實現如下：

 

//
//  main.cpp
//  fibonaccimatrix
//
//  Created by shunagao on 15/8/31.
//  Copyright © 2015年 shunagao. All rights reserved.
//

#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(int argc, const char * argv[]) {
    unsigned int num=2;
    Matrix first(num);
    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) {
            result=result*first;
            }
        first=first*first;
        n=n/2;
    }
    cout<<(result.m[0][0]+result.m[0][1])<<endl;
    return 0;
}