js生成斐波那契数列的几种写法总结

1. 使用generator函数和for of循环实现斐波那契数列；

// 使用generator函数和for of循环实现斐波那契数列；
/**
 * @function fibNumbers
 * @description 生成斐波那契数列的函数
 * @param {number} num 表示要生成最大数不超过num的斐波那契数列
 * @return 返回值一个斐波那契数列的数组
 */
function fibNumbers(num) {
    function* fibonacci() {
        let [prev, curr] = [0, 1];
        for (;;) {
            yield curr;
            [prev, curr] = [curr, prev + curr];
        }
    }
    const numbers = [];
    for (let n of fibonacci()) {
        if (n > num) break;
        // console.log(n);
        numbers.push(n);
    }
    return numbers;
}
const fibonacciArr = fibNumbers(50);
// 输出： [1, 1, 2, 3, 5, 8, 13, 21, 34]

 2. 使用递归和for循环求第n个斐波那契数：

 

// 计算第n个斐波那契数是多少的函数
// 1.for循环方式，速度最快
function fibonacciByFor(n) {
    if (n === 1 || n === 2) {
        return 1;
    }
    let [pre, cur] = [1, 1];
    // 如果是以下标计算，for循环中第二个语句为 (i <= n;)
    for(let i = 2;i < n;i++){
        // 1.1 一般的写法, 执行耗时最短
        const sum = pre + cur;
        pre = cur;
        cur = sum;
        // 1.2 解构赋值的写法
        // [pre, cur] = [cur, pre + cur];
    }
    // console.log(`第${n}个斐波那契数为：`, cur);
    return cur;
}
console.time('for循环斐波那契');
fibonacciByFor(20); // 输出：6765, 耗时：0.06689453125 ms
console.timeEnd('for循环斐波那契');

// 2.递归方式，性能没有for循环好
// 2.1 普通递归
// 如果n为5，则会重复计算fibByRecursion(4)两次
// n越大则重复计算的次数越多，
// 这样会导致堆栈溢出, 浏览器出现假死状态，导致无法及时计算出结果(当值设置为50的时候就很明显了)
function fibByRecursion(n) {
    if (n === 1 || n === 2) {
        return 1;
    }
    return fibByRecursion(n - 2) + fibByRecursion(n - 1);
}
console.time('普通递归');
fibByRecursion(20); // 输出：6765, 耗时：1.19287109375 ms
console.timeEnd('普通递归');

// 2.2 递归改进1，避免重复计算
function fibByRecursion1(n) {
    // 把前后两位数作为参数，在传递参数时进行计算
    return fib(n, 1, 1);
    function fib(n, pre, cur) {
        if (n === 1) {
            return pre;
        }
        if (n === 2) {
            return cur;
        }
        return fib(n - 1, cur, pre + cur);
    }
}
console.time('递归改进1');
fibByRecursion1(20); // 输出：6765, 耗时：0.0888671875 ms
console.timeEnd('递归改进1');

// 2.3 递归改进2，使用闭包的作用域特性把计算的结果存储在数组中，避免了重复计算
function fibByRecursion2(n) {
    let initMembers = [0, 1];
    return fib(n);
    function fib(n) {
        if (initMembers[n] === undefined) {
            // 把不存在的项存到数组中，下次再找到当前存储的第n项时就不会重新计算了
            initMembers[n] = fib(n - 2) + fib(n - 1);
        }
        return initMembers[n];
    }
}
console.time('递归改进2');
fibByRecursion2(20); // 输出：6765, 耗时：0.091796875 ms
console.timeEnd('递归改进2');

// 2.4 递归改进3，提取fibByRecursion2中的存储计算结果的功能函数
function fibByRecursion3(n) {
    let fib = setMemory(function (n) {
        if (n === 1 || n === 2) {
            return 1;
        }
        return fib(n - 2) + fib(n - 1);
    });
    return fib(n);
    // 将存储功能提取到一个函数中
    function setMemory(fn) {
        let memorizer = [];
        return function (n) {
            if (memorizer[n] === undefined) {
                memorizer[n] = fn(n);
            }
            return memorizer[n];
        }
    }
}
console.time('递归改进3');
fibByRecursion3(20); // 输出：6765, 耗时：0.092041015625 ms
console.timeEnd('递归改进3');

3. 参考链接：

3.1 JS写斐波那契数列的几种方法；

3.2【java】递归次数过多导致堆栈溢出；