递归

// let i = 0,
//     result = 0;
// function count(i) {
//     if (i==10) {
//         return false;
//     }else {
//         result += i;
//         i++;
//         console.log(result,i);
//         count(i);
//     }
// }    
// count(i);

// 递归累加
// function count(n) {
//     if(n===1 || n===0){
//         return 1;
//     }
//     return n + count(n-1);
// }
// console.log(count(10));

// 递归阶乘
function multiplication(n) {
    if (n===1 || n===0) {
        return 1;
    }
    return n * multiplication(n-1)
}
console.log(multiplication(4));


/* 
JavaScript 调用栈大小的限制
    递归并不会无限地执行下
    去，浏览器会抛出错误，也就是所谓的栈溢出错误（stack overflow error）
*/
// 递归求斐波那契数
// function fibonacci(n) {
//     if(n < 1) return 0;
//     if(n <= 2) return 1;
//     return fibonacci(n-1) + fibonacci(n-2)
// }
// console.log(fibonacci(6));

// 记忆化斐波那契数--它可以防止递归算法重复计算一个相同的值
function fibonacciMemosization(n) {
    const memo = [0, 1];
    function fibonacci(n) {
        console.log('n',n);
        if (memo[n] != null) return memo[n];
        return memo[n] = fibonacci(n-1, memo) + fibonacci(n-2, memo);
    }
    // const fibonacci = (n) => {
    //     console.log('memo',memo);
    //     if (memo[n] != null) return memo[n];
    //     return memo[n] = fibonacci(n-1, memo) + fibonacci(n-2, memo);
    // };
    // console.log(fibonacci);
    return fibonacci(n);
}
let test = fibonacciMemosization(6)
console.log(test);


/* 
为什么要用递归？它更快吗
        迭代的版本比递归的版本快很多，所以这表示递归更慢。但是，再看看三个不同版本的代码。
        递归版本更容易理解，需要的代码通常也更少。另外，对一些算法来说，迭代的解法可能不可用，
        而且有了尾调用优化，递归的多余消耗甚至可能被消除。
        所以，我们经常使用递归，因为用它来解决问题会更简单
*/