媒介

面某東，有一道題目是

完成一個斐波拉契數列， 已知第一項為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);
}

下面來溫習一下知識點：尾挪用和尾遞歸。PS：更好的計劃請繼承往下看。

尾挪用

尾挪用是指某個函數的末了一步是挪用另一個函數。

以下三種狀況都不是尾挪用：

// 狀況一
function f(x) {
    let y = g(x);
    return y;
}

// 狀況二
function f(x) {
    return g(x) + 1;
}

// 狀況三
function f(x) {
    g(x);
}

狀況一是挪用函數g以後，另有賦值操縱，所以不屬於尾挪用，縱然語義完整一樣。狀況二也是屬於挪用后另有操縱。狀況三等同於：

g(x);
return undefined;

函數挪用會在內存構成一個“挪用紀錄”，又稱“挪用幀”，保存挪用位置和內存變量等信息。假如在函數A的內部挪用函數B，那末在A的挪用幀上方，還會構成一個B的挪用幀。比及B運轉完畢，將效果返回到A，B的挪用幀才會消逝。假如函數B內部還挪用函數C，那就另有一個C的挪用幀，順次類推。一切的挪用幀，就構成一個“挪用棧”。

尾挪用由因而函數的末了一步操縱，一切不須要保存外層函數的挪用幀，因為挪用位置、內部變量等信息都不會再用到了，只需直接用內層函數的挪用幀，庖代外層函數的挪用幀就能夠了。

function f() {
    let m = 0;
    let n = 2;
    return g(m + n);
}
f();

// 等同於
function f() {
    return g(3);
}
f();

// 等同於
g(3);

假如一切函數都是尾挪用，那末完整能夠做到每次執行時，挪用幀只需一項，這將大大節約內存。這就是“尾挪用優化”。

注重，只需不再用到外層函數的內部變量，內層函數的挪用幀才會庖代外層函數的挪用幀，不然就沒法舉行“尾挪用優化”。

function addOne(a) {
    var one = 1;
    function inner(b) {
        return b + one;
    }
    return inner(a);
}

尾遞歸

函數挪用本身，稱為遞歸。假如尾挪用本身，就稱為尾遞歸。遞歸異常消耗內存，因為須要同時保存成百上千挪用幀，很容易發作“棧溢出”毛病。但關於尾遞歸來講，因為只存在一個挪用幀，所以永久不會發作“棧溢出”毛病。

function factorial(n) {
    if (n === 1) return 1;
    return n * factorial(n - 1);
}
console.log(factorial(5)); // 120

上面最多保存n個挪用紀錄，複雜度是O(n)。

假如改成尾遞歸，只保存一個挪用紀錄，複雜度O(1)。

function factorial(n, total) {
    if (n === 0) return total;
    return factorial(n - 1, n * total);
}
console.log(factorial(5, 1)); // 120

下面回到我們的主題，盤算Fibonacci數列。

function fibonacci(n) {
    if(n <= 1) return 1;
    return fibonacci(n -1) + fibonacci(n -2);
}
console.log(fibonacci(10)); // 89
console.log(fibonacci(50)); // stack overflow

上面不應用尾遞歸，項數稍大點就發作”棧溢出“了。

function fibonacci(n, prev, next) {
    if(n <= 1) return next;
    return fibonacci(n-1, next, prev + next);
}
console.log(fibonacci(10, 1, 1)); // 89
console.log(fibonacci(100, 1, 1)); // 573147844013817200000
console.log(fibonacci(1000, 1, 1)); // 7.0330367711422765e+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(fibonacci, 1, 1);
console.log(fibonacci(10)); // 89
console.log(fibonacci(100)); // 573147844013817200000
console.log(fibonacci(1000)); // 7.0330367711422765e+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 = 1, next = 1) => {
    if(n <= 1) return next;
    return fibonacci(n - 1, next, prev + next);
}
console.log(fibonacci(10)); // 89
console.log(fibonacci(100)); // 573147844013817200000
console.log(fibonacci(1000)); // 7.0330367711422765e+208

ps：用ES6極大方便了算法應用！

總結

綜上，這個題目解決的思緒是：

1. 尾遞歸+函數柯理化；
2. 尾遞歸+ES6默許賦值；

算法題永久要想到機能題目，不能只停留到外表，默哀三秒鐘，[傷心臉.gif]。