通用函數，在之後的舉例中會使用到。
function checkArray(array) {
if (!array) return
}
function swap(array, left, right) {
let rightValue = array[right]
array[right] = array[left]
array[left] = rightValue
}
冒泡排序
冒泡排序的原理如下，從第一個元素開始，把當前元素和下一個索引元素進行比較。如果當前元素大，那麼就交換位置，重複操作直到比較到最後一個元素，那麼此時最後一個元素就是該數組中最大的數。下一輪重複以上操作，但是此時最後一個元素已經是最大數了，所以不需要再比較最後一個元素，只需要比較到 length - 2 的位置。
function bubble(array) {
checkArray(array);
for (let i = array.length - 1; i > 0; i--) {
// 從 0 到 `length - 1` 遍歷
for (let j = 0; j < i; j++) {
if (array[j] > array[j + 1]) swap(array, j, j + 1)
}
}
return array;
}
console.log(bubble([5,9,8,6,3,2]))//2 3 5 6 8 9
該算法的操作次數是一個等差數列 n + (n - 1) + (n - 2) + 1 ，去掉常數項以後得出時間複雜度是 O(n * n)。
插入排序
插入排序的原理如下。第一個元素默認是已排序元素，取出下一個元素和當前元素比較，如果當前元素大就交換位置。那麼此時第一個元素就是當前的最小數，所以下次取出操作從第三個元素開始，向前對比，重複之前的操作。
function insertion(array) {
checkArray(array);
for (let i = 1; i < array.length; i++) {
for (let j = i - 1; j >= 0 && array[j] > array[j + 1]; j--)
swap(array, j, j + 1);
}
return array;
}
console.log(insertion([5,9,8,6,3,2]))//2 3 5 6 8 9
該算法的操作次數是一個等差數列 n + (n - 1) + (n - 2) + 1 ，去掉常數項以後得出時間複雜度是 O(n * n)。
選擇排序
選擇排序的原理如下。遍歷數組，設置最小值的索引爲 0，如果取出的值比當前最小值小，就替換最小值索引，遍歷完成後，將第一個元素和最小值索引上的值交換。如上操作後，第一個元素就是數組中的最小值，下次遍歷就可以從索引 1 開始重複上述操作。
function selection(array) {
checkArray(array);
for (let i = 0; i < array.length - 1; i++) {
let minIndex = i;
for (let j = i + 1; j < array.length; j++) {
minIndex = array[j] < array[minIndex] ? j : minIndex;
}
swap(array, i, minIndex);
}
return array;
}
console.log(selection([5,9,8,6,3,2]))//2 3 5 6 8 9
該算法的操作次數是一個等差數列 n + (n - 1) + (n - 2) + 1 ，去掉常數項以後得出時間複雜度是 O(n * n)。
歸併排序
歸併排序的原理如下。遞歸的將數組兩兩分開直到最多包含兩個元素，然後將數組排序合併，最終合併爲排序好的數組。假設我有一組數組 [3, 1, 2, 8, 9, 7, 6]，中間數索引是 3，先排序數組 [3, 1, 2, 8] 。在這個左邊數組上，繼續拆分直到變成數組包含兩個元素（如果數組長度是奇數的話，會有一個拆分數組只包含一個元素）。然後排序數組 [3, 1] 和 [2, 8] ，然後再排序數組 [1, 3, 2, 8] ，這樣左邊數組就排序完成，然後按照以上思路排序右邊數組，最後將數組 [1, 2, 3, 8] 和 [6, 7, 9] 排序。
function sort(array) {
checkArray(array);
mergeSort(array, 0, array.length - 1);
return array;
}
function mergeSort(array, left, right) {
// 左右索引相同說明已經只有一個數
if (left === right) return;
// 等同於 `left + (right - left) / 2`
// 相比 `(left + right) / 2` 來說更加安全，不會溢出
// 使用位運算是因爲位運算比四則運算快
let mid = parseInt(left + ((right - left) >> 1));
mergeSort(array, left, mid);
mergeSort(array, mid + 1, right);
let help = [];
let i = 0;
let p1 = left;
let p2 = mid + 1;
while (p1 <= mid && p2 <= right) {
help[i++] = array[p1] < array[p2] ? array[p1++] : array[p2++];
}
while (p1 <= mid) {
help[i++] = array[p1++];
}
while (p2 <= right) {
help[i++] = array[p2++];
}
for (let i = 0; i < help.length; i++) {
array[left + i] = help[i];
}
return array;
}
console.log(sort([5,9,8,6,3,2]))//2 3 5 6 8 9
以上算法使用了遞歸的思想。遞歸的本質就是壓棧，每遞歸執行一次函數，就將該函數的信息（比如參數，內部的變量，執行到的行數）壓棧，直到遇到終止條件，然後出棧並繼續執行函數。對於以上遞歸函數的調用軌跡如下：
mergeSort(data, 0, 6) // mid = 3
mergeSort(data, 0, 3) // mid = 1
mergeSort(data, 0, 1) // mid = 0
mergeSort(data, 0, 0) // 遇到終止，回退到上一步
mergeSort(data, 1, 1) // 遇到終止，回退到上一步
// 排序 p1 = 0, p2 = mid + 1 = 1
// 回退到 `mergeSort(data, 0, 3)` 執行下一個遞歸
mergeSort(2, 3) // mid = 2
mergeSort(3, 3) // 遇到終止，回退到上一步
// 排序 p1 = 2, p2 = mid + 1 = 3
// 回退到 `mergeSort(data, 0, 3)` 執行合併邏輯
// 排序 p1 = 0, p2 = mid + 1 = 2
// 執行完畢回退
// 左邊數組排序完畢，右邊也是如上軌跡
該算法的操作次數是可以這樣計算：遞歸了兩次，每次數據量是數組的一半，並且最後把整個數組迭代了一次，所以得出表達式 2T(N / 2) + T(N) （T 代表時間，N 代表數據量）。根據該表達式可以套用 該公式 得出時間複雜度爲 O(N * logN)
快排
快排的原理如下。隨機選取一個數組中的值作爲基準值，從左至右取值與基準值對比大小。比基準值小的放數組左邊，大的放右邊，對比完成後將基準值和第一個比基準值大的值交換位置。然後將數組以基準值的位置分爲兩部分，繼續遞歸以上操作。
function sort(array) {
checkArray(array);
quickSort(array, 0, array.length - 1);
return array;
}
function quickSort(array, left, right) {
if (left < right) {
swap(array, , right)
// 隨機取值，然後和末尾交換，這樣做比固定取一個位置的複雜度略低
let indexs = part(array, parseInt(Math.random() * (right - left + 1)) + left, right);
quickSort(array, left, indexs[0]);
quickSort(array, indexs[1] + 1, right);
}
}
function part(array, left, right) {
let less = left - 1;
let more = right;
while (left < more) {
if (array[left] < array[right]) {
// 當前值比基準值小，`less` 和 `left` 都加一
++less;
++left;
} else if (array[left] > array[right]) {
// 當前值比基準值大，將當前值和右邊的值交換
// 並且不改變 `left`，因爲當前換過來的值還沒有判斷過大小
swap(array, --more, left);
} else {
// 和基準值相同，只移動下標
left++;
}
}
// 將基準值和比基準值大的第一個值交換位置
// 這樣數組就變成 `[比基準值小, 基準值, 比基準值大]`
swap(array, right, more);
return [less, more];
}
將 [2,0,2,1,1,0] 排序成 [0,0,1,1,2,2]？
function sortColors(nums) {
let left = -1;
let right = nums.length;
let i = 0;
// 下標如果遇到 right，說明已經排序完成
while (i < right) {
if (nums[i] === 0) {
swap(nums, i++, ++left);
} else if (nums[i] === 1) {
i++;
} else {
swap(nums, i, --right);
}
}
return nums
}
console.log(sortColors([2,0,2,1,1,0]))
找出數組中第 K 大的元素？
var findKthLargest = function(nums, k) {
let l = 0
let r = nums.length - 1
// 得出第 K 大元素的索引位置
k = nums.length - k
while (l < r) {
// 分離數組後獲得比基準樹大的第一個元素索引
let index = part(nums, l, r)
// 判斷該索引和 k 的大小
if (index < k) {
l = index + 1
} else if (index > k) {
r = index - 1
} else {
break
}
}
return nums[k]
};
function part(array, left, right) {
let less = left - 1;
let more = right;
while (left < more) {
if (array[left] < array[right]) {
++less;
++left;
} else if (array[left] > array[right]) {
swap(array, --more, left);
} else {
left++;
}
}
swap(array, right, more);
return more;
}
console.log(findKthLargest([1,2,3,4,5,6,7,8,9],2))//8
堆排序
堆排序利用了二叉堆的特性來做，二叉堆通常用數組表示，並且二叉堆是一顆完全二叉樹（所有葉節點（最底層的節點）都是從左往右順序排序，並且其他層的節點都是滿的）。二叉堆又分爲大根堆與小根堆。
大根堆是某個節點的所有子節點的值都比他小
小根堆是某個節點的所有子節點的值都比他大
堆排序的原理就是組成一個大根堆或者小根堆。以小根堆爲例，某個節點的左邊子節點索引是 i * 2 + 1，右邊是 i * 2 + 2，父節點是 (i - 1) /2。
- 首先遍歷數組，判斷該節點的父節點是否比他小，如果小就交換位置並繼續判斷，直到他的父節點比他大
- 重新以上操作 1，直到數組首位是最大值
- 然後將首位和末尾交換位置並將數組長度減一，表示數組末尾已是最大值，不需要再比較大小
- 對比左右節點哪個大，然後記住大的節點的索引並且和父節點對比大小，如果子節點大就交換位置
- 重複以上操作 3 - 4 直到整個數組都是大根堆。
function heap(array) {
checkArray(array);
// 將最大值交換到首位
for (let i = 0; i < array.length; i++) {
heapInsert(array, i);
}
let size = array.length;
// 交換首位和末尾
swap(array, 0, --size);
while (size > 0) {
heapify(array, 0, size);
swap(array, 0, --size);
}
return array;
}
function heapInsert(array, index) {
// 如果當前節點比父節點大，就交換
while (array[index] > array[parseInt((index - 1) / 2)]) {
swap(array, index, parseInt((index - 1) / 2));
// 將索引變成父節點
index = parseInt((index - 1) / 2);
}
}
function heapify(array, index, size) {
let left = index * 2 + 1;
while (left < size) {
// 判斷左右節點大小
let largest =
left + 1 < size && array[left] < array[left + 1] ? left + 1 : left;
// 判斷子節點和父節點大小
largest = array[index] < array[largest] ? largest : index;
if (largest === index) break;
swap(array, index, largest);
index = largest;
left = index * 2 + 1;
}
}
console.log(heap([5,9,8,6,3,2]))// 2 3 5 6 8 9
以上代碼實現了小根堆，如果需要實現大根堆，只需要把節點對比反一下就好。
系統自帶排序實現
對於 JS 來說，數組長度大於 10 會採用快排，否則使用插入排序 源碼實現 。選擇插入排序是因爲雖然時間複雜度很差，但是在數據量很小的情況下和 O(N * logN)相差無幾，然而插入排序需要的常數時間很小，所以相對別的排序來說更快。