斐波那契函数总结

说明

 斐波那契数列又称兔子繁殖问题，

表现为0 1 1 2 3 5..........（有一说为1 1 2 3 5......）

从第三项开始，每一项都是前两项的和

表达式：

f(0)=0 n=0

f(1)=1  n=1

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

三种简单的实现斐波那契数列的方法

1.递归实现 

时间复杂度：递归总次数*每次递归的次数

空间复杂度：递归的深度*每次递归空间的大小（注意："每次递归空间的大小"是个常数，可以基本忽略不计）

递归的"深度"：树的高度（递归的过程是一个"二叉树"）

优点:实现简单      （有些问题必须调用递归，比如汉诺塔）

缺点：递归到一定程度会“栈溢出”， 递归程度越深，时间复杂度越高

public class Solution {
/**
* @param n: an integer
* @return: an ineger f(n)
*/

recursive : worst slow couldnt pass
 public int fibonacci(int n) {
     // write your code here
     if(n==1) return 0;
     else if(n==2) return 1;
         else  return fibonacci(n-1)+fibonacci(n-2);
 }

对递归优化为尾递归

在一个程序中，执行的最后一条语句是对自己的调用，而且没有别的运算

public int Fib(long long first,long long second ,long long N){

           if (N < 3)

           return 1;

            if (N == 3)

           return first + second;

            return Fib(second, first + second, N - 1);

}

 

2.循环实现

时间复杂度：O(N)

空间复杂度：O(1)

 array :quick 27.30
 public  int fibonacci(int n){
    int[] fib = new int[n+1];
    fib[0]=0;
    fib[1]=1;
    for(int i=2;i<n;i++){
      fib[i]=fib[i-1]+fib[i-2]; 
    }
    return fib[n-1];
    }

优化：使用常量，减少对数组的开销

conctant best 84.20
public  int fibonacci(int n){
    int f1=0;
    int f2=1;
    int f3= 0;
    if(n==1) return 0;
    else if(n==2) return 1;
        else {
            for(int i=2; i<n;i++){
                f3=f1+f2;
                f1=f2;
                f2=f3;
                
            }
            return f3;
        }
    
    }
    }

3.一种复杂度更低的算法

#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;
}

（部分引用自：https://blog.youkuaiyun.com/beautyofmath/article/details/48184331 ）

（部分引用自：https://blog.youkuaiyun.com/MallowFlower/article/details/78858553）