斐波那契总结【转载】

http://blog.csdn.net/yangalbert?viewmode=contents

Fibonacci(斐波那契)数列定义：

（1）递归实现

思想简单，无需赘述，实现如下：

[cpp] view plain copy

1. // 递归方法复杂度O(2^n)，计算到n=41已达到计算机的极限  
2. int F( int n )  
3. {  
4.     if ( n <= 0 ) return 1;  
5.     else if ( n == 1 ) return 1;  
6.     else return F(n-1)+F(n-2);  
7. }   
8.   
9. int* Fibonacci1( int len )  
10. {  
11.     int* arr = (int*)malloc( sizeof(int) * len);  
12.     if ( arr == NULL ) return arr;  
13.   
14.     for ( int i = 0; i < len; ++i ) arr[i] = F(i);  
15.   
16.     return arr;  
17. }  

该方法存在很多重复计算，虽然是典型的递归，但效率很低，资源消耗大。经分析，改算法时间复杂读为指数阶(O(2^n))，远高于多项式阶；占用计算机空间资源大，经测试在n=41时已达到PC的极限。

（2）采用通项公式计算

递推公式为x(n+2)=x(n+1)+x(n)，是一个二阶常系数齐次线性差分方程，利用该差分方程的特征方程t^2=t+1，以及初始条件x(0)=1, x(1)=1易解出x(n)的通项表达式。

f(n)的通项表达式：

C实现：

[cpp] view plain copy

1. struct data  
2. {  
3.     double f1;  
4.     double f2;  
5. };  
6.   
7. // 利用通项公式计算，时间复杂度O(n)  
8. int* Fibonacci2( int len )  
9. {  
10.     const double sqrt_5 = sqrt(5.0);  
11.     const double p1 = (1+sqrt_5)*0.5;  
12.     const double p2 = (1-sqrt_5)*0.5;  
13.     data d = {(1+1.0/sqrt_5)/2.0, (1.0/sqrt_5-1)/2.0};  
14.   
15.     int* arr = (int*)malloc( sizeof(int) * len);  
16.     if ( arr == NULL ) return arr;  
17.   
18.     for ( int i = 0; i < len; ++i )  
19.     {  
20.         arr[i] = (int)(d.f1-d.f2+0.5);  
21.         d.f1 *= p1;  
22.         d.f2 *= p2;  
23.     }  
24.   
25.     return arr;  
26. }  

虽然采用通项公式的算法能以O(1)的时间复杂度计算Fibonacci数列，但引入了浮点数，计算精度无法保证。

（3）采用二阶递推的方法

注意到，存在矩阵A=(1,1;1,0)使得下式成立

据此得到Fibonacci数列的实现代码：

[cpp] view plain copy

1. // 用于迭代操作的2x2矩阵  
2. class matrix  
3. {  
4. public:  
5.     matrix():a(1),b(1),c(1),d(0){}  
6.     matrix(int a1, int b1, int c1, int d1):a(a1),b(b1),c(c1),d(d1){}  
7.     matrix( const matrix& B ):a(B.a),b(B.b),c(B.c),d(B.d){}  
8.     const matrix& operator*=( const matrix& B)  
9.     {  
10.         int a1 = a, b1 = b, c1 = c, d1 = d;  
11.         int a2=B.a, b2=B.b, c2=B.c, d2=B.d;  
12.         a = a1 * a2 + b1 * c2;  
13.         b = a1 * b2 + b1 * d2;  
14.         c = c1 * a2 + d1 * c2;  
15.         d = c1 * b2 + d1 * d2;  
16.         return *this;  
17.     }  
18.       
19.     unsigned int a;  
20.     unsigned int b;  
21.     unsigned int c;  
22.     unsigned int d;  
23. };  
24.   
25. const matrix operator*( const matrix& A, const matrix& B)  
26. {  
27.     matrix C(A);  
28.     C *= B;  
29.     return C;  
30. }  
31.   
32. void printMatrix( const matrix& A )  
33. {  
34.     printf("%d  %d\n", A.a, A.b);  
35.     printf("%d  %d\n", A.c, A.d);  
36. }  
37.   
38. matrix matrixPower( const matrix& A, int n )  
39. {  
40.     matrix m(1,0,0,1); // 单位矩阵  
41.     matrix temp(A);  
42.   
43.     for ( ; n > 0; n >>= 1 )  
44.     {  
45.         if ( n&1 ) m *= temp;  
46.         temp *= temp;  
47.     }  
48.   
49.     return m;  
50. }  
51.   
52. int F3(int n)  
53. {  
54.     matrix B(1,1,1,0);  
55.     matrix A = matrixPower( B, n-1 );  
56.     return A.a + A.c;  
57. }  
58.   
59. int* Fibonacci3( int len )  
60. {  
61.     int* arr = (int*)malloc( sizeof(int) * len );  
62.     if ( arr == NULL ) return arr;  
63.   
64.     for ( int i = 0; i < len; ++i )  
65.     {  
66.         arr[i] = F3(i);  
67.     }  
68.   
69.     return arr;  
70. }  

该算法时间复杂度为O(logN).