递归-一一网

1. 尾调用优化

什么是尾调用:

就是指某个函数的最后一步是调用另一个函数。

尾调用优化:

尾调用之所以与其他调用不同，就在于它的特殊的调用位置。我们知道，函数调用会在内存形成一个”调用记录”，又称”调用帧”（call frame），保存调用位置和内部变量等信息。如果在函数A的内部调用函数B，那么在A的调用记录上方，还会形成一个B的调用记录。等到B运行结束，将结果返回到A，B的调用记录才会消失。如果函数B内部还调用函数C，那就还有一个C的调用记录栈，以此类推。所有的调用记录，就形成一个”调用栈”（call stack）。尾调用由于是函数的最后一步操作，所以不需要保留外层函数的调用记录，因为调用位置、内部变量等信息都不会再用到了，只要直接用内层函数的调用记录，取代外层函数的调用记录就可以了。这就叫做”尾调用优化”（Tail call optimization），即只保留内层函数的调用记录。如果所有函数都是尾调用，那么完全可以做到每次执行时，调用记录只有一项，这将大大节省内存。这就是”尾调用优化”的意义。

尾调用用来删除外层无用的调用侦，只保留内层函数的调用侦，来节省浏览器的内存

尾递归:

函数调用自身，称为递归。如果尾调用自身，就称为尾递归。递归非常耗费内存，因为需要同时保存成千上百个调用记录，很容易发生”栈溢出”错误（stack overflow）。但对于尾递归来说，由于只存在一个调用记录，所以永远不会发生”栈溢出”错误。

// 这是一个阶乘函数，计算n的阶乘，最多需要保存n个调用记录，复杂度 O(n) 。
function factorial(n) {
  if (n === 1) return 1;
  return n * factorial(n - 1);
}

factorial(5) // 120

// 如果改写成尾递归，只保留一个调用记录，复杂度 O(1)
function factorial(n, total) {
  if (n === 1) return total;
  return factorial(n - 1, n * total);
}

factorial(5, 1) // 120
复制代码

递归函数的改写

尾递归的实现，往往需要改写递归函数，确保最后一步只调用自身。做到这一点的方法，就是把所有用到的内部变量改写成函数的参数。比如上面的例子，阶乘函数 factorial 需要用到一个中间变量 total ，那就把这个中间变量改写成函数的参数。这样做的缺点就是不太直观，第一眼很难看出来，为什么计算5的阶乘，需要传入两个参数5和1？

两个方法可以解决这个问题。方法一是在尾递归函数之外，再提供一个正常形式的函数

// 这里通过一个正常形式的阶乘函数 factorial ，调用尾递归函数 tailFactorial ，看起来就正常多了
function tailFactorial(n, total) {
  if (n === 1) return total;
  return tailFactorial(n - 1, n * total);
}

function factorial(n) {
  return tailFactorial(n, 1);
}

factorial(5) // 120
复制代码

函数式编程有一个概念，叫做柯里化（currying），意思是将多参数的函数转换成单参数的形式。这里也可以使用柯里化

// 这里通过柯里化，将尾递归函数 tailFactorial 变为只接受1个参数的 factorial 

function currying(fn, n) {
  return function (m) {
    return fn.call(this, m, n);
  };
}

function tailFactorial(n, total) {
  if (n === 1) return total;
  return tailFactorial(n - 1, n * total);
}

const factorial = currying(tailFactorial, 1);

factorial(5) // 120
复制代码

第二种方法就简单多了，就是采用ES6的函数默认值

function factorial(n, total = 1) {
  if (n === 1) return total;
  return factorial(n - 1, n * total);
}

factorial(5) // 120
复制代码

总结一下，递归本质上是一种循环操作。纯粹的函数式编程语言没有循环操作命令，所有的循环都用递归实现，这就是为什么尾递归对这些语言极其重要。对于其他支持”尾调用优化”的语言（比如Lua，ES6），只需要知道循环可以用递归代替，而一旦使用递归，就最好使用尾递归

解决堆栈溢出报错

如果传递的参数过大，也会造成stack overflow。根本原因是执行上下文太多导致的爆栈。这时可以使用弹跳床函数。所谓弹跳床函数，相当于函数的一个中转站。

// 弹跳床函数，执行函数，如果函数返回类型还是函数则继续执行，直到执行结束
function trampoline(f) {
  while (f && f instanceof Function) {
    f = f();
  }
  return f;
}

// 相应的我们的原函数需要改写如下
function sum(n, result = 1) {
  if (n <= 1) return result;
    return sum.bind(null, n - 1, result + n);
}

// 此时调用就不会包堆栈溢出了
trampoline(sum(100000)); // 2432902008176640000
复制代码

2. 实现一个斐波那契数列

实现一个斐波拉契数列，已知第一项为0，第二项为1，第三项为1，后一项是前两项之和，即f(n) = f(n – 1) + f(n -2)

// 最简单实现
function f(n) {
    if(n === 0) return 0;
    if(n === 1) return 1;
    return f(n - 1) + f(n -2);
}
复制代码

上面不使用尾递归，项数稍大点就发生”栈溢出“了

// 尾递归优化
function f(n, prev, next) {
    if(n <= 1) {
        return next;
    }
    return f(n - 1, next, prev + next);
}
console.log(f(10, 0, 1)); // 55
console.log(f(100, 0, 1)); // 354224848179262000000
console.log(f(1000, 0, 1)); // 4.346655768693743e+208
复制代码

科里化改写:

尾递归的实现，往往需要改写递归函数，确保最后一步只调用自身。做到这一点的方法，就是把所有用到的内部变量改写成函数的参数。但是这样的话就会增加初始入参，比如fibonacci(10, 1, 1)，后面的两个参数1和1意思不明确，直接用fibonacci(100)才是习惯用法。所以需要在中间预先设置好初始入参，将多个入参转化成单个入参的形式，叫做函数柯理化。通用方式为：

function curry(fn) {
    var args = Array.prototype.slice.call(arguments, 1);
    return function () {
        var innerArgs = Array.prototype.slice.call(arguments);
        var finalArgs = innerArgs.concat(args);
        return fn.apply(null, finalArgs);
    }
}
复制代码

// 用科里化改写阶乘
function tailFactorial(n, total) {
    if(n === 1) return total;
    return tailFactorial(n - 1, n * total);
}

var factorial = curry(tailFactorial, 1); 
console.log(factorial(5)); // 120

// 同样改写斐波拉契数列
function tailFibonacci(n, prev, next) {
    if(n <= 1) return next;
    return tailFibonacci(n - 1, next, prev + next);
}

var fibonacci = curry(tailFibonacci, 0, 1);
console.log(fibonacci(10)); // 55
console.log(fibonacci(100)); // 354224848179262000000
console.log(fibonacci(1000)); // 4.346655768693743e+208
复制代码

用ES6改写:

柯理化的过程其实是初始化一些参数的过程，在ES6中，是可以直接函数参数默认赋值的。

// 用ES6改写阶乘
const factorial = (n, total = 1) => {
    if(n === 1) return total;
    return factorial(n - 1, n * total);
}
console.log(factorial(5)); // 120
// 用ES6改写斐波那契数列
const fibonacci = (n, prev = 0, next = 1) => {
    if(n <= 1) return next;
    return fibonacci(n - 1, next, prev + next);
}
console.log(fibonacci(10)); // 55
console.log(fibonacci(100)); // 354224848179262000000
console.log(fibonacci(1000)); // 4.346655768693743e+208
复制代码