斐波那契數列的實現（簡單遞歸和動態規劃）

斐波那契數列的實現（簡單遞歸和動態規劃）

1、簡單遞歸的實現

 1 #include "stdafx.h"
 2 #include <string>
 3 using namespace std;
 4 int f(int n)
 5 {
 6     if (n == 0)
 7     {
 8         return 0;
 9     }
10     if (n == 1)
11     {
12         return 1;
13     }
14     return f(n - 1) + f(n - 2);
15 }
16 int _tmain(int argc, _TCHAR* argv[])
17 {
18     printf("%d", f(10));
19     getchar();
20     return 0;
21 }

　　求解斐波那契數列當中的n=5時的值這個問題的遞歸樹以下圖所示：

     可見遞歸算法因爲會屢次計算一樣的子問題而出現效率低下的問題，爲了不重複計算子問題，提高算法的效率，可使用動態規劃的思惟來改進算法。

2、動態規劃算法

一、具備備忘功能的自頂向下算法

     使用一個數組來記錄各個子問題的解，當再一次遇到這一問題的時候直接查找數組來得到解避免屢次計算子問題。

 1 #include "stdafx.h"
 2 #include <string>
 3 using namespace std;
 4 int f(int a[],int n)
 5 {
 6     if (n == 0)
 7     {
 8         a[0] = 0;
 9         return 0;
10     }
11     if (n == 1)
12     {
13         a[1] = 1;
14         return 1;
15     }
16     if (a[n] >= 0)
17     {
18         return a[n];
19     }
20     a[n] = f(a, n - 1) + f(a, n - 2);
21     return f(a, n - 1) + f(a, n - 2);
22 }
23 int _tmain(int argc, _TCHAR* argv[])
24 {
25     int n = 10;//須要求解的數
26     int* a = (int*)malloc((n + 1)*sizeof(int));
27     for (int i = 0; i < n + 1; i++)
28     {
29         a[i] = -1;
30     }
31     printf("%d\n子問題的解", f(a, n));
32     for (int i = 0; i < n + 1; i++)
33     {
34         printf("%d ", a[i]);
35     }
36     getchar();
37     return 0;
38 }

 

 二、自底向上解決方案

　　先求解子問題再根據子問題的解來求解父問題，斐波那契數列的子問題圖以下：

 1 #include "stdafx.h"
 2 #include <string>
 3 using namespace std;
 4 int f(int a[],int n)
 5 {
 6     a[0] = 0;
 7     a[1] = 1;
 8     for (int i = 2; i <= n; i++)
 9     {
10         a[i] = a[i - 1] + a[i - 2];
11     }
12     return a[n];
13 }
14 int _tmain(int argc, _TCHAR* argv[])
15 {
16     int n = 10;//須要求解的數
17     int* a = (int*)malloc((n + 1)*sizeof(int));
18     for (int i = 0; i < n + 1; i++)
19     {
20         a[i] = -1;
21     }
22     printf("%d\n子問題的解", f(a, n));
23     for (int i = 0; i < n + 1; i++)
24     {
25         printf("%d ", a[i]);
26     }
27     getchar();
28     return 0;
29 }

　　自底向上的計算方法實現起來很是容易，分析算法，僅從形式上面分析算法可知，算法的時間主要消耗在計算數據規模爲n的數組裏面的數上面了，因此時間複雜度爲O（n）。