【数据结构与算法(Java)】斐波那契数列

1. 实现思路

1.1【递归法】： 递归"裂变"计算f值，计算次数较多

1. 基本情况：k < 2, f(k) = k
2. 递归收缩：k > 2, f(k) = f(k -1) + f(k - 2)

1.2【遍历法】：逐个储存+计算下一个f值

1. k < 2, f(k) = k
2. loop 逐个计算，算到k停止：k > 2, f(k) = f(k -1) + f(k - 2)
3. 返回最后一个值

1.3 【数组法】：将计算过的f值储存在array里

1. k < 2, f(k) = k
2. 设置用于储存f的数组
3. 初始化前两个f值
4. 遍历：通过提取数组内前两个f值并求和，来得出后一个值，并储存到数组内。算到k停止
5. 返回数组下标为k的值

2. 代码实现

    /**
     * 斐波那契数列
     *      k < 2, f(k) = k
     *      k > 2, f(k) = f(k -1) + f(k - 2)
     * @param k - 要返回第几个值
     * @return - 第k个值
     */
     
    // （递归法）- 递归"裂变"计算f值，计算次数较多
    public static int fibonacciByRecursion(int k) {
        // 1. 基本情况：k < 2, f(k) = k
        if (k < 2) {
            return k;
        }
        // 2. 递归收缩：k > 2, f(k) = f(k -1) + f(k - 2)
        return fibonacciByRecursion(k - 1) + fibonacciByRecursion(k - 2);
    }
    
    // （遍历法）- 逐个储存+计算下一个f值
    public static int fibonacciByLoop(int k) {
        int f1 = 0; // 储存前一个值
        int f2 = 1; // 储存后一个值
        // 1. k < 2, f(k) = k
        if (k < 2) {
            return k;
        }
        // 2. loop 逐个计算，算到k停止：k > 2, f(k) = f(k -1) + f(k - 2)
        for (int i = 2; i <= k; i++){
            int temp = f2;
            f2 = f1 + temp;
            f1 = temp;
        }
        // 3. 返回最后一个值
        return f2;
    }
    
    // （数组法）- 将计算过的f值储存在array里
    public static int fibonacciByArray(int k) {
        // 1. k < 2, f(k) = k
        if (k < 2) {
            return k;
        }
        // 2. 设置用于储存f的数组
        int[] fibonacciArray = new int[k + 1];
        // 3. 初始化前两个f值
        fibonacciArray[0] = 0;
        fibonacciArray[1] = 1;
        // 4. 遍历：通过提取数组内前两个f值并求和，来得出后一个值，并储存到数组内。算到k停止
        for (int i = 2; i <= k; i++) {
            fibonacciArray[i] = fibonacciArray[i - 1] + fibonacciArray[i - 2];
        }
        // 5. 返回数组下标为k的值
        return fibonacciArray[k];
    }