JavaScript算法之遞歸

時間 2019-11-07

原文原文鏈接

今天來了解下既愛又恨的 -- 遞歸javascript

什麼是「遞歸」

給你講一個故事就明白了，什麼故事呢？前端

從前有座山，山裏有個廟，廟裏有個老和尚在給小和尚講故事，講的是從前有座山，山裏有個廟，廟裏有個老和尚在給小和尚講故事，講的是從前有座山。。。java

這就是一個典型的遞歸，在不考慮歲數等自身的條件下，這將是個死遞歸，沒有終止條件。es6

再舉一個例子。不知道你有沒有看過一部號稱不怕劇透的電影《盜夢空間》。小李子團隊們每次執行任務的時候，都會進入睡眠模式。若是在夢中任務還完不成的話，就再來個夢中夢，繼續去執行任務。若是還不行，就再來一層夢。一樣，若是須要回到現實的話，也必須得從最深的那層夢中醒來，而後到第一層夢，而後回到現實中。算法

這個過程也能夠當作遞歸。層層夢是遞，層層醒是歸。

遞歸本質上是將原來的問題，轉化爲更小的同一問題 大白話就是一個函數不斷的調用本身。後端

接下來看一個遞歸的經典例題，就是計算 Fibonacci 數列。數組

指的是這樣一個數列：一、一、二、三、五、八、1三、2一、3四、……、x;緩存

代碼展現爲：bash

function Fibonacci (n) {
  if ( n <= 2 ) {return 1};

  return Fibonacci(n - 1) + Fibonacci(n - 2);
}
複製代碼

遞歸三要素

1.一個問題的解能夠分解爲幾個更小的同一題的解

好比說上面的數列，若是要求解第 10 位數是多少 fn(10)，能夠分解爲求第 9 位數 fn(9) 和第 8 位數 fn(8) 是多少，相似這樣分解。數據結構

2.分解後的子問題只存在數據不同的問題。

好比說上面的數列，每次分解後，所造成的子問題求解方式都同樣，只是說每次數據規模變了。

3.存在遞歸終止條件

這個是必須存在的，把問題一層一層的分解下去，可是不能無限循環下去了。好比說上面的數列，當 n 小於等於 2 的時候，就會中止，此時就已經知道了第一個數和第二個數是多少了，這就是終止條件。不能像老和尚給小和尚講故事那樣，永無止境。

實現遞歸

首先來分析一個簡單的例題，用遞歸的方式來求解數組中每一個元素的和。

根據上面所講的三要素，來分解下這個問題。

求解數組 arr 的和咱們能夠分解成是第一個數而後加上剩餘數的和，以此類推能夠獲得以下分解：

const arr = [1,2,3,4,5,6,7,...,n];
 sum(arr[0]+...+arr[n]) = arr[0] + sum(arr[1]+...+arr[n]);
 sum(arr[1]+...+arr[n]) = arr[1] + sum(arr[2]+...+arr[n]);
                ....
 sum(arr[n]) = arr[n] + sum([]);
複製代碼

而後能夠推導出一個公式：

x = 0;
sum(arr, x) = arr[x] + sum(arr,x+1); // x：表示數組的長度
複製代碼

再考慮一個終止條件，當 x 增加到和數組長度同樣的時候，就該中止了，並且此時應該返回 0。因此綜上咱們能夠得出此題的解：

{
    function sum(arr) {
        const total = function(arr, l) {
            if(l == arr.length) {
                return 0;
            }
            return arr[l] + total(arr, l + 1);
        }
        return total(arr, 0);
    }
    sum([1,2,3,4,5,6,9,10]);
}
複製代碼

寫遞歸代碼的關鍵就是找到如何將原來的問題轉化爲更小的同一問題，而且基於此寫出遞推公式，而後再推敲終止條件，最後將遞推公式和終止條件合成最終代碼。

注意事項

1.遞歸容易堆棧溢出

函數調用會使用棧來保存臨時變量。每調用一個函數，都會將臨時變量封裝爲棧幀壓入內存棧，等函數執行完成返回時，纔出棧。而遞歸很是耗費內存，由於須要同時保存成千上百個調用幀，當數據規模較大的時候很容易發生「棧溢出」錯誤（stack overflow）。

好比說一個利用遞歸求階乘的函數：

function factorial(n) {
  if (n === 1) return 1;
  return n * factorial(n - 1);
}
複製代碼

那如何避免這種錯誤呢？咱們能夠在代碼中添加一個參數，記錄遞歸調用的次數。當大於一個數字的時候，手動設置報錯信息。好比說上面的例子：

{
    let count = 0;
    function factorial(n) {
        count ++;
        if (count > 1000) {
            console.error('超過了最大調用次數');
            return;
        }
        if (n === 1) return 1;
        return n * factorial(n - 1);
      }
      factorial(2000)
}
複製代碼

固然這個數字事先沒法估算，只適合一些最大深度比較低的遞歸調用。

2.警戒遞歸中的重複計算

好比說上文提到的經典數列：

function Fibonacci (n) {
  if ( n <= 2 ) {return 1};
  return Fibonacci(n - 1) + Fibonacci(n - 2);
}
複製代碼

代碼很簡介，可是卻包含了大量的重複計算。

假設要求計算 f(5)

f(5) = f(4) + f(3)；

因而會遞歸計算 f(4) 和 f(3)；

接着計算 f(4)

f(4) = f(3)+ f(2);

因而會遞歸計算f(3)和f(2);
複製代碼

能夠看到，計算 f(5) 和 f(4) 中都要計算 f(3)，但這兩次 f(3) 會重複計算，這就是遞歸的最大問題，對於同一個 f(n)，不能複用。

你好奇過計算一個 f(n) 到底須要有多少次遞歸調用呢？

咱們能夠在代碼里加一個計數驗證一下。

{
    let count = 0;
    function Fibonacci (n) {
        count ++;
      if ( n <= 2 ) {return 1};
    
      return Fibonacci(n - 1) + Fibonacci(n - 2);
    }
    Fibonacci(n); // n: 要計算的值
    console.log(count);
}
複製代碼

實驗的結果：

f(5) count = 9

f(10) count = 109

f(25) count = 150049

f(35) count = 18454929

f(40) count = 204668309

f(45) … 抱歉，我機器太慢，算不出來
複製代碼

能夠把代碼在你的機器上試試哦，這看似簡單的兩句代碼的時間複雜度卻達到了O的指數級。

因此優化算法刻不容緩。

爲了不重複計算，能夠利用一個對象來保存已經求解過的 f(n)。當遞歸調用到 f(n) 時，先判斷是否求解過了。若是是，則直接從對象中取值返回，不需計算，不然的話，再進行遞歸，這樣就能避免剛講的問題了。

因此優化後的代碼以下：

{
    function Fibonacci() {
        this.obj = {};
        this.count = 0;
    }
    Fibonacci.prototype.getF = function(n) {
        this.count ++;
        if ( n <= 2 ) {return 1};
        if (this.obj.hasOwnProperty(n)) {
            return this.obj[n];
        }
        const ret = this.getF(n - 1) + this.getF(n -2);
        this.obj[n] = ret;
        return ret;
    }
    
    var f = new Fibonacci();
    f.getF(45);
}
複製代碼

加入了緩存之後，由上圖能夠看出來，如今的時間複雜度只是 O(n) 的。

非遞歸實現

利用遞歸實現有缺有優，優勢是短小精悍；而缺點就是空間複雜度高、有堆棧溢出的風險、存在重複計算、過多的函數調用會耗時較多等問題。因此，在選擇算法時，要根據實際狀況來選擇合適的方式來實現。

通常來講，遞歸能夠實現的利用 for 循環均可以實現。好比說上文的數組求和。

接下里咱們用 for 循環來改寫斐波那契數列。

也比較簡單，話很少說，直接行上代碼展現：

{
    function fibonacci(n) {
        if (n === 1 || n === 2) {
            return 1;
        }
        let one = 1;
        let two = 1;
        let temp = null;
        for(let i = 3; i <= n; i++) {
            temp = one + two;     // 累加前兩個數的和
            one = two;
            two = temp;
        }
        return temp;
    }
    console.log(fibonacci(40));
}
複製代碼