斐波那契数列（Fibonacci）数列 c++详解

Fibonacci数列是一个在数学和计算机科学中非常著名的数列。这个数列以其特殊的递推关系而闻名，也因其在自然界中的多次出现而引人注目。

1. 定义： Fibonacci数列的定义如下：
   • F(0) = 0
   • F(1) = 1
   • 对于 n > 1，F(n) = F(n-1) + F(n-2)
   也就是说，从第三个数开始，每个数都是前两个数的和。
2. 数列开始： 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, ...
3. 问题描述： Fibonacci问题通常指的是计算数列中的第n个数。
4. 解决方法： 在代码中，我展示了三种常见的解决方法： a. 递归方法（fibonacciRecursive）：
   • 直接按定义实现，简单但效率低。
   • 时间复杂度：O(2^n)，空间复杂度：O(n)（递归栈深度）。
   b. 动态规划方法（fibonacciDP）：
   • 使用数组存储中间结果，避免重复计算。
   • 时间复杂度：O(n)，空间复杂度：O(n)。
   c. 优化空间的方法（fibonacciOptimized）：
   • 只保存最近的两个数，进一步优化空间使用。
   • 时间复杂度：O(n)，空间复杂度：O(1)。
5. 应用： Fibonacci数列在自然界和计算机科学中有许多应用：
   • 描述某些植物的生长模式（如向日葵的种子排列）。
   • 在算法分析中用于描述某些算法的时间复杂度。
   • 在金融市场分析中用作技术指标。
6. 有趣的性质：
   • 相邻Fibonacci数的比值趋近于黄金比例（约1.618）。
   • Fibonacci数列与Pascal三角形有密切关系。

Fibonacci问题是学习递归、动态规划和算法优化的好例子。它看似简单，但涉及了很多重要的编程和数学概念。

#include <iostream>
#include <vector>

class FibonacciSolver {
public:
    // 递归方法计算Fibonacci数
    int fibonacciRecursive(int n) {
        if (n <= 1) return n;
        return fibonacciRecursive(n - 1) + fibonacciRecursive(n - 2);
    }

    // 动态规划方法计算Fibonacci数
    int fibonacciDP(int n) {
        if (n <= 1) return n;
        std::vector<int> dp(n + 1, 0);
        dp[1] = 1;
        for (int i = 2; i <= n; i++) {
            dp[i] = dp[i - 1] + dp[i - 2];
        }
        return dp[n];
    }

    // 优化空间的动态规划方法
    int fibonacciOptimized(int n) {
        if (n <= 1) return n;
        int prev = 0, curr = 1;
        for (int i = 2; i <= n; i++) {
            int next = prev + curr;
            prev = curr;
            curr = next;
        }
        return curr;
    }
};

int main() {
    FibonacciSolver solver;
    int n = 10; // 计算第10个Fibonacci数

    std::cout << "第" << n << "个Fibonacci数（递归方法）: " 
              << solver.fibonacciRecursive(n) << std::endl;

    std::cout << "第" << n << "个Fibonacci数（动态规划方法）: " 
              << solver.fibonacciDP(n) << std::endl;

    std::cout << "第" << n << "个Fibonacci数（优化方法）: " 
              << solver.fibonacciOptimized(n) << std::endl;

    return 0;
}

详细解释每种方法计算F(5)的过程

1.递归方法： 这个方法会显示递归调用的过程

计算 F(5)
计算 F(4)
计算 F(3)
计算 F(2)
计算 F(1)
计算 F(0)
计算 F(1)
计算 F(2)
计算 F(1)
计算 F(0)
计算 F(3)
计算 F(2)
计算 F(1)
计算 F(0)
计算 F(1)
结果: 5

2.动态规划方法： 这个方法会显示DP数组如何被填充：

DP数组初始化: 0 1 0 0 0 0 
计算 F(2): 1, DP数组: 0 1 1 0 0 0 
计算 F(3): 2, DP数组: 0 1 1 2 0 0 
计算 F(4): 3, DP数组: 0 1 1 2 3 0 
计算 F(5): 5, DP数组: 0 1 1 2 3 5 
结果: 5

每个Fibonacci数只被计算一次，并存储在数组中。

3.优化空间的方法： 这个方法只保存最近的两个数：

初始状态: prev = 0, curr = 1
计算 F(2): 1 (prev = 0, curr = 1)
计算 F(3): 2 (prev = 1, curr = 1)
计算 F(4): 3 (prev = 1, curr = 2)
计算 F(5): 5 (prev = 2, curr = 3)
结果: 5

每一步只保存和更新两个变量，大大减少了空间使用。

• 递归方法简单直观，但有大量重复计算，效率最低。
• 动态规划方法避免了重复计算，效率高，但需要O(n)的额外空间。
• 优化空间的方法在保持高效的同时，将空间复杂度降到了O(1)。