斐波那契数列：从朴素递归到记忆化优化，深入理解递归与缓存斐波那契数列：从朴素递归到记忆化优化，深入理解递归与缓存斐波

斐波那契数列：从朴素递归到记忆化优化，深入理解递归与缓存

斐波那契数列（Fibonacci Sequence）是计算机科学中最经典的递归问题之一。它定义简洁却蕴含丰富的算法思想：

$f(0) = 0$
$f(1) = 1$
$f(n) = f(n-1) + f(n-2) \quad (n \geq 2)$

看似简单的公式，却能引出关于递归效率、重复计算、空间换时间、闭包与缓存等核心编程概念的深度思考。本文将带你从最朴素的递归实现出发，逐步优化至高效的记忆化版本，并借助 IIFE 和闭包封装缓存逻辑，真正掌握“用空间换时间”的精髓。

一、朴素递归：简洁但低效

最直观的实现方式就是直接翻译数学定义：

function fib(n) {
    if (n <= 1) return n;
    return fib(n - 1) + fib(n - 2);
}

✅ 优点：

代码简洁，逻辑清晰，完全对应数学定义。
自顶向下：从大问题 fib(n) 拆解为小问题 fib(n-1) 和 fib(n-2)。
符合人类直觉，易于理解和教学。

❌ 缺陷：

指数级时间复杂度 $O(2^n)$ ：每个 fib(k) 会被重复计算多次。
- 例如：fib(5) 调用 fib(4) 和 fib(3)；而 fib(4) 又会调用 fib(3) 和 fib(2) —— fib(3) 被算了两次！
调用栈过深：当 n 较大（如 n=100）时，函数不断入栈，极易导致栈溢出（Stack Overflow） 。
实际不可用：fib(50) 就可能需要数分钟甚至更久。

💡 关键洞察：递归虽美，但若存在大量重叠子问题（Overlapping Subproblems），就必须优化！

二、优化思路：用缓存避免重复计算

观察递归树可以发现：相同的子问题被反复求解。这正是动态规划中“重叠子问题”特征的典型体现。

解决方案：记忆化（Memoization） —— 把已计算的结果存起来，下次直接查表。

方法1：全局缓存对象

const cache = {}; // 全局缓存

function fib(n) {
    if (n in cache) return cache[n];      // 已计算？直接返回
    if (n <= 1) {
        cache[n] = n;
        return n;
    }
    const result = fib(n - 1) + fib(n - 2);
    cache[n] = result;                    // 存入缓存
    return result;
}

✅ 效果：

时间复杂度降至 $O(n)$ ：每个 fib(k)（k=0~n）只计算一次。
空间复杂度 $O(n)$ ：用于缓存 + 递归调用栈。
fib(100) 瞬间完成！

⚠️ 隐患：

cache 是全局变量，容易被外部修改或污染。
多个斐波那契函数实例会共享同一个缓存，缺乏封装性。

三、进阶封装：IIFE + 闭包，打造私有缓存

为了解决全局变量问题，我们可以利用 IIFE（立即执行函数表达式） 和 闭包（Closure） 创建一个私有作用域，将 cache 完全隐藏在函数内部。

const fib = (function () {
    const cache = {}; // 私有变量，外部无法访问

    console.log('初始化缓存...'); // 仅执行一次

    return function (n) {
        if (n in cache) return cache[n];
        if (n <= 1) {
            cache[n] = n;
            return n;
        }
        cache[n] = fib(n - 1) + fib(n - 2); // 注意：这里调用的是外层返回的 fib
        return cache[n];
    };
})(); // 立即执行，返回内部函数并赋值给 fib

🔑 核心机制解析：

概念	说明
IIFE	`(function(){...})()` 立即执行，创建独立作用域
闭包	内部函数“记住”了外部的 `cache` 变量，即使 IIFE 执行完毕，`cache` 依然存活
自由变量	`cache` 对内部函数而言是自由变量，通过闭包捕获
私有性	外部无法直接访问或修改 `cache`，保证数据安全

✅ 这种写法既保留了记忆化的高效，又实现了良好的封装，是 JavaScript 中常见的模块化模式。

四、对比总结：三种实现的性能与设计

实现方式	时间复杂度	空间复杂度	是否可重入	封装性	适用场景
朴素递归	$O(2^n)$	$O(n)$ （栈）	是	差	教学、极小 n
全局缓存	$O(n)$	$O(n)$	否（共享状态）	差	快速原型
IIFE + 闭包	$O(n)$	$O(n)$	是（独立实例）	优	生产环境、库开发

五、延伸思考

还能更快吗？
是的！可以用迭代法（自底向上） ，用循环代替递归，空间复杂度可优化至 $O(1)$ 。
大数问题
JavaScript 的 Number 类型在 fib(78) 左右就会失去精度。可改用 BigInt：
```
cache[n] = fib(n-1) + fib(n-2); // 若参数为 BigInt，则结果也是 BigInt
```

通用记忆化工具函数
可以抽象出一个 memoize 高阶函数，用于任意纯函数：

function memoize(fn) {
    const cache = new Map();
    return function(...args) {
        const key = JSON.stringify(args);
        if (cache.has(key)) return cache.get(key);
        const result = fn.apply(this, args);
        cache.set(key, result);
        return result;
    };
}
const fib = memoize((n) => n <= 1 ? n : fib(n-1) + fib(n-2));

结语

斐波那契数列虽小，却是通往算法思维的一扇大门。从朴素递归的优雅，到记忆化的高效，再到闭包封装的工程实践，每一步都体现了程序员对时间、空间、可维护性的权衡与追求。

“好的代码不仅正确，还要聪明地避免做无用功。”

下次当你面对一个看似简单的递归问题时，不妨多问一句： “有没有重复计算？能不能用缓存？” —— 这或许就是从初学者迈向高手的关键一步。