使用js編寫基礎的數據結構

時間 2020-06-09

原文原文鏈接

做爲一條鹹魚，大學的數據結構這門課確定沒咋上，能逃課就逃課了，這就形成很尷尬的局面----我數據結構很垃圾。雖然從事前端初級工程師不咋用獲得這個東西，可是它就是一個底子，就是基礎，不學不行啊，因此工做之餘把我用js學習寫的這些東西發上來保存一下以防丟失。前端

1、棧node

首先，第一個學的數據結構確定是棧，由於是最好理解，也最容易學習的。算法

棧，又稱堆棧，是一種運算受限的線性表。其限制是僅容許在表的一端進行插入和刪除運算，這一端被稱爲棧頂，相對地，把另外一端稱爲棧底。向一個棧插入新元素又稱做進棧、入棧或壓棧，它是把新元素放到棧頂元素的上面，使之成爲新的棧頂元素；從一個棧刪除元素又稱做出棧或退棧，它是把棧頂元素刪除掉，使其相鄰的元素成爲新的棧頂元素。(來自百度百科)後端

形象點說，就是拿了一個口徑跟硬幣同樣大的量筒，入棧就是把一個硬幣放進去，最早放進去的那個硬幣就在量筒的最低端，取不出來，最後放進去的硬幣就在量筒的最上端，能取出來。出棧就是把最上面的那個硬幣取出來。在這個量筒中只能這麼執行，不能出現其餘騷操做（好比把量筒砸了），可是你能夠經過透明的量筒壁來數一數到底量筒中放入了幾個硬幣。數組

首先咱們先定義一個 Stack 類：數據結構

class Stack{
  constructor(){
    this.items = []
  }
}

咱們使用一個js中的數組做爲載體（量筒），對其進行限制模擬一個棧。app

入棧操做：函數

add(node){
  this.items.push(node)
}

由於只能在最後面進行添加和取出，因此咱們添加元素直接添加在最後面。學習

出棧操做：this

pop(){
  this.items.pop()
}

同理，將數組的最後一位刪除，這樣就模擬了棧的出棧入棧，限制了數組的刪除和添加只能在最後一位進行操做。

那麼想知道量筒最上面那個硬幣長什麼樣子呢？咱們只須要獲取到這個數組，也就是棧的最後入棧的那個元素就行。

get peek(){
  return this.items[this.items.length-1]
}

還有判斷一個棧是否爲空，則只須要判斷這個數組的長度是否爲0：

get isEmpty(){
  return this.items.length === 0
}

若是想知道這個棧裏面有多少元素呢：

get size(){
  return this.items.length
}

再若是不須要這個棧裏面的數據的話呢，就清除了吧：

clear(){
  this.items = []
}

最後能夠將棧內的全部元素依次打印出來：

print(){
  console.log(this.items.toString())  
}

將上面代碼整理一下，一個用js實現的棧類就出來了：

class Stack {
  constructor() {
    this.items = []
  }
  // 添加
  add(node) {
    this.items.push(node)
  }
  // 出棧
  pop() {
    this.items.pop()
  }
  // 末位
  get peek() {
    return this.items[this.items.length - 1]
  }
  // 是否爲空棧
  get isEmpty() {
    return this.items.length === 0
  }
  // 獲取尺寸
  get size() {
    return this.items.length
  }
  // 清空棧
  clear() {
    this.items = []
  }
  // 打印棧內內容
  print() {
    console.log(this.items.toString())
  }
}

ok，用js實現一個棧數據結構已經完成，就這麼輕鬆，接着學習稍微有點難度的鏈表。

2、鏈表

鏈表是一種物理存儲單元上非連續、非順序的存儲結構，數據元素的邏輯順序是經過鏈表中的指針連接次序實現的。鏈表由一系列結點（鏈表中每個元素稱爲結點）組成，結點能夠在運行時動態生成。每一個結點包括兩個部分：一個是存儲數據元素的數據域，另外一個是存儲下一個結點地址的指針域。

說通俗一點，就是跟火車同樣，每一列車箱都有本身的空間用來坐人，這就是數據域，也有一個鉸接去跟下一節車箱進行鏈接，這就是指針域，用來綁定下一個車箱的。

在這裏開始以前，咱們先建立一個節點類Node：

class Node{
  contructor(element){
    this.element = element
    this.next = null
  }  
}

這裏的 element 就是設計的數據域，這裏的 next 就是設計的指針域，用來指定下一個節點是哪個。

ok，開始，建立一個鏈表類:

class LinkedList{
  constructor(){
    this.head = null
    this.length = 0
  }
}

由於鏈表是一個有序的數據結構，咱們用 head 標示其第一個節點，length 表示鏈表的長度。

第一個要實現的功能確定是添加元素到鏈表的最後面：

addEnd(ele){
  const node = new Node(ele)
  let current = null
  if(this.head === null){    // 若是鏈表爲空，直接把須要添加的節點放在head
    this.head = node
  }  
  else{
    current = this.head
    while(current.next){    //  在這裏尋找鏈表的最後一個節點
      current = current.next
    }
    current.next = node
  }
  this.length ++
}

對於初學者來講，這個插入可能有點抽象，我畫個圖。

在上面這個圖中，將鏈表的形象畫一下，大概就是這樣，指針域就是next，指向下一個節點，數據域就是 element，存儲數據用。因此在鏈表的最後面添加一個節點的時候，只須要將鏈表目前最後面的節點的next指向須要添加的節點就ok了。

可是不可能每一次都把節點添加到鏈表的最後面，因此確定得有一個插入操做，傳入一個參數表示要插入的位置：

insert(ele,position){
  const node = new Node(ele)
  let current = this.head, previous = null, index = 0

  if(position>=0 && position < this.length){ // 由於插入位置必須小於鏈表的長度而且不小於0
     if(position === 0){  // 直接插入頭部
       node.next = current
       this.head = node
     }
     else{
       while(index++ < position){  // 從0開始找，找到須要插入的位置
         previous = current
         current = current.next
       }
       previous.next = node
       node.next = current
     }
     this.length ++
     return true
  }
  console.log('請輸入正確的位置')  
  return false
}

在鏈表的插入中，若是要將一個節點插入兩個節點（A和B）之間，只須要將前面的節點A的next指向須要添加的節點，而且將須要添加的節點的next指向後面的節點B就ok了，看下圖。

在本來的鏈表中，A節點的next指向的是B節點的next。這樣子就實現了一個節點的插入。

再來寫鏈表的刪除：

removeAt(position){
  if(position>=0 && position< this.length){
    let current = this.head,previous = null, index = 0
    if(position === 0){
      this.head = this.head.next
    }  
    else{
      while(index++<position){
        previous = current
        current = current.next
      }
      previous.next = current
    }
    this.length--
    return true  
  }
  console.log('請輸入正確的位置')
  return false
}

用上面的圖來看吧，刪除是怎麼刪除的呢？須要刪除的節點的上一個節點是A，next是節點B，只須要將節點A的next指向B就ok了。

ok,這樣就刪除了，再看看代碼，是找到須要刪除的位置以後，將當前位置的節點的上一個節點的next指向該節點的next。

再接着寫根據內容查找節點所在的位置：

findIndex(ele){
  let current = this.head, index = 0
  while(current){
    if(ele === current.element) return index
    index ++ 
    current = current.next
  }
  return -1
}

這個很好理解，遍歷列表，找到對應內容的節點所在的位置。

繼續寫根據內容刪除節點：

remove(ele){
  let index = this.findIndex(ele)
  this.removeAt(index)
}

這個方法是將上面的刪除和根據位置查找兩個方法進行了一個組合封裝。

而後是判斷鏈表是否有數據：

get isEmpty(){
  return this.head === null
}

再獲取鏈表的長度：

get size(){
  return this.length
}

最後是打印鏈表內容：

print(){
  let current = this.head
  if(this.length === 0){
    console.log('鏈表爲空')
  }
  while(current.next){
    console.log(current.element)
    current = current.next  
  }
}

將上面的代碼整理一下，一個鏈表類就出來了：

class LinkedList {
    constructor() {
        this.head = null
        this.length = 0
    }

    // 添加
    addEnd(ele) {
        const node = new Node(ele)
        let current = null
        if (this.head === null) {
            this.head = node
            this.length++
        } else {
            current = this.head
            while (current.next) {
                current = current.next
            }
            current.next = node
            this.length++
        }
    }

    // 插入
    insert(ele, position) {
        if (position >= 0 && position < this.length) {
            const node = new Node(ele)
            let current = this.head, previous = null, index = 0
            if (position === 0) {
                this.head = node
                node.next = current
            } else {
                while (index++ < position) {
                    previous = current
                    current = current.next
                }
                previous.next = node
                node.next = current
            }
            this.length++
            return true
        }
        return false
    }

    // 根據位置刪除
    removeAt(position) {
        if (position > -1 && position < this.length) {
            let current = this.head, previous = null, index = 0
            if (position == 0) {
                this.head = current.next
            } else {
                while (index++ < position) {
                    previous = current
                    current = current.next
                }
                previous.next = current.next
            }
            this.length--
            return current.element
        }
        return null
    }

    // 根據內容查找位置
    findIndex(ele) {
        let current = this.head, index = 0
        while (current) {
            if (ele === current.element) {
                return index + 1
            }
            index++
            current = current.next
        }
        return -1
    }

    // 根據內容刪除
    remove(ele) {
        let index = this.findIndex(ele)
        this.removeAt(index)
    }

    // 是否爲空
    isEmpty() {
        return this.head === null
    }

    // 長度
    size() {
        return this.length
    }

    // 打印鏈表內容

　　print(){
  　　let current = this.head 　　if(this.length === 0){ 　　console.log('鏈表爲空') 　　} 　　while(current.next){ 　　console.log(current.element) 　　current = current.next 　　 } 　　}

ok，一個完整的鏈表類出來了，比起棧，鏈表稍微複雜了一點，畢竟跟指針有關。c語言中的指針能夠形象的表現出來，在js中，指針已經被封裝在最底層了，因此咱們只能使用一個next屬性模擬指針。

鏈表相比數組最重要的優勢，那就是無需移動鏈表中的元素，就能輕鬆地添加和移除元素。所以，當你須要添加和移除不少元素時，最好的選擇就是鏈表，而非數組。

3、雙向鏈表

上面寫的鏈表是單向的，只能從一個節點尋找到它的下一個節點，而雙向鏈表則可讓一個節點找到它的上一個節點和下一個節點。

開始，先寫一個Node類：

class Node{
  constructor(element){
    this.element = element
    this.last = null
    this.next = null
  }  
}

相比於單向鏈表的節點，咱們添加一個屬性：last，用來指向它的上一個節點。

建立一個雙向鏈表類：

class DoubleLinkedList{
  constructor(){
    this.head = null
    this.tail = null
    this.length = 0
  }
}

在鏈表類的實例屬性中，咱們添加一個屬性：tail，表示雙向鏈表的最後一個節點。

好了，開始寫添加一個節點到鏈表的最末端：

addEnd(ele){
  const node = new Node(ele)
  let current = null

  if(this.head === null){
    this.head = node
  }
  else if(this.tail === null ){
    this.tail = node
    this.tail.last = this.head
    this.head.next = this.tail
  }
  else{
    current = this.tail
    node.last = current
    current.next = node
    this.tail = node
  }
  this.length++
  return
}

和單向鏈表不一樣的是，雙向鏈表往最後面添加的時候是直接使用 this.tail 進行操做，不須要像單項列表那樣一個一個找，知道找到最後一個。

接着寫插入：

insert(ele, position){
  if(position>=0 && position<this.length){
    const node = new Node(ele)
    let current = this.head, previous = null, index = 0
    if(position === 0){
      this.head = node
      node.next = current
      current.last = node
    }
    else if(position === this.length - 1){
      current = this.tail
      node.last = current
      current.next = node
      this.tail = node
    }
    else{
      while(index++ < position){
        previous = current
        current = current.next
      }
      previous.next = node
      node.last = previous
      node.next = current
      current.last = node
    }
    this.length++
    return true
  }
  return false
}

跟單項列表同樣，只是在插入的過程當中多了一個last的指向操做。

接着是根據位置參數進行刪除：

removeAt(position){
  if(position >= 0 && position < this.length){
    let current = this.head, previous = null, index = 0
    if(position === 0) {
      this.head = current.next
      this.head.last = null
    }
    else if(position === this.length - 1){
      this.tail = this.tail.last
      this.tail.next = null
    }
    else{
      while(index++ < position){
        previous = current
        current = current.next
      }
      previous.next = current
      current.last = previous
    }
    this.length--
    return true
  }
  return false
}

其餘的操做都跟單向鏈表同樣了，整理一下上面的代碼：

class DoubleLinkedList{ 
　　constructor() { 
　　　　this.head = null 
　　　　this.tail = null 
　　　　this.length = 0 
　　}

　　addEnd(ele){
  　　const node = new Node(ele) 　　let current = null 　　 if(this.head === null){ 　　 this.head = node 　　 } 　　 else if(this.tail === null ){ 　　 this.tail = node 　　 this.tail.last = this.head 　　 this.head.next = this.tail 　　 } 　　 else{ 　　 current = this.tail 　　 node.last = current 　　 current.next = node 　　 this.tail = node 　　 } 　　 this.length++ 　　 return 　　}

　　insert(ele, position){
  　　if(position>=0 && position<this.length){ 　　 const node = new Node(ele) 　　 let current = this.head, previous = null, index = 0 　　 if(position === 0){ 　　 this.head = node 　　 node.next = current 　　 current.last = node 　　 } 　　 else if(position === this.length - 1){ 　　 current = this.tail 　　 node.last = current 　　 current.next = node 　　 this.tail = node 　　 } 　　 else{ 　　 while(index++ < position){ 　　 previous = current 　　 current = current.next 　　 } 　　 previous.next = node 　　 node.last = previous 　　 node.next = current 　　 current.last = node 　　 } 　　 this.length++ 　　 return true 　　 } 　　 return false 　　}

　　removeAt(position){
 　　 if(position >= 0 && position < this.length){ 　　 let current = this.head, previous = null, index = 0 　　 if(position === 0) { 　　 this.head = current.next 　　 this.head.last = null 　　 } 　　 else if(position === this.length - 1){ 　　 this.tail = this.tail.last 　　 this.tail.next = null 　　 } 　　 else{ 　　 while(index++ < position){ 　　 previous = current 　　 current = current.next 　　 } 　　 previous.next = current 　　 current.last = previous 　　 } 　　 this.length-- 　　 return true 　　 } 　　 return false 　　}

再將單向鏈表的其餘操做方法添加進去，一個完整的雙向鏈表類也誕生啦。

4、隊列

隊列是一種特殊的線性表，特殊之處在於它只容許在表的前端（front）進行刪除操做，而在表的後端（rear）進行插入操做，和棧同樣，隊列是一種操做受限制的線性表。進行插入操做的端稱爲隊尾，進行刪除操做的端稱爲隊頭。

顧名思義，隊列就跟咱們平時的排隊進景區同樣，先來的人排在前面，後面來的人排在後面，並且前面的人也是最早離開隊列進入景區的。

開始寫代碼，先建立一個隊列類：

class Queue{
  constructor(){
    this.items = []
  }
}

跟棧同樣，咱們也有一個數組進行限制操做來模擬隊列。

首先確定是添加一個元素進入隊列，直接將元素添加在數組的最後邊：

enqueue(node) {
  this.items.push(node)
}

而後是出隊列，也就是刪除數組的第一個元素：

dequeue() {
  this.items.shift()
}

獲取下一個要出隊列的元素：

get front(){
  return this.items[0]
}

獲取整個隊列的長度：

get size(){
  return this.items.length
}

獲取隊列是否爲空：

get isEmpty(){
  return this.items.length === 0
}

清空整個隊列：

clear(){
  this.items = []
}

打印隊列全部內容：

print(){
  console.log(this.items.toString())
}

將上面的全部整理一下：

class Queue {
  constructor() {
    this.items = []
  }
  // 添加
  enqueue(node) {
    this.items.push(node)
  }
  // 出隊列
  dequeue() {
    this.items.shift()
  }
  // 取首位
  get front() {
    return this.items[0]
  }
  // 取長度
  get size() {
    return this.items.length
  }
  // 是否爲空
  get isEmpty() {
    return this.items.length === 0
  }
  // 清空
  clear() {
    this.items = []
  }
  // 打印隊列內容
  print() {
    console.log(this.items.toString())
  }
}

一個完整的隊列類出來了，隊列跟棧同樣都是受限制的數據結構，也比較好理解。

可是這樣的隊列只能知足正常需求，好比人家是vip大會員呢，人家確定不能跟一羣普通人一塊兒去排隊吧，不能從最後面插入，這樣vip特權將沒有任何意義，因此就出來一個優先隊列，接下來學習一下。

5、優先隊列

在優先隊列中，元素被賦予優先級。當訪問元素時，具備最高優先級的元素最早刪除。優先隊列具備最高級先出的行爲特徵。

直接上代碼，先建立一個優先隊列：

class PriorityQueue{
  constructor(){
    this.items = []
  }
}

優先隊列的特色就是優先，因此咱們在入隊列的時候須要多添加一個參數：優先級。優先隊列相比於普通隊列的惟一的不一樣就在於入隊列的時候有一個優先級的判斷，其餘操做都跟普通隊列操做相同。

enqueue(node, priority){
  priority = priority || 99999999999
  const queueNode = { node, priority }
  if (this.isEmpty) { // 這裏的判斷是否爲空仍是使用普通隊列的方法就ok
    this.items.push(queueNode)
  }
  else{
    // 在隊列中找到要插入的位置，優先級數越小，優先級越高
    const preIndex = this.items.findIndex(item => queueNode.priority < item.priority) 
    if(preIndex>-1){
      this.items.splice(preIndex, 0, queueNode)
    }
    else{  // preIndex爲-1的時候說明沒有找到比添加的新節點的優先級低的，直接插入最後面
      this.items.push(queueNode)
    }
  }
}

6、循環隊列

爲充分利用向量空間，克服"假溢出"現象的方法是：將向量空間想象爲一個首尾相接的圓環，並稱這種向量爲循環向量。存儲在其中的隊列稱爲循環隊列。

循環隊列相比普通隊列，修改的地方也就在於查詢某個位置的參數時的不一樣。

// 獲取真實位置
getIndex(index){
  return index % this.items.length
}

// 獲取真實數據
find(index){
  return !this.isEmpty ? this.items[this.getIndex(index)] : null
}

7、集合

集合是由一組無序且惟一（不能重複）的項組成的。

在ES6中，js已經內置了Set類型的實現，可是出於學習目的，仍是本身寫一下吧。

首先建立一個集合類：

class Set{
  constructor(){
    this.items = {}
  }
}

由於集合中的全部項不能有重複的，因此首先寫一個判斷有無重複的方法：

has(value){
  return this.items.hasOwnProperty(value)
}

開始寫添加項：

add(value){
  if(!this.has(value)){
    this.items[value] = value
    return true
  } 
  return false
}

接着寫刪除某一個項：

remove(value){
  if(this.has(value)){
    delete this.items[value]
    return true
  }
  return false
}

獲取集合的長度：

get size(){
  return Object.keys(this.items).length
}

獲取集合的值：

get values(){
  return Object.keys(this.items)
}

初中數學中咱們就學習了集合，兩個集合之間會產生並集，交集和差集，還有判斷一個集合是不是另一個集合的子集，來寫一下這四個方法。

首先寫兩個集合的並集：

union(otherSet){
  const unionSet = new Set()
  this.values().forEach(v => unionSet.add(v))
  otherSet.values().forEach(v => unionSet.add(v))
  return unionSet
}

交集：

intersection(otherSet){
  const intersectionSet = new Set()
  this.values().forEach(v => {
    if(otherSet.has(v)){
      intersection.add(v)
    }
  })
  return intersectionSet
}

差集：

difference(otherSet){
  const differenceSet = new Set()
  this.values().forEach(v => {
    if(!otherSet.has(v)) differenceSet.add(v)
  })
  return differenceSet
}

判斷是不是子集：

subset(otherSet) {
  if (this.size > otherSet.size) {
    return false
  } else {
    return !this.values.some(v => !otherSet.has(v))
  }
}

ok，集合差很少寫完了，代碼整理一下：

class Set {
  constructor() {
    this.items = {}
  }
  has(value) {
    return this.items.hasOwnProperty(value)
  }
  add(value) {
    if (!this.has(value)) {
      this.items[value] = value
      return true
    }
    return false
  }
  remove(value) {
    if (this.has(value)) {
      delete this.items[value]
      return true
    }
    return false
  }
  get size() {
    return Object.keys(this.items).length
  }
  get values() {
    return Object.keys(this.items)
  }
  // 並集
  union(otherSet) {
    const unionSet = new Set()
    this.values.forEach(v => unionSet.add(v))
    otherSet.values.forEach(v => unionSet.add(v))
    return unionSet
  }
  // 交集
  intersection(otherSet) {
    const intersectionSet = new Set()
    this.values.forEach(v => {
      if (otherSet.has(v)) {
        intersectionSet.add(v)
      }
    })
    return intersectionSet
  }
  // 差集
  difference(otherSet) {
    const differenceSet = new Set()
    this.values.forEach(v => {
      if (!otherSet.has(v)) {
        differenceSet.add(v)
      }
    })
    return differenceSet
  }
  // 子集（判斷是不是otherSet的子集）
  subset(otherSet) {
    if (this.size > otherSet.size) {
      return false
    } else {
      return !this.values.some(v => !otherSet.has(v))
    }
  }
}

其實這個類寫的是內容缺的很多，好比在建立一個Set實例的時候不能直接傳參，那麼咱們改一改constructor方法：

constructor(...params){
  this.items = {}
  if(params.length === 1 && params[0] instanceof Array){
     params[0].map(v => this.add(v))
  }
  else{ 
    params.map(v => {
      this.add(v)
    }) 
  }
}

這樣就能夠在創新一個新實例的時候傳入參數並初始化。

8、字典

字典（dictionary）是一些元素的集合。每一個元素有一個稱做key 的域，不一樣元素的key 各不相同。有關字典的操做有：插入具備給定關鍵字值的元素、在字典中尋找具備給定關鍵字值的元素、刪除具備給定關鍵字值的元素。

字典在js的實現就是Object，沒有什麼太大的區別，正常使用幾乎一致，就寫一點來模擬一下。

建立一個字典類：

class Dictionary{
  constructor(){
    this.items = {}
  }
}

首先是寫入一個數據：

set(key,value){
  this.items[key] = value
}

再是獲取一個數據：

get(key){
  return this.items[key]
}

而後是刪除一個字段：

remove(key){
  delete this.items[key]
}

獲取全部的key值：

get keys(){
  return Object.keys(this.items)
}

獲取全部的value值：

get values(){
  return Object.values(this.items)
}

整理一下所有代碼：

class Dictionary {
  constructor() {
    this.items = {}
  }
  set(key, value) {
    this.items[key] = value
  }
  get(key) {
    return this.items[key]
  }
  remove(key) {
    delete this.items[key]
  }
  get keys() {
    return Object.keys(this.items)
  }
  get values() {
    /**
     * ES7: return Object.values(this.items)
     */
    return Object.keys(this.items).reduce((arr, current, index) => {
      arr.push(this.items[current])
      return arr
    }, [])
  }
}

字典和js中的Object幾乎相同，因此沒必要要太多描述，出於學習的目的稍微模擬實現一下就行。

9、散列

把任意長度的輸入經過散列算法變換成固定長度的輸出，該輸出就是散列值。

散列算法的做用是儘量快地在數據結構中找到一個值，其也是字典類的一種散列表現方式。上面的字典類中若是須要找到一個值（get方法）是須要對字典進行遍歷查找，而散列是對每個值有一個特定的數字進行存儲，當須要查找某個值的時候直接去找其對應的數字就好了。

第一個散列類咱們使用最經常使用的「lose lose」散列函數，其是將參數中全部字母的ASCII碼進行相加。先來建立一個散列類：

class HashTable{
  constructor() {
    this.table = []
  }
}

首先依據「lose lose」散列函數來給每一個須要存儲的參數編寫一個求存儲數值的方法：

static loseloseHashCode(key){
  let hash = 0
  for (let codePoint of key) {
    hash += codePoint.charCodeAt()
  }
  return hash % 37
}

寫入數值：

put(key, value) {
  const position = HashTable.loseloseHashCode(key)this.table[position] = value
}

獲取值：

get(key) {
  return this.table[HashTable.loseloseHashCode(key)]
}

最後是刪除一個不須要的值：

remove(key) {
  this.table[HashTable.loseloseHashCode(key)] = undefined
}

ok，再整理一下代碼：

class HashTable {
  constructor() {
    this.table = []
  }
  static loseloseHashCode(key) {
    let hash = 0
    for (let codePoint of key) {
      hash += codePoint.charCodeAt()
    }
    return hash % 37
  }
  // 修改和增長元素
  put(key, value) {
    const position = HashTable.loseloseHashCode(key)this.table[position] = value
  }

  get(key) {
    return this.table[HashTable.loseloseHashCode(key)]
  }

  remove(key) {
    this.table[HashTable.loseloseHashCode(key)] = undefined
  }

}

大功告成，這樣子就完成了一個HashTable類。在HashTable類中，咱們移除一個字段不須要刪除這個位置，只須要用undefined來佔位就行，由於每個數值對應一個位置，若是刪除了這個位置，後面的全部數值都會前進一個位置，就會影響整個排列。

以前這個「lose lose」散列函數有一個問題就是，若是存儲「ab」和「ba」這兩個值呢，獲得的key值是相同的，這樣子第二個存儲的值會將第一個覆蓋，這確定不是咱們想要的，因此就有了解決這個衝突的辦法。

首先看解決這個衝突的第一個辦法：分離連接。

分離連接是將同一個位置的不一樣值根據寫入順序造成一個單向鏈表，這樣就不會發生衝突了。

這樣子的話，寫入就變成了：

put(key,value){
  const position = HashTable.loseloseHashCode(key)
  if (this.table[position] === undefined) {
    this.table[position] = new LinkedList()
  }
  this.table[position].append({ key, value })
}

而後是獲取：

get(key) {
  const position = HashTable.loseloseHashCode(key)
  if (this.table[position] === undefined) return undefined
  const getElementValue = node => {
    if (!node && !node.element) return undefined
    if (Object.is(node.element.key, key)) {
      return node.element.value
    } else {
      return getElementValue(node.next)
    }
  }
  return getElementValue(this.table[position].head)
}

移出：

remove(key) {
  const position = HashTable.loseloseHashCode(key)
  if (this.table[position] === undefined) return undefined

  const getElementValue = node => {
    if (!node && !node.element) return false
    if (Object.is(node.element.key, key)) {
      this.table[position].remove(node.element)
      if (this.table[position].isEmpty) {
        this.table[position] = undefined
      }
      return true
    } else {
      return getElementValue(node.next)
    }
  }

  return getElementValue(this.table[position].head)
}

這樣子就完成了一個分離連接的散列類，整理一下代碼：

class HashTable {
  constructor() {
    this.table = []
  }
  static loseloseHashCode(key) {
    let hash = 0
    for (let codePoint of key) {
      hash += codePoint.charCodeAt()
    }
    return hash % 37
  }
  // 修改和增長元素
  put(key, value) {
    const position = HashTable.loseloseHashCode(key)
    if (this.table[position] === undefined) {
      this.table[position] = new LinkedList()
    }
    this.table[position].append({ key, value })
  }

  get(key) {
    const position = HashTable.loseloseHashCode(key)
    if (this.table[position] === undefined) return undefined
    const getElementValue = node => {
      if (!node && !node.element) return undefined
      if (Object.is(node.element.key, key)) {
        return node.element.value
      } else {
        return getElementValue(node.next)
      }
    }
    return getElementValue(this.table[position].head)
  }

  remove(key) {
    const position = HashTable.loseloseHashCode(key)
    if (this.table[position] === undefined) return undefined
    const getElementValue = node => {
      if (!node && !node.element) return false
      if (Object.is(node.element.key, key)) {
        this.table[position].remove(node.element)
        if (this.table[position].isEmpty) {
          this.table[position] = undefined
        }
        return true
      } else {
        return getElementValue(node.next)
      }
    }
    return getElementValue(this.table[position].head)
  }
}

ok，大功告成！分離連接的核心在於每個存儲數字的位置都是一個單向鏈表，這樣子在找一個值得時候，首先找到其所在的位置，而後從該位置的鏈表的頭部開始查找，相比直接查找位置，這樣子效率是慢了，可是確實是解決了衝突問題。

接下來看第二種解決衝突的辦法：線性探查。

線性探查就比較粗暴了，當想向表中某個位置加人一個新元素的時候，若是索引爲 index 的位置已經被佔據了，就嘗試 index+1的位置。若是index+1 的位置也被佔據了，就嘗試 index+2 的位置，以此類推。

直接改寫插入的方法：

put(key,value){
  const position = HashTable.loseloseHashCode(key)
  if (this.table[position] === undefined) this.table[position] = { key, value }
  else {
    let index = ++position
    while (this.table[index] !== undefined) index++
    this.table[index] = { key, value }
  }
}

獲取：

get(key) {
  const position = HashTable.loseloseHashCode(key)
  const getElementValue = index => {
    if (this.table[index] === undefined) return undefined
    if (Object.is(this.table[index].key, key)) return this.table[index].value
    else return getElementValue(index + 1)
  }
  return getElementValue(position)
}

移除：

remove(key) {
  const position = HashTable.loseloseHashCode(key)
  const removeElementValue = index => {
    if (this.table[key] === undefined) return false
    if (Object.is(this.table[index].key, key)) {
      this.table[index] = undefined
      return true
    } 
    else 
      return this.removeElementValue(index + 1)
  }
  return removeElementValue(position)
}

整理一下，

class HashTable {
  constructor() {
    this.table = []
  }
  static loseloseHashCode(key) {
    let hash = 0
    for (let codePoint of key) {
      hash += codePoint.charCodeAt()
    }
    return hash % 37
  }
  // 修改和增長元素
  put(key, value) {
    const position = HashTable.loseloseHashCode(key)
    if (this.table[position] === undefined) this.table[position] = { key, value }
    else {
      let index = ++position
      while (this.table[index] !== undefined) index++
      this.table[index] = { key, value }
    }
  }

  get(key) {
    const position = HashTable.loseloseHashCode(key)
    const getElementValue = index => {
      if (this.table[index] === undefined) return undefined
      if (Object.is(this.table[index].key, key)) return this.table[index].value
      else return getElementValue(index + 1)
    }
    return getElementValue(position)
  }

  remove(key) {
    const position = HashTable.loseloseHashCode(key)
    const removeElementValue = index => {
      if (this.table[key] === undefined) return false
      if (Object.is(this.table[index].key, key)) {
        this.table[index] = undefined
        return true
      } else return this.removeElementValue(index + 1)
    }
    return removeElementValue(position)
  }
}

其實線性探查是最簡單粗暴的，就你佔我位置了，那我去下一個位置，總能找到一個沒有被佔用的，可是這個方法在數值過多的狀況下回就突顯缺點：慢，由於若是有上億的數據，最壞的多是插入一次須要查找一億次，這就很浪費時間，因此大佬們就會去尋找更簡單的散列函數來處理存入的位置，例如 djb2 、sdbm等等。

接下來介紹一下 djb2 散列函數：

static djb2HashCode(key) {
  let hash = 5381
  for (let codePoint of key) {
    hash = hash * 33 + codePoint.charCodeAt()
  }
  return hash % 1013
}

djb2 函數比「lose lose」函數的衝突少的多，能更有效的節約處理衝突的時間。

10、樹

樹狀圖是一種數據結構，它是由n（n>=1）個有限結點組成一個具備層次關係的集合。把它叫作「樹」是由於它看起來像一棵倒掛的樹，也就是說它是根朝上，而葉朝下的。它具備如下的特色：

　　每一個結點有零個或多個子結點；

　　沒有父結點的結點稱爲根結點；

　　每個非根結點有且只有一個父結點；

　　除了根結點外，每一個子結點能夠分爲多個不相交的子樹。

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。