Fibonacci数列<?xml:namespace prefix = o ns = "urn:schemas-microsoft-com:office:office" />

v  Fibonacci背景知识

斐波那契:比萨德列奥纳多，又称斐波那契（Leonardo Pisano ,Fibonacci, Leonardo Bigollo，1175年-1250年），意大利数学家，西方第一个研究斐波那契数，并将现代书写数和乘数的位值表示法系统引入欧洲。

v  Fibonacci 引出

斐波那契在《算盘书》中提出了一个有趣的兔子问题：一般而言，兔子在出生两个月后，就有繁殖能力，一对兔子每个月能生出一对小兔子来。如果所有兔都不死，那么一年以后可以繁殖多少对兔子？

我们不妨拿新出生的一对小兔子分析一下：第一个月小兔子没有繁殖能力，所以还是一对；两个月后，生下一对小兔总数共有两对； 三个月以后，老兔子又生下一对，因为小兔子还没有繁殖能力，所以一共是三对；

类推表如下：

 

       从一年的总体对数中可以发现,从第二个月开始，其数量是前两个月的数量的和，所以得出递推公式为：

F(n)=F(n-1)+F(n-2)(n>=2)     (1)

v  Fibonacci数列的性质

1． F(n)=F(n-1)+F(n-2)

2.  其任意一项平方数为其前项和后项的积加一或者减一

    F(n)*F(n)=F(n-1)*F(n+1)+/-1

3.任取相邻的四个斐波那契数，中间两数之积（内积）与两边两数之积（外积）相差1

v  Fibonacci数列的程序实现

1.  递归实现 

static int Fib1(int n)
                {
                        int []result = new int[]{ 0, 1 };
                        if(n<2) return result[n];
                        return Fib1(n-1)+Fib1(n-2);
                }

2． 非递归实现(迭代法)

static int Fib2(int n)    
                {
                        int[] result = new int[] { 0, 1 };

                        if (n < 2) return result[n];

                        int n1=0,n2=1,retTemp=0;

                        for (int i = 2; i <=n; i++)
                        {
                                retTemp = n1 + n2;
                                n1 = n2;
                                n2 = retTemp;
                        }
                        return retTemp;
                }

  利用Fibonacci矩阵恒等式方法就Fibonacci数列：

internal class MaxtrixBy
                {

                        public struct Matrix
                        {
                                public int m00, m01, m10, m11;
                                public Matrix(int _m00, int _m01, int _m10, int _m11)    
                                {
                                        m00 = _m00;
                                        m01 = _m01;
                                        m10 = _m10;
                                        m11 = _m11;
                                }
                        }
                        public static Matrix MatrixMuti(Matrix m1, Matrix m2)
                        {
                                return new Matrix(m1.m00 * m2.m00 + m1.m10 * m2.m01, m1.m00 * m2.m10 + m1.m10 * m2.m11,
                                                            m1.m10 * m2.m00 + m1.m11 * m2.m01, m1.m10 * m2.m00 + m1.m11 * m2.m11);
                                                            
                        }
    
                        public static Matrix MatrixPower(int n)
                        {
                                Debug.Assert(n > 0);
                                Matrix matrix = new Matrix();

                                if (n == 1)
                                {
                                        return matrix=new Matrix(1,1,1,0);
                                }
                                if(n%2==0)
                                {
                                        matrix = MatrixPower(n / 2);
                                        matrix = MatrixMuti(matrix, matrix);    
                                }
                                if (n % 2 == 1)
                                {
                                        matrix = MatrixPower((n-1) / 2);
                                        matrix = MatrixMuti(matrix, matrix);
                                        matrix = MatrixMuti(matrix, new Matrix(1, 1, 1, 0));
                                }
                                return matrix;
                        }

                        public static int Fib3(int n)
                        {
                                int[] result = new int[] { 0, 1 };
                                if(n<2) return result[n];
                             // MaxtrixBy matrixby=new MaxtrixBy();
                                Matrix m = MaxtrixBy.MatrixPower(n - 1);
                                return m.m00;
                        }
                }

	递归表示	迭代法	矩阵恒等式
时间复杂度	O(2 exp n)	O(n)	O(logn)