面试官：斐波那契数列你能想出几种解法？(Java实现)

Posted 2021-10-06 结构化思维wz

文章目录

• • • 1.递归解法
    • 2.带备忘录的递归解法
    • 3.dp数组(自底向上的动态规划思路)解法
    • 4.优化空间复杂度为O(1)的自底向上解法

1.递归解法

/**
 * @author 王泽
 * 斐波那契数列
 * 时间复杂度O(2^n)
 */

public class Fibo {
    public static void main(String[] args) {
        System.out.println(fib(10));
    }
    static int fib(int N){
        if (N==0){return 0;}
        if(N==1 || N==2){return 1;}
        return fib(N-1)+fib(N-2);
    }
}

2.带备忘录的递归解法

/**
 * @author 王泽
 * 带备忘录的fibo，每次算出子问题先上传到备忘录，每次遇到子问题先去备忘录中查找。
 * 时间复杂度：O(N)
 */

public class MemoFibo {
    public static void main(String[] args) {
        Memo memo = new Memo();
        System.out.println(memo.fib(10));
    }
}
class Memo{
    int fib(int N){
        if (N==0){return 0;}
        //将备忘录初始化为0
        int[] memo = new int[N+1];
        //进行带备忘录的递归
        return helper(memo,N);
    }
    int helper(int[] memo,int n){
        //base case
        if(n==1 || n==2){return 1;}
        //已经计算过的
        if (memo[n] != 0){return memo[n];}
        memo[n] = helper(memo, n-1) + helper(memo, n-2);
        return memo[n];
    }
}

3.dp数组(自底向上的动态规划思路)解法

/**
 * @author 王泽
 * dp数组的迭代解法，自底向上，动态规划
 * 时间复杂度：O(N)
 */

public class DpFibo {
    public static void main(String[] args) {
        Dp dp = new Dp();
        DpTable dpTable =new DpTable();
        System.out.println(dp.fib(10));
    }

}
/**
 * 基本的dp数组解法
 * */
class Dp{
    int fib(int n){
        int[] dp = new int[n+1];
        //base case
        dp[0] = 0;
        dp[1] = 1;
        for(int i=2;i<=n;i++){
            dp[i] = dp[i-1] + dp[i-2];
        }
        return dp[n];
    }
}

4.优化空间复杂度为O(1)的自底向上解法

/**
 * @author 王泽
 * dp数组的迭代解法，自底向上，动态规划
 * 时间复杂度：O(N)
 */

public class DpFibo {
    public static void main(String[] args) {
        Dp dp = new Dp();
        DpTable dpTable =new DpTable();
        System.out.println(dp.fib(10));
        System.out.println("优化后===》");
        System.out.println(dpTable.fib(10));
    }

}
/**
 * 基本的dp数组解法
 * */
class Dp{
    int fib(int n){
        int[] dp = new int[n+1];
        //base case
        dp[0] = 0;
        dp[1] = 1;
        for(int i=2;i<=n;i++){
            dp[i] = dp[i-1] + dp[i-2];
        }
        return dp[n];
    }
}
/**
 * 优化dp数组的解法。
 * 状态压缩
 * 优化了空间复杂度O(1)。
 */
class DpTable{
    int fib(int N){
        if (N==0){return 0;}
        if(N==2 || N ==1){return 1;}
        int prev =1,curr =1;
        //空间由从原来的N，变成现在的2
        for (int i = 3; i <= N ; i++) {
            int sum =prev +curr;
            prev = curr;
            curr = sum;
        }
        return curr;
    }
}