那些關於前端資料結構與演算法

GitChat技術雜談發表於2017-11-21
前端資料結構演算法

本文來自作者 張振 在 GitChat 上分享「前端資料結構與演算法的奧祕」，「閱讀原文」檢視交流實錄

「文末高能」

「更多同類話題」

「檢視全部話題」

編輯 | 嘉仔

目前前端的在網際網路行業比重越來越加深,前端不僅限於網頁製作，還包括移動端及其服務端的搭建。

所以對從業人員要求越來越高,如果自身不重視資料結構與演算法這樣基礎知識，很有可能數年來從事單一的毫無成長的職業發展，只有基礎牢固，演算法精通的人 才能未來的道路上越走越遠，就像蓋高樓大廈，我們不是程式碼的搬運工，而是設計的領航人。

什麼是資料結構

面試官一問到什麼是資料結構。 很多人都蒙圈了 答不上來。

答案：資料元素相互之間存在的一種和多種特定的關係集合 包括二個部分組成邏輯結構，儲存結構。

邏輯結構

簡單的來說 邏輯結構就是資料之間的關係,邏輯結構大概統一的可以分成兩種 一種是線性結構，非線性結構 。

線性結構

是一個有序資料元素的集合。 其中資料元素之間的關係是一對一的關係，即除了第一個和最後一個資料元素之外，其它資料元素都是首尾相接的。

常用的線性結構有: 列表，棧，佇列，連結串列，線性表，集合。

非線性結構

各個資料元素不再保持在一個線性序列中，每個資料元素可能與零個或者多個其他資料元素髮生聯絡。

常見的線性結構有 二維陣列，多維陣列，廣義表，樹(二叉樹等)，圖(網)等。

儲存結構

邏輯結構指的是資料間的關係，而儲存結構是邏輯結構用計算機語言的實現。 常見的儲存結構有順序儲存、鏈式儲存、索引儲存以及雜湊儲存（雜湊表）。

資料結構-線性結構-陣列

作為前端大家估計用的最多的就是陣列 其實陣列是一個儲存元素的線性集合 元素可以通過索引來任意存取 索引用來計算儲存位置的偏移量，幾乎所有的程式語言都有類似的資料結構。

然而 JS 中的陣列是一種特殊的物件， 用來表示偏移量的索引是該物件的屬性，索引為整數的時候，這個索引在內部被強轉換為字串型別，這也是 JS 物件中資料名必須是字串的原因了，JS中的陣列嚴格來說應該稱為物件，是特殊的 JS 物件。

以下是簡單的陣列操作 ：

  1. 建立陣列：2種方式

    1.操作符
var ary = []   

2.array的建構函式方式
var ary = new Array()

    這兩方式都是建立陣列 大多數JS專家推薦使用[]操作符，效率更高。

  2. 由字串生成陣列 split()

  3. 查詢元素 indexOf()

  4. 陣列轉化成字串 join() toString()

  5. 由已有的陣列建立新陣列 concat() splice()

  6. 為陣列增加元素 push() unshift()

  7. 為陣列刪除元素  pop() shift() splice()

  8. 為陣列排序 sort()

  9. 陣列迭代器 forEach() map()  filter()

資料結構-線性結構-列表

列表是一組有序的的資料，如果資料結構非常複雜，那麼列表的作用就沒有那麼大了。

學習如何來設計我們自己的抽象類，主要去學習設計思想及編寫程式碼的方式。

如何實驗列表類  (建構函式 + 原型的方式)。

function List() {
    // 列表的元素個數
    this.listSize = 0;

    // 列表的當前位置 是第幾個
    this.pos = 0;

    // 初始化一個空陣列來儲存列表元素
    this.dataStore = [];
}
 List.prototype = (function () {
      return {
         clear: clear,
         find: find,
         toString: toString,
         insert: insert,
         append: append,
         remove: remove,
         front: front,
         end: end,
         prev: prev,
         next: next,
         hasNext: hasNext,
         hasPrev: hasPrev,
         length: length,
         currPos: currPos,
         moveTo: moveTo,
         getElement: getElement
     };
     /**
       * 給列表最後新增元素的時候，列表元素個數+1
       * @param element
       */
     function append(element) {
          this.listSize++;
          this.dataSource.push(element);
      }

     /**
      * @param element 如果傳入的是物件，需要判斷是否是物件以及兩個物件是否相等
      * @returns {number} 如果找到，返回位置，否則-1
      */
      function find(element) {
          for (var i = 0; i < this.dataSource.length; i++) {
             if (this.dataSource[i] === element) {
                  return i;
              }
         }
         return -1;
      }

     /**
      * 返回列表元素的個數
      * @returns {number}
      */
     function length() {
          return this.listSize;
      }

     /**
      * 刪除元素成功，元素個數-1
      * @param element
      * @returns {boolean}
      */
      function remove(element) {
          var removeIndex = this.find(element);
          if (removeIndex !== -1) {
              this.dataSource.splice(removeIndex, 1);
              this.listSize--;
              return true;
          }
          return false;
     }

      /**
       * 返回要展示的列表
       * @returns {string}
       */
     function toString() {
          return this.dataSource.toString();
      }

      /**
       * 插入某個元素
       * @param element 要插入的元素
       * @param afterElement 列表中的元素之後
       * @returns {boolean}
       */
      function insert(element, afterElement) {
          var insertIndex = this.find(afterElement);
          if (insertIndex !== -1) {
              this.dataSource.splice(insertIndex + 1, 0, element);
              this.listSize++;
              return true;
          }
          return false;
      }

      /**
       * 清空列表中的所有元素
      */
     function clear() {
         delete this.dataSource;
         this.dataSource = [];
         this.listSize = this.pos = 0;
      }

     /**
     * 將列表的當前位置移動到第一個元素
     */
     function front() {
         this.pos = 0;
      }

     /**
     * 將列表的當前位置移動到最後一個元素
     */
     function end() {
         this.pos = this.listSize - 1;
      }

     /**
      * 返回當前位置的元素
      * @returns {*}
      */
       function getElement() {
         return this.dataSource[this.pos];
      }

     /**
      * 將當前位置向前移動一位
      */
     function prev() {
         --this.pos;
     }

     /**
      * 將當前位置向後移動一位
      */
     function next() {
         ++this.pos;
     }

     /**
      * 返回列表的當前位置
      * @returns {number|*}
      */
     function currPos() {
         return this.pos;
     }

     /**
      * 移動到指定位置
      * @param position
      */
     function moveTo(position) {
         this.pos = position;
    }

     /**
     * 判斷是否有後一位
      * @returns {boolean}
      */
     function hasNext() {
         return this.pos < this.listSize;
     }

     /**
      * 判斷是否有前一位
      * @returns {boolean}
      */
     function hasPrev() {
         return this.pos >= 0;
     }
   }());
需求 假如有20部影碟 屬於一個TXT檔案 記錄當前使用者都拿走了哪個碟。
 var fs = require('fs');
  var movies = createMovies('films.txt');
  /**
   * 讀取資料，返回陣列
   * @param file
   * @returns {Array|*}
   */
  function createMovies(file) {
      var arr = fs.readFileSync(file, 'utf-8').split("\n");
     for (var i = 0; i < arr.length; i++) {
         arr[i] = arr[i].trim();
     }
     return arr;
 }


 var movieList = new List();
    for (var i = 0; i < movies.length; i++) {
     movieList.append(movies[i]);
 } 

 var customers = new List();
 /**
  * 使用者物件
  * @param name 使用者姓名
  * @param movie 使用者拿走的影碟
  * @constructor
  */
 var Customer = function (name, movie) {
      this.name = name;
    this.movie = movie;
 };
 /**
  * 使用者拿走影碟
  * @param name 使用者的名字
  * @param movie 影碟的名字
  * @param movieList 所有影碟列表
  * @param customerList 使用者列表
  */
 function checkOut(name, movie, movieList, customerList) {
     if (movieList.find(movie) !== -1) {
         var user = new Customer(name, movie);
         customerList.append(user);//使用者拿掉影碟，講使用者加入customerList
         movieList.remove(movie);//從movieList中刪除掉被拿掉的影碟
     } else {
         console.log('沒有該電影');
     }
 }
資料結構-線性結構-棧
棧：限定僅在表尾進行插入和刪除操作的線性表，允許插入和刪除的一端成為棧頂，另一端稱為棧底，不含任何元素的棧稱為空棧。  基本用法 就是 push pop  (JS已經幫我們實現了)。
棧具有FILO（first in last out）即先進後出的特性 。例如數制間的相互轉化(可以利用棧將一個數字從一個數制轉換成另一個數制)。
講數字轉換為二進位制或者八進位制

function mulbase(num , base) {
    var s = new Stack()
    do {
        s.push(num % base)
        num = Math.floor (num /= base)    
    } while (num > 0);
    var content = " ";
    while (s.length() > 0) {
      content  += s.pop()
    }
    return content
}
資料結構-線性結構-佇列
佇列 (Queue)是一種先進先出 (First-In-First-Out, FIFO) 的資料結構，與棧不同的是，它操作的元素是在兩端，而且進行的是不一樣的操作。
向佇列的隊尾加入一個元素叫做入隊 (enQueue)，向佇列的隊首刪除一個元素叫做出佇列。
列表具有即先進先出的特性 , 由於JS是單執行緒的, 所以導致了我們程式碼在執行的時候 只能執行一個任務，在實際的開發當中 我們已應該遇到過很多的佇列問題,看原始碼是如何巧妙的運用佇列的。
在我們執行動畫的時候其實就是對佇列的應用。
(function($) {

  window.$ = $;

})
(function() {

  var rquickExpr = /^(?:#([\w-]*))$/;

  function aQuery(selector) {
    return new aQuery.fn.init(selector);
  }

  /**
   * 動畫
   * @return {[type]} [description]
   */
  var animation = function() {
    var self = {};
    var Queue = []; //佇列的位置
    var open = false //動畫狀態
    var first = true; //通過add介面觸發

    var makeAnim = function(element, options, cb) {
      var width = options.width
      element.style.webkitTransitionDuration = '3000ms';
      element.style.webkitTransform = 'translate3d(' + width + 'px,0,0)';

      //監聽動畫完結
      element.addEventListener('webkitTransitionEnd', function() {
        cb()
      });
    }
    var _fire = function() {
      //加入動畫正在觸發
      if (!open) {
        var onceanimate = Queue.shift();
        if (onceanimate) {
          open = true;
          //next
          onceanimate(function() {
            open = false;
            _fire();
          });
        } else {
          open = true;
        }
      }
    }

    return self = {
      //增加佇列
      add: function(element, options) {
        Queue.push(function(cb) {
          makeAnim(element, options, cb);
        });

        //如果有一個佇列立刻觸發動畫
        if (first && Queue.length) {
          first = false;
          self.fire();
        }
      },
      //觸發
      fire: function() {
        _fire();
      }
    }
  }();
  aQuery.fn = aQuery.prototype = {
     animate: function(options) {
       animation.add(this.element, options);
       return this;
     }
   }

     var init = aQuery.fn.init = function(selector) {
     var match = rquickExpr.exec(selector);
     var element = document.getElementById(match[1])
     this.element = element;
     return this;
   }

   init.prototype = aQuery.fn;
   return aQuery;
 }());

 //dom
 var oDiv = document.getElementById('div1');

 //呼叫
 oDiv.onclick = function() {
   $('#div1').animate({
     'width': '500'
   }).animate({
     'width': '300'
   }).animate({
     'width': '1000'
   });
 };
面試題 : JS如何實現一個非同步佇列來按順序執行 ？
資料結構-線性結構-連結串列
在JS當中 佇列與棧都是一種特殊的線性結構, 也是一種簡單的基於陣列順序的儲存結構, 由於JS的解析器的原因  不存在其他語言程式設計中出現的 陣列固定長度一說。
線性表的順序儲存結構，最大的缺點就是改變其中一個元素的排列時都會引起整個合集的變化，其原因就是在記憶體中的儲存本來就是連貫沒有間隙的，刪除一個自然就要補上。針對這種結構的優化之後就出現了鏈式儲存結構。
連結串列是由一個組節點組成的集合,每一個節點都使用一個物件的引用指向它的後繼, 指向另一個節點的引用叫鏈。
連結串列包括: 單向連結串列，雙向連結串列，迴圈連結串列。
我們需要先定義節點物件是什麼樣子。按照 Codewars 上的設定，一個節點物件有兩個屬性 data 和 next 。data 是這個節點的值，next 是下一個節點的引用。這是預設的類别範本。
設計一個單項鍊表：
function LinkedList () {
  var Node = function (element) {
    this.element = element
    // 儲存指向下個元素的引用，預設為null
    this.next = null
  }

  // 連結串列長度
  var length = 0
  // head儲存指向第一個元素的引用
  var head = null
}
連結串列需要實現以下方法：
append(element)：向連結串列尾部新增元素
insert(position, element)：向連結串列特定位置插入元素
removeAt(position)：從連結串列特定位置移除一項
remove(element)：在連結串列中移除某元素
indexOf(element)：返回元素在連結串列中的索引，若不存在則返回-1
isEmpty()：如果連結串列不包含任何元素就返回true，否則為false
size()：返回連結串列長度
toString()：返回元素的值轉成字串
實現 append
類似陣列的 push 方法，但是隻能新增一個元素。
實現方法的時候分兩種情況考慮：1. 連結串列為空時新增第一個元素；2. 連結串列不為空時在尾部新增元素。
this.append = function (element) {

  var node = new Node(element),
      current

  if (head === null) { // 當連結串列為空時
    // 將head指向新增的元素
    head = node
  } else { // 連結串列不為空
    // 使用一個current變數從head開始迭代連結串列
    current = head

    // 迭代連結串列，直到找到最後一項
    while (current.next) {
      current = current.next
    }

    // 找到最後一項，將其next賦為node，建立連結
    current.next = node
  }

  // 更新列表長度
  length++
}
實現 removeAt
在連結串列中特定位置移除元素，實現時也需要考慮兩種情況：1. 移除第一個元素；2. 移除其他元素（包括最後一個）。
this.removeAt = function (position) {
  // 判斷位置是否越界
  if (position > -1 && position < length) {
    var current = head,
        previous,
        index = 0

    // 如果刪除了第一個元素，把head指向下一個元素就行了
    if (position === 0) {
      head = current.next
    } else {
      // 根據輸入的位置查詢要刪除的元素
      while (index++ < position) {
        previous = current
        current = current.next
      }
      // 將上一個元素的next指向current的下一項，跳過current，實現移除current
      previous.next = current.next
    }

    // 更新列表長度
    length--

    // 返回刪除的元素
    return current.element
  } else {
    return null
  }
}
實現insert
與removeAt類似的實現，大家可以先不看原始碼，自己按著removeAt的思路實現一遍。
this.insert = function (position, element) {
  // 檢查位置是否越界
  if (position >= 0 && position <= length) {
    var node = new Node(element),
        index = 0,
        previous,
        current = head

    // 在第一個位置新增
    if (position === 0) {

      node.next = current
      head = node

    } else {
      while (index++ < position) {
        previous = current
        current = current.next
      }

      node.next = current
      previous.next = node
    }

    // 更新列表長度
    length++

    return true
} else {
  return false
}
}
實現 indexOf
根據元素查詢在連結串列中的位置，沒找到就返回-1。
this.indexOf = function (element) {
  var current = head,
      index = 0

  while (current) {
    if (element === current.element) {
      return index
    }
    index++
    current = current.next
  }

  return -1
}
實現其他方法
// 返回所有元素的值轉成字串
this.toString = function () {
  var current = head,
      string = ''

  while (current) {
    string += current.element
    current = current.next
  }

  return string
}

// 移除特定元素
this.remove = function (element) {
  var index = this.indexOf(element)
  return this.removeAt(index)
}

// 判斷連結串列是否為空
this.isEmpty = function () {
  return length === 0
}

// 返回連結串列長度
this.size = function () {
  return length
}

// 返回第一個元素
this.getHead = function () {
  return head
}
雙向連結串列
雙向連結串列和單向連結串列的區別就是每一個元素是雙向的，一個元素中包含兩個引用：一個指向前一個元素；一個指向下一個元素。除此之外，雙向連結串列還有一個指向最後一個元素的tail指標，這使得雙向連結串列可以從頭尾兩個方向迭代連結串列 。
設計一個簡單的雙向連結串列 

function DoubleLinkedList () {
  var Node = function (element) {
    this.element = element
    this.prev = null // 新增了一個指向前一個元素的引用
    this.next = null
  }

  var length = 0
  var head = null
  var tail = null //新增了tail指向最後一個元素
}
append(element)：向連結串列尾部新增元素
insert(position, element)：向連結串列特定位置插入元素
removeAt(position)：從連結串列特定位置移除一項
showHead()：獲取雙向連結串列的頭部
showLength()：獲取雙向連結串列長度
showTail()：獲取雙向連結串列尾部
實現append
和單向連結串列的一樣，只不過多了tail有一些不同 。
this.append = function (element) {
  var node = new Node(element),
      current = tail

  if (head === null) {
    head = node
    tail = node
  } else {
    node.prev = current
    current.next = node
    tail = node
  }

  length++
}
實現 insert
同單向連結串列類似，只不過情況更復雜了，你不僅需要額外考慮在第一個元素的位置插入新元素，還要考慮在最後一個元素之後插入新元素的情況。
此外如果在第一個元素插入時，連結串列為空的情況也需要考慮。
this.insert = function (position, element) {
  // 檢查是否越界
  if (position >= 0 && position <= length) {
    var node = new Node(element),
        current = head,
        previous,
        index = 0

    if (position === 0) { // 第一個元素的位置插入
      // 如果連結串列為空
      if (!head) {
        head = node
        tail = node
      } else {
        node.next = current
        current.prev = node
        head = node
      }
    } else if (position === length) { // 在最後一個元素之後插入
      current = tail
      node.prev = current
      current.next = node
      tail = node
    } else { // 在中間插入
      while (index++ < position) {
        previous = current
        current = current.next
      }

      node.next = current
      previous.next = node

      current.prev = node
      node.prev = previous
    }

    length++

    return true
  } else {
    return false
  }
}
實現 removeAt
this.removeAt = function (position) {
  // 檢查是否越界
  if (position > -1 && position < length) {
    var current = head,
        previous,
        index = 0

    if (position === 0) { // 第一個元素
      head = current.next
      // 如果只有一個元素
      if (length === 1) {
        tail = null
      } else {
        head.prev = null
      }
    } else if (position === length - 1) { // 最後一個元素
      current = tail
      tail = current.prev
      tail.next = null
    } else {
      while (index++ < position) {
        previous = current
        current = current.next
      }

      previous.next = current.next
      current.next.prev = previous
    }

    length--

    return current.element
  } else {
    return null
  }
}
資料結構  線性結構-集合
專案中我們會經常的跟集合打交道, 如果有兩個陣列，你還每一次都迴圈的程式碼來判斷是否重複 。。 那麼只能說 你的程式碼有點跟不上時代的節奏了。
集合中包括：並集，交集，差集
let set1 = new Set([1,2,3]);
let set2 = new Set([2,3,4]);

並集
let union = new Set([...set1, ...set2]);

交集
let intersect = new Set([...set1].filter( x => set2.has(x)));

差集
let difference = new Set([...set1].filter(x => !set2.has(x)));
面試題: 如何高效的處理兩個陣列中獲取陣列中相同項。
資料結構 -非線性結構 -二叉樹
樹是一種非線性的資料結構 。而二叉樹是一個特殊的資料結構，它每個節點的子節點不允許超過兩個。3種遍歷二叉樹的方式有：中序，先序，後序 。
二叉樹的原理：
  1. 第一次訪問的時候 設根節點為當前節點
  2. 如果插入的值小於當前節點， 設定該插入節點為原節點的左節點 ，反之 執行第4部
  3. 如果當前節點的左節點為null ，就將新的節點插入這個位置，退出迴圈 反之 繼續執行下一次迴圈
  4. 設新的當前節點為原節點的右節點
  5. 如果當前節點的右節點為null 就將新的節點插入這個位置，退出迴圈 反之繼續執行下一次迴圈
二叉樹是由節點組成的，所以我們需要定義一個物件node，可以儲存資料，也可以儲存其他節點的連結(left 和 right)，show()方法用來顯示儲存在節點中的資料。Node程式碼如下：
function Node(data,left,right) {
    this.data = data;
    this.left = left;
    this.right = right;
    this.show = show;
}
function BST() {
    this.root = null;
    this.insert = insert;
    this.inOrder = inOrder;
}
function insert(data) {
    var n = new Node(data,null,null);
    if(this.root == null) {
        this.root = n;
    }else {
        var current = this.root;
        var parent;
        while(current) {
            parent = current;
            if(data <  current.data) {
                current = current.left;
                if(current == null) {
                    parent.left = n;
                    break;
                }
            }else {
                current = current.right;
                if(current == null) {
                    parent.right = n;
                    break;
                }
            }
        }
    }
}
//初始程式碼如下：
var nums = new BST();
nums.insert(23);
nums.insert(45);
nums.insert(16);
nums.insert(37);
nums.insert(3);
nums.insert(99);
nums.insert(22)
遍歷二叉查詢樹。更多詳細內容請跳轉(https://www.cnblogs.com/tugenhua0707/p/4361051.htm)。
高階演算法
基礎演算法(冒泡，插入, 選擇) 就不浪費大家時間了。高階排序演算法是處理大型資料集的最高效排序演算法（遞迴執行效率底下），它是處理的資料集可以達到上百萬個元素，而不僅僅是幾百個或者幾千個。
高階排序演算法 -希爾排序
希爾排序的核心理念是：首先比較距離較遠的元素，而非相鄰的元素。
基本原理：通過定義一個間隔序列來表示在排序過程中進行比較的元素之間有多遠的間隔。 對於大部門實際應用場景，演算法要到的間隔序列可以提前定義好，有一些公開定義的間隔序列是 701，301，132，57，23，10，4，1。
var ary = [0,91,11,83,72,61,12,3,35,44] 已知一個陣列
間隔3時候 排序結果 0 83 12 44  對這個陣列進行排序結果0 12 44 83
間隔3的時候 排序結果 91 72 3  對這個陣列進行排序結果 3 72 91
間隔3的時候 排序結果 11 61 35 結果是 11 35 61
執行以上結果就是 [0,3,11,12,72,35,44,91,61,83]
間隔2的時候  結果排序 0 11 72 44 61   對這個陣列進行排序結果 0 11 44 61 72
間隔2的時候  結果排序 3 12 35 91 83  結果3 12 35 83 91
執行以上結果就是 [0,3,11,12,44,35,61,91,72,83]
間隔1的時候  結果排序 0 3 11 12 35 44 61 73 83 91
function CArray(numElements,gaps) {
    this.dataStore = [];
    this.pos = 0;
    this.numElements = numElements;
    this.gaps = gaps;  //間隔序列
    this.insert = insert;
    this.shellSort = shellSort;
    for(var i = 0; i < numElements.length; i++) {
        this.dataStore[i] = numElements[i];
    }            
}

function shellSort() {
    for(var g = 0; g < this.gaps.length; ++g) {
        for(var i = this.gaps[g]; i < this.dataStore.length; ++i) {
            var temp = this.dataStore[i];
            for(var j = i; j >= this.gaps[g] && this.dataStore[j - this.gaps[g]] > temp; j -= this.gaps[g]) {
                this.dataStore[j] = this.dataStore[j - this.gaps[g]];
            }
            this.dataStore[j] = temp;
        }
    }
}
// 希爾排序測試程式碼
var numElements = [0,91,11,83,72,61,12,3,35,44];
var gaps = [3,2,1];
var myNums = new CArray(numElements,gaps);
myNums.shellSort();
console.log(myNums.toString());
高階排序演算法 -快速排序
快速排序是處理大資料最快的排序演算法之一，通過遞迴的方式將資料一次分解成包含大小原色的不同子序列 通過不斷重複這個步驟來獲取資料。
// 快速排序
function qSort(list) {
    if(list.length == 0) {
        return [];
    }
    // 儲存小於基準值的值
    var left = [];
    // 儲存大於基準值的值
    var right = [];
    var pivot = list[0];
    for(var i = 1; i < list.length; i++) {
        if(list[i] < pivot) {
            left.push(list[i]);
        }else {
            right.push(list[i])
        }
    }
    return qSort(left).concat(pivot,qSort(right));
}

var numElements = [44,75,23,43,55,12,64,77,33];
var list = qSort(numElements);
console.log(list);  // [12, 23, 33, 43, 44, 55, 64, 75, 77
高階演算法 —動態規則
動態規則有時被認為是一種與遞迴相反的技術，遞迴是從頂部開始將問題解決，通過解決掉所有分析出的小問題方式，來解決問題 。 
而動態規則的解決方式 正好相反 先解決小的問題 然後解決大的問題。
斐波那契數列指的是這樣一個數列

0 1 1 2 3 5 8 13 21 34 55 

可以看出序列的前兩項數值相加而成的
1. 遞迴方式
 function result (n) {

         if (n < 2) {

                 reutrn n 
         } 
         else {
            return result(n-1) + result(n-2) 

         }

  }

  這個函式執行效率比較低
2. 動態規則方法
  function result (n) {
      let val = [];
        for(let i = 0; i <= n; ++i){
            val[i]=0;
        }
        if(n ===1 || n  === 2){
            return 1;
        }
        else {
            val[1] =1;
            val[2] = 2;
            for(let i = 3; i <= n; ++i){
                val[i] = val  [i-1] +val[i-2] ;
            }
        }
        return val[n-1]
   }
通過陣列 val 中儲存了中間結果， 如果要計算的斐波那契數是 1 或者 2， 那麼 if 語句會返回 1。 否則，數值 1 和 2 將被儲存在 val 陣列中 1 和 2 的位置。
迴圈將會從 3 到輸入的引數之間進行遍歷， 將陣列的每個元素賦值為前兩個元素之和， 迴圈結束， 陣列的最後一個元素值即為最終計算得到的斐波那契數值， 這個數值也將作為函式的返回值。
高階演算法 - 貪心演算法
貪心演算法的基本思路：
  1. 建立數學模型來描述問題。
  2. 把求解的問題分成若干個子問題。
  3. 對每一子問題求解，得到子問題的區域性最優解。
  4. 把子問題的解區域性最優解合成原來解問題的一個解
貪心演算法適用的問題：尋找最優解的過程，目的是得到當前最優解、可惜的是，它需要證明後才能真正運用到題目的演算法中。
部分揹包問題：固定容積的揹包能放入物品的總最大價值

物品 A B C D 
價格 50 220 60 60 
尺寸 5 20 10 12 
比率 10 11 6 5
//按比例降序儘可能多放入物品 

function greedy(values, weights, capacity){
    var returnValue = 0
    var remainCapacity = capacity
    var sortArray = []
    values.map((cur, index) =>{
        sortArray.push({
            'value': values[index],
            'weight': weights[index],
            'ratio': values[index]/weights[index]
        })
    })
    sortArray.sort(function(a, b){
        return b.ratio > a.ratio
    })
    console.log(sortArray)
    sortArray.map((cur,index) => {
        var num = parseInt(remainCapacity/cur.weight)
        console.log(num)
        remainCapacity -= num*cur.weight
        returnValue += num*cur.value
    })
    return returnValue
}
var items = ['A','B','C','D']
var values = [50,220,60,60]
var weights = [5,20,10,12]
var capacity = 32 //揹包容積

greedy(values, weights, capacity) // 320

近期熱文
《TensorFlow 計算與智慧基礎》
《突破技術發展瓶頸、成功轉型的重要因素》
《Selenium 爬取評論資料，就是這麼簡單！》
《這種稀缺的測試人，好多公司都搶著要》
《Node 企業專案大規模實踐》

GitChat 與 CSDN 聯合推出
《GitChat 達人課：AI 工程師職業指南》
「閱讀原文」看交流實錄，你想知道的都在這裡
            




相關文章