JavaScript數據結構04 - 鏈表

時間 2019-11-06

原文原文鏈接

1、定義

1.1 概念

前面咱們學習了數組這種數據結構。數組（或者也能夠稱爲列表）是一種很是簡單的存儲數據序列的數據結構。在這一節，咱們要學習如何實現和使用鏈表這種動態的數據結構，這意味着咱們能夠從中任意添加或移除項，它會按需進行擴容。node

要存儲多個元素，數組（或列表）多是最經常使用的數據結構，它提供了一個便利的[]語法來訪問它的元素。然而，這種數據結構有一個缺點：（在大多數強類型語言中）數組的大小是固定的，須要預先分配，從數組的起點或中間插入或移除項的成本很高，由於須要移動元素。
（注意：在JavaScript中數組的大小隨時可變，不須要預先定義長度）git

鏈表存儲有序的元素集合，但不一樣於數組，鏈表中的元素在內存中並非連續放置的。每一個元素由一個存儲元素自己的節點和一個指向下一個元素的引用（也稱指針或連接）組成。github

相對於傳統的數組，鏈表的一個好處在於，添加或刪除元素的時候不須要移動其餘元素。然而，鏈表須要使用指針，所以實現鏈表時須要額外注意。數組的另外一個細節是能夠直接訪問任何位置的元素，而想要訪問鏈表中間的一個元素，須要從起點（表頭）開始迭代列表直到找到所需的元素。segmentfault

火車能夠當作生活中一個典型的鏈表的例子。一列火車是由一系列車箱組成的。每節車箱都相互鏈接。你很容易分離一節車箱，改變它的位置，添加或移除它。數組

1.2 分類

鏈表最經常使用的有三類：微信

單向鏈表
雙向鏈表
循環鏈表

2、鏈表的實現

2.1 單向鏈表

建立單向鏈表類：數據結構

// SinglyLinkedList
function SinglyLinkedList () {
  function Node (element) {
    this.element = element;
    this.next = null;
  }

  var length = 0;
  var head = null;
  
  this.append = function (element) {};
  this.insert = function (position, element) {};
  this.removeAt = function (position) {};
  this.remove = function (element) {};
  this.indexOf = function (element) {};
  this.isEmpty = function () {};
  this.size = function () {};
  this.getHead = function () {};
  this.toString = function () {};
  this.print = function () {};
}

SinglyLinkedList須要一個輔助類Node。Node類表示要加入鏈表的項。它包含一個element屬性，即要添加到鏈表的值，以及一個next屬性，即指向鏈表中下一個節點項的指針。app

鏈表裏面有一些聲明的輔助方法：學習

append(element)：向鏈表尾部添加新項
insert(position, element)：向鏈表的特定位置插入一個新的項
removeAt(position)：從鏈表的特定位置移除一項
remove(element)：從鏈表中移除一項
indexOf(element)：返回元素在鏈表中的索引。若是鏈表中沒有該元素則返回-1
isEmpty()：若是鏈表中不包含任何元素，返回true，若是鏈表長度大於0，返回false
size()：返回鏈表包含的元素個數，與數組的length屬性相似
getHead()：返回鏈表的第一個元素
toString()：因爲鏈表使用了Node類，就須要重寫繼承自JavaScript對象默認的toString()方法，讓其只輸出元素的值
print()：打印鏈表的全部元素

下面咱們來一一實現這些輔助方法：測試

// 向鏈表尾部添加一個新的項
  this.append = function (element) {
    var node = new Node(element);
    var currentNode = head;

    // 判斷是否爲空鏈表
    if (currentNode === null) {
      // 空鏈表
      head = node;
    } else {
      // 從head開始一直找到最後一個node
      while (currentNode.next) {
        // 後面還有node
        currentNode = currentNode.next;
      }
      currentNode.next = node;
    }

    length++;
  };

  // 向鏈表特定位置插入一個新的項
  this.insert = function (position, element) {
    if (position < 0 && position > length) {
      // 越界
      return false;
    } else {
      var node = new Node(element);
      var index = 0;
      var currentNode = head;
      var previousNode;

      if (position === 0) {
        node.next = currentNode;
        head = node;
      } else {
        while (index < position) {
          index++;
          previousNode = currentNode;
          currentNode = currentNode.next; 
        }
  
        previousNode.next = node;
        node.next = currentNode;
      }

      length++;

      return true;
    }
  };

  // 從鏈表的特定位置移除一項
  this.removeAt = function (position) {
    if (position < 0 && position >= length || length === 0) {
      // 越界
      return false;
    } else {
      var currentNode = head;
      var index = 0;
      var previousNode;

      if (position === 0) {
        head = currentNode.next;
      } else {
        while (index < position) {
          index++;
          previousNode = currentNode;
          currentNode = currentNode.next;
        }
        previousNode.next = currentNode.next;
      }

      length--;

      return true;
    }
  };

  // 從鏈表的特定位置移除一項
  this.removeAt = function (position) {
    if (position < 0 && position >= length || length === 0) {
      // 越界
      return false;
    } else {
      var currentNode = head;
      var index = 0;
      var previousNode;

      if (position === 0) {
        head = currentNode.next;
      } else {
        while (index < position) {
          index++;
          previousNode = currentNode;
          currentNode = currentNode.next;
        }
        previousNode.next = currentNode.next;
      }

      length--;

      return true;
    }
  };

  // 從鏈表中移除指定項
  this.remove = function (element) {
    var index = this.indexOf(element);
    return this.removeAt(index);
  };

  // 返回元素在鏈表的索引，若是鏈表中沒有該元素則返回-1
  this.indexOf = function (element) {
    var currentNode = head;
    var index = 0;

    while (currentNode) {
      if (currentNode.element === element) {
        return index;
      }

      index++;
      currentNode = currentNode.next;
    }

    return -1;
  };

  // 若是鏈表中不包含任何元素，返回true，若是鏈表長度大於0，返回false
  this.isEmpty = function () {
    return length == 0;
  };

  // 返回鏈表包含的元素個數，與數組的length屬性相似
  this.size = function () {
    return length;
  };

  // 獲取鏈表頭部元素
  this.getHead = function () {
    return head.element;
  };

  // 因爲鏈表使用了Node類，就須要重寫繼承自JavaScript對象默認的toString()方法，讓其只輸出元素的值
  this.toString = function () {
    var currentNode = head;
    var string = '';

    while (currentNode) {
      string += ',' + currentNode.element;
      currentNode = currentNode.next;
    }

    return string.slice(1);
  };

  this.print = function () {
    console.log(this.toString());
  };

建立單向鏈表實例進行測試：

// 建立單向鏈表實例
var singlyLinked = new SinglyLinkedList();
console.log(singlyLinked.removeAt(0));              // true
console.log(singlyLinked.isEmpty());              // true
singlyLinked.append('Tom');                       
singlyLinked.append('Peter');
singlyLinked.append('Paul');
singlyLinked.print();                             // "Tom,Peter,Paul"
singlyLinked.insert(0, 'Susan');                  
singlyLinked.print();                             // "Susan,Tom,Peter,Paul"
singlyLinked.insert(1, 'Jack');                   
singlyLinked.print();                             // "Susan,Jack,Tom,Peter,Paul"
console.log(singlyLinked.getHead());              // "Susan"
console.log(singlyLinked.isEmpty());              // false
console.log(singlyLinked.indexOf('Peter'));       // 3
console.log(singlyLinked.indexOf('Cris'));        // -1
singlyLinked.remove('Tom');                       
singlyLinked.removeAt(2);                         
singlyLinked.print();                             // "Susan,Jack,Paul"

2.2 雙向鏈表

雙向鏈表和普通鏈表的區別在於，在普通鏈表中，一個節點只有鏈向下一個節點的連接，而在雙向鏈表中，連接是雙向的：一個鏈向下一個元素，另外一個鏈向前一個元素。

建立雙向鏈表類：

// 建立雙向鏈表DoublyLinkedList類
function DoublyLinkedList () {
  function Node (element) {
    this.element = element;
    this.next = null;
    this.prev = null;        // 新增
  }

  var length = 0;
  var head = null;
  var tail = null;          // 新增
}

能夠看到，雙向鏈表在Node類裏有prev屬性（一個新指針），在DoublyLinkedList類裏也有用來保存對列表最後一項的引用的tail屬性。

雙向鏈表提供了兩種迭代列表的方法：從頭至尾，或者從尾到頭。咱們能夠訪問一個特定節點的下一個或前一個元素。

在單向鏈表中，若是迭代鏈表時錯過了要找的元素，就須要回到鏈表起點，從新開始迭代。在雙向鏈表中，能夠從任一節點，向前或向後迭代，這是雙向鏈表的一個優勢。

實現雙向鏈表的輔助方法：

// 向鏈表尾部添加一個新的項
  this.append = function (element) {
    var node = new Node(element);
    var currentNode = tail;

    // 判斷是否爲空鏈表
    if (currentNode === null) {
      // 空鏈表
      head = node;
      tail = node;
    } else {
      currentNode.next = node;
      node.prev = currentNode;
      tail = node; 
    }

    length++;
  };

  // 向鏈表特定位置插入一個新的項
  this.insert = function (position, element) {
    if (position < 0 && position > length) {
      // 越界
      return false;
    } else {
      var node = new Node(element);
      var index = 0;
      var currentNode = head;
      var previousNode;

      if (position === 0) {
        if (!head) {
          head = node;
          tail = node;
        } else {
          node.next = currentNode;
          currentNode.prev = node;
          head = node;
        }
      } else if (position === length) {
        this.append(element);
      } else {
        while (index < position) {
          index++;
          previousNode = currentNode;
          currentNode = currentNode.next; 
        }
  
        previousNode.next = node;
        node.next = currentNode;

        node.prev = previousNode;
        currentNode.prev = node;
      }

      length++;

      return true;
    }
  };

  // 從鏈表的特定位置移除一項
  this.removeAt = function (position) {
    if (position < 0 && position >= length || length === 0) {
      // 越界
      return false;
    } else {
      var currentNode = head;
      var index = 0;
      var previousNode;

      if (position === 0) {
        // 移除第一項
        if (length === 1) {
          head = null;
          tail = null;
        } else {
          head = currentNode.next;
          head.prev = null;
        }
      } else if (position === length - 1) {
        // 移除最後一項
        if (length === 1) {
          head = null;
          tail = null;
        } else {
          currentNode = tail;
          tail = currentNode.prev;
          tail.next = null;
        }
      } else {
        while (index < position) {
          index++;
          previousNode = currentNode;
          currentNode = currentNode.next;
        }
        previousNode.next = currentNode.next;
        previousNode = currentNode.next.prev;
      }

      length--;

      return true;
    }
  };

  // 從鏈表中移除指定項
  this.remove = function (element) {
    var index = this.indexOf(element);
    return this.removeAt(index);
  };

  // 返回元素在鏈表的索引，若是鏈表中沒有該元素則返回-1
  this.indexOf = function (element) {
    var currentNode = head;
    var index = 0;

    while (currentNode) {
      if (currentNode.element === element) {
        return index;
      }

      index++;
      currentNode = currentNode.next;
    }

    return -1;
  };

  // 若是鏈表中不包含任何元素，返回true，若是鏈表長度大於0，返回false
  this.isEmpty = function () {
    return length == 0;
  };

  // 返回鏈表包含的元素個數，與數組的length屬性相似
  this.size = function () {
    return length;
  };

  // 獲取鏈表頭部元素
  this.getHead = function () {
    return head.element;
  };

  // 因爲鏈表使用了Node類，就須要重寫繼承自JavaScript對象默認的toString()方法，讓其只輸出元素的值
  this.toString = function () {
    var currentNode = head;
    var string = '';

    while (currentNode) {
      
      string += ',' + currentNode.element;
      currentNode = currentNode.next;
    }

    return string.slice(1);    
  };

  this.print = function () {
    console.log(this.toString());
  };

建立雙向鏈表實例進行測試：

// 建立雙向鏈表
var doublyLinked = new DoublyLinkedList();
console.log(doublyLinked.isEmpty());              // true
doublyLinked.append('Tom');                       
doublyLinked.append('Peter');
doublyLinked.append('Paul');
doublyLinked.print();                             // "Tom,Peter,Paul"
doublyLinked.insert(0, 'Susan');                  
doublyLinked.print();                             // "Susan,Tom,Peter,Paul"
doublyLinked.insert(1, 'Jack');                   
doublyLinked.print();                             // "Susan,Jack,Tom,Peter,Paul"
console.log(doublyLinked.getHead());              // "Susan"
console.log(doublyLinked.isEmpty());              // false
console.log(doublyLinked.indexOf('Peter'));       // 3
console.log(doublyLinked.indexOf('Cris'));        // -1
doublyLinked.remove('Tom');                       
doublyLinked.removeAt(2);                         
doublyLinked.print();                             // "Susan,Jack,Paul"