JavaScript資料結構和演算法

轉載自【JavaScript資料結構和演算法 】

前言

在過去的幾年中，得益於Node.js的興起，JavaScript越來越廣泛地用於伺服器端程式設計。鑑於JavaScript語言已經走出了瀏覽器，程式設計師發現他們需要更多傳統語言（比如C++和Java）提供的工具。這些工具包括傳統的資料結構（如連結串列，棧，佇列，圖等），也包括傳統的排序和查詢演算法。本文主要是總結什麼情況下使用何種資料結構較好，並沒有細講裡面的原理和實現方式，僅僅提供給閱讀過《資料結構和演算法》的同學作為總結和參考筆記，如果未細究過資料結構和演算法的同學，本文也可以作為一個方向，希望能引導你去深究資料結構和演算法。

為什麼要學習資料結構和演算法

資料結構和演算法對於很多前端工程師來說，一直覺得是可有可無的，但其實不然，個人覺得，前端工程師其實是最需要重視資料結構和演算法的人，因為前端所做的東西是使用者訪問網站第一眼看到的東西，特別在移動浪潮到來之後，對使用者體驗越來越高，對前端提出了更高的要求，面對越來越複雜的產品，需要堅實的資料結構和演算法基礎才能駕馭。
如果沒有學習過電腦科學的程式設計師，當我們在處理一些問題時，比較熟悉的資料結構就是陣列，陣列無疑是一個很好的選擇。但很多時候，對於很多複雜的問題，陣列就顯得太過簡陋了，當學習了資料結構和演算法之後，對於很多程式設計問題，當想到一個合適的資料結構後，設計、實現和解決這些問題的演算法就手到擒來。

相關知識點——資料結構、排序演算法和查詢演算法

相關講解細分：
資料結構：列表、棧、佇列、連結串列、字典、雜湊、圖和二叉查詢樹
排序演算法：氣泡排序、選擇排序、插入排序、希爾排序、歸併排序和快速排序
查詢演算法：順序查詢和二分查詢

列表

在日常生活中，人們經常使用列表：待辦事項列表、購物清單、最佳十名榜單等等。而計算機程式也在使用列表，在下面的條件下，選擇列表作為資料結構就顯得尤為有用：

• 資料結構較為簡單
• 不需要在一個長序列中查詢元素，或者對其進行排序

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

棧

棧是一種特殊的列表，棧內的元素只能通過列表的一端訪問，這一端稱為棧頂。想象一下，我們平常在飯館見到的一摞盤子就是現實世界常見的棧的例子，只能從最上面取盤子，盤子洗乾淨後，也只能放在最上面。棧被稱為一種後入先出的資料結構。是一種高效的資料結構，因為資料只能在棧頂新增或刪除，所以這樣的操作很快。
使用條件：

• 只要資料的儲存滿足後入先出或先進後出的原理，都優先考慮使用棧.

佇列

佇列也是一種列表，不同的是佇列只能在隊尾插入元素，在隊首刪除元素。想象一下，我們在銀行排隊，排在最前面的人第一個辦理業務，而後面來的人只能排在隊伍的後面，直到輪到他們為止。
使用條件：

• 只要資料的儲存滿足先進先出、後入後出的原理，都優先考慮使用佇列

常見應用場景：

• 佇列主要用在和時間有關的地方，特別是作業系統中，佇列是實現多工的重要機制
• 訊息機制可以通過佇列來實現，程式排程也是使用佇列來實現

連結串列

連結串列也是一種列表，為什麼需要出現連結串列，JavaScript中陣列的主要問題時，它們被實現成了物件，與其他語言（比如C++和Java）的陣列相對，效率很低。如果你發現陣列在實際使用時很慢，就可以考慮使用連結串列來代替它。
使用條件：

• 連結串列幾乎可以用在任何可以使用一維陣列的情況中。如果需要隨機訪問，陣列仍然是更好的選擇。

字典

字典是一種以鍵-值對行駛儲存資料的資料結構，JavaScript中的Object類就是以字典的形式設計的。JavaScript可以通過實現字典類，讓這種字典型別的物件使用起來更加簡單，字典可以實現物件擁有的常見功能，並相應擴充自己想要的功能，而物件在JavaScript編寫中隨處可見，所以字典的作用也異常明顯了。

雜湊

雜湊（也稱為雜湊表）是一種的常用的陣列儲存技術，雜湊後的陣列可以快速地插入或取用。雜湊使用的資料結構叫做雜湊表。在雜湊表上插入、刪除和取用資料都非常快，但對於查詢操作來說卻效率低下，比如查詢一組陣列中的最大值和最小值。這些操作需要求助於其他資料結構，比如下面介紹的二叉查詢樹。

雜湊表在JavaScript中可以基於陣列去進行設計。陣列的長度是預先設定的，所有元素根據和該元素對應的鍵，儲存在陣列的特定位置，這裡的鍵和物件的鍵是類似的概念。使用雜湊表儲存陣列時，通過一個雜湊函式將鍵對映為一個數字，這個數字的範圍是0到雜湊表的長度。

但是即使使用一個高效的雜湊函式，依然存在將兩個鍵對映為同一個值的可能，這種現象叫做碰撞。常見碰撞的處理方法有：開鏈法和線性探測法（具體概念有興趣的可以網上自信瞭解）

使用條件：

• 可以用於資料的插入、刪除和取用，不適用於查詢資料

圖

圖由邊的集合及頂點的集合組成。地圖是我們身邊很常見的現實場景，比如每兩個城鎮都由某種道路相連。上面的每個城鎮可以看作一個頂點，連線城鎮的道路便是邊。邊由頂點對（v1, v2）定義，v1和v2分別是圖中的兩個頂點。頂點也有權重，也成為成本。如果一個圖的頂點對是有序的，則稱之為有向圖（例如常見的流程圖），反之，稱之為無序圖。
使用場景（用圖對現實中的系統建模）：

• 交通系統，可以用頂點表示街道的十字路口，邊可以表示街道。加權的邊可以表示限速或者車道的數量。可以用該系統判斷最佳路線及最有可能堵車的街道。
• 任何運輸系統都可以用圖來建模。比如，航空公司可以用圖來為其飛行系統建模。將每個機場看成頂點，將經過兩個頂點的每條航線看作一條邊。加權的邊可以表示從一個機場到另一個機場的航班成本，或兩個機場間的距離，這取決於建模的物件是什麼。

搜尋圖的演算法主要有兩種： 深度優先搜尋和廣度優先搜尋。

二叉樹和二叉查詢樹

樹是電腦科學中經常用到的一種資料結構。樹是一種非線性的資料結構，以分層的方式儲存資料。
二叉樹每個節點的子節點不允許超過兩個。一個父節點的兩個子節點分別稱為左節點和右節點，通過將子節點的個數限定為2，可以寫出高效的程式在樹中插入、查詢和刪除資料。
二叉查詢樹（BST）是一種特殊的二叉樹，相對較小的值儲存在左節點中，較大的值儲存在右節點中。這一特性使得查詢的效率很高，對於數值型和非數值型的資料，比如單詞和字串，都是如此。
二叉查詢樹實現方法

function Node(data, left, right) { // 建立節點
  this.data = data;
  this.left = left;
  this.right = right;
  this.show = show
}

function show () { // 顯示樹的資料
  return this.data
}

function BST () { // 二叉查詢樹類
  this.root = null;
  this.insert = insert;
  this.inOrder = inOrder; // inOrder是遍歷BST的方式
}

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 (true) {
	  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;
		}
	  }
    }
  }
}複製程式碼

遍歷BST的方式有三種：中序遍歷（以升序訪問樹中所有節點，先訪問左節點，再訪問根節點，最後訪問右節點）【10 22 30 56 77 81 92】、先序遍歷（先訪問根節點，再以同樣的方式訪問左節點和右節點）【56 22 10 30 81 77 92】、後序遍歷（先訪問葉子節點，從左子樹到右子樹，再到根節點）【10 30 22 77 92 81 56】

排序演算法

基本排序演算法

基本排序演算法，其核心思想是指對一組陣列按照一定的順序重新排列。重新排列時用到的技術是一組巢狀的for迴圈。其中外迴圈會遍歷陣列的每一項，內迴圈則用於比較元素。

氣泡排序

氣泡排序是一種簡單的排序演算法。它重複地走訪過要排序的數列，一次比較兩個元素，如果它們的順序錯誤就把它們交換過來。走訪數列的工作是重複地進行直到沒有再需要交換，也就是說該數列已經排序完成。這個演算法的名字由來是因為越小的元素會經由交換慢慢“浮”到數列的頂端。

function bubbleSort (arr) {
	var i = arr.length;
	while (i > 0) {
		var pos = 0
		for (var j = 0; j < i; j++) {
			if (arr[j] > arr[j+1]){
				pos = j
				var temp = arr[j]
				arr[j] = arr[j+1]
				arr[j+1] = temp
			}
		}
		i = pos
	}
	return arr
}
var arr=[3,44,38,5,47,15,36,26,27,2,46,4,19,50,48];
console.log(bubbleSort(arr));//[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]複製程式碼

選擇排序

選擇排序(Selection-sort)是一種簡單直觀的排序演算法。它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然後，再從剩餘未排序元素中繼續尋找最小（大）元素，然後放到已排序序列的末尾。以此類推，直到所有元素均排序完畢。

function selectionSort (arr) {
	var len = arr.length;
	var minIndex, temp;
	for (var i = 0; i < len-1; i++) {
		minIndex = i;
		for (var j = i+1; j < len; j++) {
			if (arr[j] < arr[minIndex]) {
				minIndex = j
			}
		}
		temp = arr[minIndex]
		arr[minIndex] = arr[i]
		arr[i] = temp
	}
	return arr
}
var arr=[3,44,38,5,47,15,36,26,27,2,46,4,19,50,48];
console.log(selectionSort(arr));//[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]複製程式碼

插入排序

插入排序（Insertion-Sort）的演算法描述是一種簡單直觀的排序演算法。它的工作原理是通過構建有序序列，對於未排序資料，在已排序序列中從後向前掃描，找到相應位置並插入。插入排序在實現上，通常採用in-place排序（即只需用到O(1)的額外空間的排序），因而在從後向前掃描過程中，需要反覆把已排序元素逐步向後挪位，為最新元素提供插入空間。

function insertSort (arr) {
	var len = arr.length
	for (i = 1; i < len; i++) {
		var key = arr[i]
		var j = i - 1
		while (j >= 0 && arr[j] > key) {
			arr[j+1] = arr[j]
			j--;
		}
		arr[j+1] = key
	}
	return arr
}
var arr=[3,44,38,5,47,15,36,26,27,2,46,4,19,50,48];
console.log(insertSort(arr));//[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]複製程式碼

高階排序演算法

高階資料排序演算法，通常用於處理大型資料集的最高效排序演算法，它們處理的資料集可以達到上百萬個元素，而不僅僅是幾百個或者幾千個，下面我們將介紹希爾排序、歸併排序和快速排序。

希爾排序

1959年Shell發明，第一個突破O(n^2)的排序演算法；是簡單插入排序的改進版；它與插入排序的不同之處在於，它會優先比較距離較遠的元素。希爾排序又叫縮小增量排序。
希爾排序的核心在於間隔序列的設定。既可以提前設定好間隔序列，也可以動態的定義間隔序列。

function shellSort (arr) {
	var len = arr.length;
	var temp, gap = 1;
	while (gap < len /3 ) {
		gap = gap * 3 + 1
	}
	while (gap >= 1) {
		for (var i = gap; i < len; i++) {
			temp = arr[i]
			for (var j = i - gap; j >= 0 && arr[j] > temp; j-=gap) {
				arr[j+gap] = arr[j]
			}
			arr[j+gap] = temp
		}
		gap = (gap - 1) / 3
	}
	return arr
}
var arr=[3,44,38,5,47,15,36,26,27,2,46,4,19,50,48];
console.log(shellSort(arr));//[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]複製程式碼

歸併排序

歸併排序是建立在歸併操作上的一種有效的排序演算法。該演算法是採用分治法（Divide and Conquer）的一個非常典型的應用。歸併排序是一種穩定的排序方法。將已有序的子序列合併，得到完全有序的序列；即先使每個子序列有序，再使子序列段間有序。若將兩個有序表合併成一個有序表，稱為2-路歸併。

function mergeSort (arr) {
	var len = arr.length
	if (len < 2) {
		return arr
	}
	var middle = Math.floor(len / 2)
	var left = arr.slice(0, middle)
	var right = arr.slice(middle)
	return merge (mergeSort(left), mergeSort(right));
}
function merge (left, right) {
	var result = []
	while (left.length && right.length) {
		if (left[0] < right[0]) {
			result.push(left.shift())
		} else {
			result.push(right.shift())
		}
	}
	while (left.length) {
		result.push(left.shift())
	}
	while (right.length) {
		result.push(right.shift())
	}
	return result
}
var arr=[3,44,38,5,47,15,36,26,27,2,46,4,19,50,48];
console.log(mergeSort(arr));複製程式碼

快速排序

快速排序是處理 大資料集最快的排序演算法之一。它是一種分而治之的演算法，通過遞迴的方法將資料依次分解為包含較小元素和較大元素的不同子序列。該演算法不斷重複這個步驟知道所有資料都是有序的。
這個演算法首先要在列表中選擇一個元素作為基準值。資料排序圍繞基準值進行，將列表中小於基準值的元素移到陣列的底部，將大於基準值的元素移到陣列的頂部。

function qSort (arr) {
	if (arr.length == 0) {
		return []
	}
	var left = []
	var right = []
	var pivot = arr[0]
	for (var i = 1; i < arr.length; i++) {
		if (arr[i] < pivot) {
			left.push(arr[i])
		} else {
			right.push(arr[i])
		}
	}
	return qSort(left).concat(pivot, qSort(right))
}
var arr=[3,44,38,5,47,15,36,26,27,2,46,4,19,50,48];
console.log(qSort(arr));複製程式碼

檢索演算法

在列表中查詢資料有兩種方式：順序查詢和二分查詢。順序查詢適用於元素隨機排列的列表；二分查詢適用於元素已排序的列表。二分查詢效率更高，但是必須在進行查詢之前花費額外的時間將列表中的元素排序。

順序查詢

對於查詢資料，最簡單的方法就是從列表的第一個元素開始對列表元素逐個進行判斷，直到找到了想要的結果，或者直到列表結尾也沒有找到。這種方法稱為順序查詢，有時也被稱為線性查詢。

function seqSearch (arr, data) {
  for (var i = 0; i < arr.length; i++) {
    if (arr[i] == data) {
      return i;
    }
  }
  return -1;
}
var arr=[3,44,38,5,47,15,36,26,27,2,46,4,19,50,48];
console.log(seqSearch(arr, 15))複製程式碼

二分查詢

二分法查詢，也稱折半查詢，是一種在有序陣列中查詢特定元素的搜尋演算法。查詢過程可以分為以下步驟：

• 首先，從有序陣列的中間的元素開始搜尋，如果該元素正好是目標元素（即要查詢的元素），則搜尋過程結束，否則進行下一步。
• 如果目標元素大於或者小於中間元素，則在陣列大於或小於中間元素的那一半區域查詢，然後重複第一步的操作。
• 如果某一步陣列為空，則表示找不到目標元素。

function binSearch (arr, data) {
	var low = 0;
	var high = arr.length - 1
	while (low <= high) {
		var middle = Math.floor((low + high) / 2)
		if (arr[middle] < data) {
			low = middle + 1
		} else if (arr[middle] > data) {
			high = middle - 1
		} else {
			return middle
		}
	}
	return -1
}
var arr=[3,44,38,5,47,15,36,26,27,2,46,4,19,50,48];
console.log(binSearch(arr, 15))複製程式碼