斐波那契數與二分法的遞歸與非遞歸算法及其複雜度分析

1. 什麼是斐波那契數？

這裏我借用百度百科上的解釋：斐波那契數，亦稱之爲斐波那契數列（意大利語： Successione di Fibonacci)，又稱黃金分割數列、費波那西數列、費波拿契數、費氏數列，指的是這樣一個數列：0、一、一、二、三、五、八、1三、2一、……在數學上，斐波納契數列以以下被以遞歸的方法定義：F0=0，F1=1，Fn=Fn-1+Fn-2（n>=2，n∈N*），用文字來講，就是斐波那契數列列由 0 和 1 開始，以後的斐波那契數列係數就由以前的兩數相加。特別指出：0不是第一項，而是第零項。

在這個斐波那契數列中的數字，就被稱爲斐波那契數。這個級數與大天然植物的關係極爲密切。幾乎全部花朵的花瓣數都來自這個級數中的一項數字：菠蘿表皮方塊形鱗苞造成兩組旋向相反的螺線，它們的條數必須是這個級數中緊鄰的兩個數字（如左旋8行，右旋13行）；還有向日葵花盤……直到最近的1993年，人們纔對這個古老而重要的級數給出真正滿意的解釋：此級數中任何相鄰的兩個數，次第相除，其比率都最爲接近0.618034……這個值，它的極限就是所謂的"黃金分割數"。

2. 求第N個斐波那契數

求第N個斐波那契數比較簡單能夠直接套用公式n = 0,1 時，fib(n) = 1；n > =2 時，fib(n) = fib(n-2) + fib(n-1)在計算時有兩種算法：遞歸和非遞歸。以下：

 1 //非遞歸算法
 2 long long fib1(size_t N) {
 3     long long a = 0, b = 1, c = 0;
 4     if (N < 2) {
 5         return N;
 6     }
 7     else {
 8         for (long long i = 2; i <= N; ++i) {
 9             c = a + b;
10             a = b;
11             b = c;
12         }
13     }
14         return c;
15 }
16 int main()
17 {
18     printf("%lld", fib1(10));
19     getchar();
20     return 0;
21 }  //此算法最大的優勢是不存在重複計算，故效率比遞歸算法快的多得多。

 1 //遞歸算法
 2 long long fib2(size_t N) {
 3     if (N < 2) 
 4         return N;
 5     return fib2(N - 1) + fib2(N - 2);
 6 }
 7 int main()
 8 {
 9     printf("%lld", fib2(10));
10     getchar();
11     return 0;
12 }

遞歸可使程序看起來比較簡潔，但缺點是效率比較低，而且可能致使棧溢出，當須要計算的數稍大一點，就須要很長的計算時間，所以須要靈活使用遞歸。

3. 二分法查找

3.1 二分查找的非遞歸算法

 1 template<typename T>  
 2 T* BinarySearch(T* array,int number,const T& data)  //data要查找的數，number查找範圍長度，array要查找的數組
 3 {  
 4        assert(number>=0);  
 5        int left = 0;  
 6        int right = number-1;  
 7        while (right >= left)  
 8        {  
 9               int mid = (left&right) + ((left^right)>>1);  
10               if (array[mid] > data)  
11               {  
12                      right = mid - 1;  
13               }  
14               else if (array[mid] < data)  
15               {  
16                      left = mid + 1;  
17               }  
18               else  
19               {  
20                      return (array + mid);  
21               }  
22        }  
23        return NULL;  
24 }  

3.2 二分查找遞歸算法

 1 template<typename T>  
 2 T* BinarySearch(T* left,T* right,const T& data)  
 3 {  
 4        assert(left);  
 5        assert(right);  
 6        if (right >=left)  
 7        {  
 8               T* mid =left+(right-left)/2;  
 9               if (*mid == data)  
10                      return mid;  
11               else  
12                      return *mid > data ? BinarySearch(left, mid - 1, data) : BinarySearch(mid + 1, right, data);  
13        }  
14        else  
15        {  
16               return NULL;  
17        }  
18 }  

4. 時間複雜度與空間複雜度

時間複雜度：通常狀況下，算法中基本操做重複執行的次數是問題規模n的某個函數f(n)，進而分析f(n)隨n的變化狀況並肯定T(n)的數量級。這裏用"O"來表示數量級，給出算法的時間複雜度。

      T(n)=O(f(n));                 

  它表示隨着問題規模的n的增大，算法的執行時間的增加率和f(n)的增加率相同，這稱做算法的漸進時間複雜度，簡稱時間複雜度。而咱們通常討論的是最壞時間複雜度，這樣作的緣由是：最壞狀況下的時間複雜度是算法在任何輸入實例上運行時間的上界，分析最壞的狀況以估算算法指向時間的一個上界。

時間複雜度的分析方法：

（1）時間複雜度就是函數中基本操做所執行的次數；

（2）通常默認的是最壞時間複雜度，即分析最壞狀況下所能執行的次數；

（3）忽略掉常數項；

（4）關注運行時間的增加趨勢，關注函數式中增加最快的表達式，忽略係數；

（5）計算時間複雜度是估算隨着n的增加函數執行次數的增加趨勢；

（6）遞歸算法的時間複雜度爲： 遞歸總次數 * 每次遞歸中基本操做所執行的次數；

    經常使用的時間複雜度有如下七種，算法時間複雜度依次增長：O(1)常數型、O(log2 n)對數型、O(n)線性型、O(nlog2n)二維型、O(n^2)平方型、O(n^3)立方型、O(2^n)指數型。

空間複雜度：

  算法的空間複雜度並非計算實際佔用的空間，而是計算整個算法的輔助空間單元的個數，與問題的規模沒有關係。算法的空間複雜度S(n)定義爲該算法所耗費空間的數量級。

  S(n)=O(f(n))  若算法執行時所須要的輔助空間相對於輸入數據量n而言是一個常數，則稱這個算法的輔助空間爲O(1); 

  遞歸算法的空間複雜度：遞歸深度N*每次遞歸所要的輔助空間， 若是每次遞歸所需的輔助空間是常數，則遞歸的空間複雜度是 O(N)。

5. 斐波那契數的時間複雜度與空間複雜度分析

5.1 非遞歸算法時間複雜度分析

 使用非遞歸算法求到第n個斐波那契數，是從第2個數開始，將前兩個數相加求求後一個數，再將後一個數賦值給前一個數，再計算前兩個數相加的結果。依次類推直到第n個數，用n-1個數和n-2個數相加求出結果，這樣的好處是，咱們只計算了n-1次就求出告終果，即時間複雜度爲O(n)；咱們以代碼中測試數10爲例詳解求第十個數的過程。當N=10時，進入函數首先判斷，而後走下面的分支開始計算

計算了N-1次，得出告終果因此時間複雜度是O（N）。

非遞歸算法空間複雜度分析
此函數內部最多時一共開闢了a, b, c, i四個變量空間複雜度是常數，即爲O（1）。 

5.2 遞歸算法時間複雜度分析

在遞歸算法中，求解fib2(n)，把它推到求解fib2(n-1)和fib2(n-2)。也就是說，爲計算fib2(n)，必須先計算

fib2(n-1)和fib2(n-2)，而計算fib2(n-1)和fib2(n-2)，時按照表達式及計算法則，需先計算又必須先計算fib2(n-1)，而fib2(n-1)由fib2(n-2)和fib2(n-3)計算得來，而這之中的和fib2(n-2)由fib2(n-3)和fib2(n-4)計算得來......依次類推，表面上看不出有何複雜度，可是仔細分析可知，每個計算fib2(n)的分支都會衍生出計算直至(1)和fib(0)，也就是說每一個分支都要本身計算數自己到1的斐波那契數列，這樣就增長了龐大且冗雜的運算量，仍是以10 爲例詳細計算說明

圖中數字表明第N個斐波那契數，圖中沒有所有將計算步驟畫出來，可是已經足夠說明問題，它的每一步計算都被分紅計算前兩個斐波那契數，以此類推。那麼這就造成了一顆二叉樹，雖然不是滿二叉樹，可是咱們分析的是最壞時間複雜度，並且只要估算出來遞歸次數隨N增加的趨勢便可，故能夠近似將它當作滿二叉樹，其中的節點數就是計算的次數，也就是複雜度，由公式：節點數=2^h-1（h爲樹的高度）可得O（2^n）。

遞歸的時間複雜度是：  遞歸次數*每次遞歸中執行基本操做的次數，因此時間複雜度是： O(2^N)

遞歸算法空間複雜度分析：

遞歸最深的那一次所耗費的空間足以容納它全部遞歸過程。遞歸產生的棧偵是要銷燬的，因此空間也就釋放了，要返回上一層棧偵繼續計算+號後面的數，因此它所須要的空間不是一直累加起來的，以後產生的棧偵空間都小於遞歸最深的那一次所耗費的空間。

遞歸的深度*每次遞歸所需的輔助空間的個數 ，因此空間複雜度是：O(N)

6. 求二分法的時間複雜度和空間複雜度

 6.1  非遞歸算法分析

分析：

假設最壞狀況下，循環X次以後找到，則：2^x=n; x=logn(算法中若是沒寫，log默認底數爲2)

循環的基本次數是log2 N，因此: 時間複雜度是O(logN);

因爲輔助空間是常數級別的因此：空間複雜度是O(1);

6.2 遞歸算法複雜度分析

假設最壞狀況下，循環X次以後找到，則：2^x=n; x=logn(算法中若是沒寫，log默認底數爲2)

遞歸的次數和深度都是log2 N,每次所須要的輔助空間都是常數級別的：

時間複雜度:O(log2 N)；

空間複雜度：O(log2N )。

7.  擴展-----不用循環法和遞歸法求1+2+3+...+N（思考一種複雜度爲O（1）的解法）

 1 class Temp
 2 {
 3 public:
 4     Temp(){
 5         ++N;
 6         Sum += N;
 7     }
 8     static void Reset(){
 9         N = 0;
10         Sum = 0;
11     }
12     static int GetSum(){
13         return Sum;
14     }
15 private:
16     static int N;
17     static int Sum;
18 };
19 int Temp::N = 0;
20 int Temp::Sum = 0;
21 int solution_Sum(int n){
22     Temp::Reset();
23     Temp *a = new Temp[n];
24     delete[]a;
25     a = 0;
26     return Temp::GetSum();
27 }
28 int main(){
29     cout << solution_Sum(100) << endl;
30     getchar();
31     return 0;
32 
33 }