算法打卡-day10

斐波那契数列

1、递归实现

每个递归函数包含多个自身调用f(n)=f(n-1)+f(n-2)

public class E06Fibonacci {
    public static int f(int n){
        if(n==0){
            return 0;
        }
        if(n==1){
            return 1;
        }
       int x=f(n-1);
       int y=f(n-2);
       return x+y;
    }


    public static void main(String[] args) {
        int f= f(8);
        System.out.println(f);
    }

}

时间复杂度

          调用次数2*f(n+1)-1。O(1.1618^n)

2、递归优化-记忆法

              思路：定义一个一维数组，数组中的每个元素对应斐波那契第N项的值

             时间复杂度O(N)，增加了空间复杂度

public class E01Fibonacci {
    public static int fibonacci(int n){
        int[] cache = new int[n+1];
        //-1表示没有计算出结果
        Arrays.fill(cache,-1);
        cache[0]=0;
        cache[1]=1;
        return f(n,cache);
    }

    public static int f(int n,int[] cache){
        if(cache[n] !=-1){
            return cache[n];
        }
        
        int x=f(n-1,cache);
        int y=f(n-2,cache);
        //存入数组
        cache[n]=x+y;
        return cache[n];
    }
}

3、动态规划 

    public static int fibonacci(int n){
        int[] dp= new int[n+1];//用来缓存结果

        if(n==0){
            return 0;
        }
        if(n==1){
            return 1;
        }
        dp[0]=0;
        dp[1]=1;
        for(int i=2;i<=n;i++){
            dp[i]=dp[i-1]+dp[i-2];
        }
        return dp[n];

    }

降维

  public static int fibonacci(int n){
        if(n==0){
            return 0;
        }
        if(n==1){
            return 1;
        }
        int a=0;
        int b=1;
        for(int i=2;i<=n;i++){
            int c = b+a;
            a=b;
            b=c;
        }
        return b;

    }