斐波那契数列：从递归到缓存优化的极致拆解

斐波那契数列：从递归到缓存优化的极致拆解

斐波那契数列是算法入门的经典案例，也是理解「递归」「缓存优化」「闭包」核心思想的绝佳载体。本文会从最基础的递归解法入手，逐步拆解重复计算的痛点，再通过哈希缓存、闭包缓存等方式优化，带你吃透斐波那契数列的解题思路。

一、斐波那契数列的定义

先明确斐波那契数列的核心规则：

• 起始项：f(0) = 0，f(1) = 1；
• 递推公式：f(n) = f(n-1) + f(n-2)（n ≥ 2）；
• 数列示例：0, 1, 1, 2, 3, 5, 8, 13, 21...

简单来说，从0和1开始，后续每一项都等于前两项之和。

二、基础递归解法：思路简单但效率拉胯

1. 递归核心思想

递归的本质是「大问题拆解为小问题」：计算 f(n) 时，先拆解为计算 f(n-1) 和 f(n-2)，直到拆解到 f(0) 或 f(1) 这个「递归终止条件」，再逐层返回结果。

2. 代码实现

// 基础递归版斐波那契
function fib(n) {
  // 递归退出条件：触底到0或1，直接返回
  if (n <= 1) return n;
  // 递推公式：拆分为两个子问题
  return fib(n - 1) + fib(n - 2);
}

console.log(fib(10)); // 55（小数值正常）
console.log(fib(100)); // 卡死（重复计算导致超时）

3. 核心问题分析

（1）重复计算严重

以 fib(5) 为例，拆解过程如下：

fib(5) = fib(4) + fib(3)
fib(4) = fib(3) + fib(2)
fib(3) = fib(2) + fib(1)
fib(2) = fib(1) + fib(0)

可以看到：fib(3) 被计算了2次，fib(2) 被计算了3次，fib(1) 被计算了5次。随着n增大，重复计算呈指数级增长。

（2）时间复杂度爆炸

• 时间复杂度：O(2ⁿ)，指数级复杂度，n=40时计算时间就会明显增加，n=100直接卡死；
• 空间复杂度：O(n)，递归调用栈的深度等于n，极端情况下会触发「栈溢出」。

（3）调用栈溢出风险

递归依赖函数调用栈存储上下文，当n过大时（比如n=10000），会超出JS引擎的调用栈限制，抛出 Maximum call stack size exceeded 错误。

三、优化1：哈希缓存（空间换时间）

1. 优化思路

既然重复计算是核心问题，我们可以用「哈希表（对象）」缓存已经计算过的结果：

• 计算前先查缓存，存在则直接返回；
• 计算后将结果存入缓存，避免重复计算。

这是典型的「空间换时间」策略，用少量内存开销换取时间复杂度的大幅降低。

2. 代码实现

// 缓存对象：存储已计算的斐波那契值
const cache = {};

function fib(n) {
  // 1. 优先查缓存，存在则直接返回
  if (n in cache) {
    return cache[n];
  }
  // 2. 递归终止条件
  if (n <= 1) {
    cache[n] = n; // 存入缓存
    return n;
  }
  // 3. 计算并缓存结果
  const result = fib(n - 1) + fib(n - 2);
  cache[n] = result;
  return result;
}

console.log(fib(100)); // 顺利输出：354224848179261915075

3. 优化效果分析

• 时间复杂度：O(n)，每个n只计算一次，后续直接取缓存；
• 空间复杂度：O(n)，缓存对象存储n个值 + 递归调用栈深度n；
• 核心改进：彻底解决重复计算问题，n=100也能快速计算。

4. 小问题

缓存对象 cache 暴露在全局作用域中，容易被意外修改，破坏了函数逻辑的独立性。

四、优化2：闭包封装缓存（更优雅的空间换时间）

1. 优化思路

用「立即执行函数（IIFE）」创建闭包，将缓存对象封装在函数内部，避免全局污染：

• IIFE 立即执行，创建独立的作用域；
• 内部定义缓存对象（自由变量），返回一个计算斐波那契的函数；
• 返回的函数可以访问闭包中的缓存对象，且外部无法修改。

2. 代码实现

// IIFE 创建闭包，封装缓存
const fib = (function() {
  // 闭包中的缓存：仅内部可访问，避免全局污染
  const cache = {};
  
  // 返回实际的计算函数
  return function(n) {
    if (n in cache) {
      return cache[n];
    }
    if (n <= 1) {
      cache[n] = n;
      return n;
    }
    // 注意：此处调用的是外部的fib（即返回的这个函数）
    cache[n] = fib(n - 1) + fib(n - 2);
    return cache[n];
  }
})();

console.log(fib(100)); // 依然快速输出结果
console.log(cache); // undefined（外部无法访问缓存，更安全）

3. 核心优势

• 缓存私有化：闭包中的 cache 仅被返回的 fib 函数访问，避免全局污染和意外修改；
• 代码更优雅：把缓存和计算的逻辑打包在一起，就像把相关工具放进同一个工具箱，用起来方便还不杂乱；
• 性能不变：时间复杂度仍为O(n)，空间复杂度仍为O(n)。

五、补充：递归 vs 迭代（拓展思路）

除了缓存优化递归，还可以用「迭代」彻底避免递归调用栈问题：

// 迭代版斐波那契（空间复杂度可优化至O(1)）
function fib(n) {
  if (n <= 1) return n;
  let prev = 0, curr = 1;
  for (let i = 2; i <= n; i++) {
    const next = prev + curr;
    prev = curr;
    curr = next;
  }
  return curr;
}

• 时间复杂度：O(n)；
• 空间复杂度：O(1)，仅用三个变量存储状态，无递归栈和缓存开销。

六、核心知识点总结

1. 递归的适用场景

递归适合解决「可拆分为相似子问题、有明确终止条件、符合树形结构」的问题，但必须注意：

• 避免重复计算（用缓存优化）；
• 防止栈溢出（n过大时优先用迭代）。

2. 缓存优化的核心思想

「空间换时间」是算法优化的常用策略，核心是存储已计算的结果，避免重复劳动，常见载体包括：

• 哈希表（对象/Map）；
• 数组；
• 闭包私有化缓存。

3. IIFE + 闭包的价值

• IIFE：立即执行函数，创建独立作用域，避免全局污染；
• 闭包：让内部函数访问外部作用域的变量（如cache），且变量不会被垃圾回收，持续有效。

4. 各版本对比

版本	时间复杂度	空间复杂度	优点	缺点
基础递归	O(2ⁿ)	O(n)	思路简单	重复计算、易栈溢出
哈希缓存	O(n)	O(n)	解决重复计算	缓存全局暴露
闭包缓存	O(n)	O(n)	缓存私有化、代码优雅	仍有递归栈开销
迭代	O(n)	O(1)	性能最优、无栈溢出	思路稍绕

七、总结

斐波那契数列的优化过程，是算法思维从「简单实现」到「高效优雅」的典型体现：

1. 基础递归：满足「能跑」，但存在重复计算和栈溢出问题；
2. 哈希缓存：解决重复计算，时间复杂度从O(2ⁿ)降到O(n)；
3. 闭包缓存：在缓存的基础上优化代码结构，实现缓存私有化；
4. 迭代优化：彻底摆脱递归栈，空间复杂度降到O(1)。

斐波那契看似简单，却是理解算法优化的绝佳入口。从朴素递归的指数爆炸，到缓存记忆化的时间换空间，再到闭包封装的工程优雅，最后迭代实现极致效率------每一步都体现了"用合适工具解决合适问题"的编程智慧。