5月25日 体能大比拼 答案

因为其实是一个题目，我就不分初级高级把一些常见的方法都一起过一遍。

1. 普通递归法(n大了容易爆栈)

const fibonacci = (n) => {
  if(n == 1 || n == 2) {
    return 1;
  }
   return fibonacci(n - 1) + fibonacci(n - 2);
}

分析：逻辑简单，容易理解，但是费时，栈容易爆

2. 尾调用优化递归

const fibonacci = (n,a = 1,b = 1) => {
  if(n == 1 || n == 2) {
    return b;
  } else {
    return fibonacci(n-1,b,a+b);
  }
}

分析：因为函数最后没有用到任何外部的值，所以有尾调用优化，不存在费空间的问题，但是同样费时间，比如我们在计算fibonacci(10)的时候我们已经算出来10之前的所有项，但是如果我们现在算fibonacci(11)，就又需要从头开始计算。

3. 普通循环

const fibonacci = (n) => {
    let [a, b] = [1, 1];
    if (n <= 2) {
        return 1;
    }
    for (let i = 1; i < n; i++) {
        [a, b] = [b, a + b];
    }
    return a;
}

分析： 跟上面一种方法差不多，没有记忆功能，不可能过得了测试。

其实，就单单算一次fibonacci的话，用3和2的方法都挺快的，但是如果我们要算很多个fibonacci的话(调用多次fibonacci()函数)，我们就需要把每次得到的结果保存下来，因为题目说了不要使用全局变量，所以我们就不得不使用闭包。

下面贴几个我认为比较好的方法 --来自网友; )

第一种

const fibonacci = ((memory = {}) => n => {
    if(n < 2) return n
    if(memory[n-2] === undefined){
        memory[n-2] = fibonacci(n-2)
    }
    if(memory[n-1] === undefined){
        memory[n-1] = fibonacci(n-1)
    }
    return memory[n] = memory[n-1] + memory[n-2]
})()

贴这个方法的人还问了为什么这个方法比另一个快，我们看看

const fibonacci = n =>{
   let [a, b] = [0, 1]
   while(n--){[a, b] = [b, a + b]}
   return a
}

有网友回复：

分析：刚才我们已经分析过了，下面的这种写法没有记忆能力，第一种方法用了闭包，把所有的结果保存到一个对象中，并不是网友回复对象更快这个原因，单纯就是第二种方法完全没有记忆能力，大家一定要擦亮自己的眼睛。我们来试试把对象换成数组（只需要把(memory = {})的大括号改成中括号[]），结果还是AC啦，完全没有问题。

---

第二种

const fibonacci = (n) => {
    if (!fibonacci.cache) {
        fibonacci.cache = [];
        for (let i = 1; i <= 1000000; i++) {
            if (i === 1 || i === 2) {
                fibonacci.cache[i] = 1;
            }
            else if (i > 2) {
                fibonacci.cache[i] = fibonacci.cache[i - 1] + fibonacci.cache[i - 2];
            }
        }
    }
    return fibonacci.cache[n];
}

分析：这种方法没有用到闭包，而是把结果添加到函数对象的一个属性上，并且不管问的是多少，我们先算个1000000以内的斐波那契数列，然后不管问哪里都可以。

---

第三种（一行）

const fibonacci = ((s) => (f = (i) => s[i] || (s[i] = f(i - 1) + f(i - 2))))([0, 1, 1])

为了让大家看的更加清楚一点，我们不用箭头函数的写法

const fibonacci = (function fibonacci(s) {
    return function f(i) {
        return s[i] === undefined ? (s[i] = f(i - 1) + f(i - 2)) : s[i];
    }
})([0, 1, 1]);

分析：也是闭包，用数组存放结果，写的比较简洁优雅。

---

第四种

const fibonacci = ((dp) => (n) => {
    if (dp[n]) {
        return dp[n];
    }
    for (let i = dp.length - 1; i <= n; i++) {
        dp[i] = dp[i - 1] + dp[i - 2];
    }
    return dp[n];
})([0, 1, 1]);

分析：跟第三种类似，也是用闭包存储数据，区别就是3是递归调用函数（从大到小）来算值的，而4是（从小到大）来算值的。

---

涉及到的知识点：

1. 箭头函数
2. 函数参数默认值
3. 解构赋值
4. 尾调用优化
5. 立即执行函数
6. 闭包