本文參考：百度百科對於排序的解釋
常見排序算法的比較：
| 排序算法 | 最佳時間複雜度 | 平均時間複雜度 | 最壞時間複雜度 | 穩定性 |
|---|---|---|---|---|
| 選擇排序 | O(N^2) | O(N^2) | O(N^2) | 不穩定 |
| 插入排序 | O(N) | O(N^2) | O(N^2) | 穩定 |
| 冒泡排序 | O(N) | O(N^2) | O(N^2) | 穩定 |
| 希爾排序 | O(N) | O(NlogN) | O(N^S)（1<S<2） | 不穩定 |
| 快速排序 | O(NlogN) | O(NlogN) | O(N^2) | 不穩定 |
| 堆排序 | O(NlogN) | O(NlogN) | O(NlogN) | 不穩定 |
| 歸併排序 | O(NlogN) | O(NlogN) | O(NlogN) | 穩定 |
選擇排序：
選擇排序
（Selectionsort）是一種簡單直觀的排序算法。
它的工作原理是：第一次從待排序的數據元素中選出最小（或最大）的一個元素，存放在序列的起始位置，然後再從剩餘的未排序元素中尋找到最小（大）元素，然後放到已排序的序列的末尾。以此類推，直到全部待排序的數據元素的個數爲零。選擇排序是不穩定的排序方法。
JavaScript實現：
var arr = new Array(1, 3, 2, 8, 9, 1, 5);
function SelectionSort(arr) {
if (arr == null || arr.length < 2) {
return arr;
}
for (var i = 0; i < (arr.length - 1); i++) {
let minIndex = i;
for (let j = i + 1; j < arr.length; j++) {
minIndex = arr[j] < arr[minIndex] ? j : minIndex;
}
let temp = arr[i];
arr[i] = arr[minIndex];
arr[minIndex] = temp;
}
return arr;
}
console.log(arr);
SelectionSort(arr);
console.log(arr);
插入排序：
插入排序
（Insertionsort）是一種簡單直觀且穩定的排序算法。
如果有一個已經有序的數據序列，要求在這個已經排好的數據序列中插入一個數，但要求插入後此數據序列仍然有序，這個時候就要用到一種新的排序方法——插入排序法,算法適用於少量數據的排序，時間複雜度O(n^2)。是穩定的排序方法。
插入算法把要排序的數組分成兩部分：第一部分包含了這個數組的所有元素，但將最後一個元素除外（讓數組多一個空間纔有插入的位置），而第二部分就只包含這一個元素（即待插入元素）。在第一部分排序完成後，再將這個最後元素插入到已排好序的第一部分中。
JavaScript實現：
//測試數組
var arr = new Array(1, 3, 2, 8, 9, 1, 5);
//插入排序
function InsertionSort(arr) {
if (arr == null || arr.length < 2) {
return arr;
}
for (let i = 1; i < arr.length; i++) {
for (let j = i - 1; j >= 0 && arr[j] > arr[j + 1]; j--) {
let temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
return arr;
}
//控制檯輸出
console.log(arr);
InsertionSort(arr);
console.log(arr);
冒泡排序
冒泡排序（Bubble Sort），是一種計算機科學領域的較簡單的排序算法。
它重複地走訪過要排序的元素列，依次比較兩個相鄰的元素，如果順序（如從大到小、首字母從Z到A）錯誤就把他們交換過來。走訪元素的工作是重複地進行直到沒有相鄰元素需要交換，也就是說該元素列已經排序完成。
這個算法的名字由來是因爲越小的元素會經由交換慢慢“浮”到數列的頂端（升序或降序排列），就如同碳酸飲料中二氧化碳的氣泡最終會上浮到頂端一樣，故名“冒泡排序”。
JavaScript實現：
function bubbleSort(arr) {
var i = arr.length, j;
var tempExchangVal;
while (i > 0) {
for (j = 0; j < i - 1; j++) {
if (arr[j] > arr[j + 1]) {
tempExchangVal = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = tempExchangVal;
}
}
i--;
}
return arr;
}
var arr = [3, 2, 4, 9, 1, 5, 7, 6, 8];
var arrSorted = bubbleSort(arr);
console.log(arrSorted);
alert(arrSorted);
希爾排序
希爾排序(Shell’s Sort)是插入排序的一種又稱“縮小增量排序”（Diminishing Increment
Sort），是直接插入排序算法的一種更高效的改進版本。希爾排序是非穩定排序算法。該方法因D.L.Shell於1959年提出而得名。
希爾排序是把記錄按下標的一定增量分組，對每組使用直接插入排序算法排序；隨着增量逐漸減少，每組包含的關鍵詞越來越多，當增量減至1時，整個文件恰被分成一組，算法便終止。
JavaScript實現
var arr = [49, 38, 65, 97, 76, 13, 27, 49, 55, 04];
var len = arr.length;
for (var fraction = Math.floor(len / 2); fraction > 0; fraction = Math.floor(fraction / 2)) {
for (var i = fraction; i < len; i++) {
for (var j = i - fraction; j >= 0 && arr[j] > arr[fraction + j]; j -= fraction) {
var temp = arr[j];
arr[j] = arr[fraction + j];
arr[fraction + j] = temp;
}
}
}
console.log(arr);
快速排序
快速排序（Quicksort）是對冒泡排序的一種改進。 快速排序由C. A. R.
Hoare在1960年提出。它的基本思想是：通過一趟排序將要排序的數據分割成獨立的兩部分，其中一部分的所有數據都比另外一部分的所有數據都要小，然後再按此方法對這兩部分數據分別進行快速排序，整個排序過程可以遞歸進行，以此達到整個數據變成有序序列。
JavaScript實現：
const quickSort = (array) => {
const sort = (arr, left = 0, right = arr.length - 1) => {
if (left >= right) {//如果左邊的索引大於等於右邊的索引說明整理完畢
return
}
let i = left
let j = right
const baseVal = arr[j] // 取無序數組最後一個數爲基準值
while (i < j) {//把所有比基準值小的數放在左邊大的數放在右邊
while (i < j && arr[i] <= baseVal) { //找到一個比基準值大的數交換
i++
}
arr[j] = arr[i] // 將較大的值放在右邊如果沒有比基準值大的數就是將自己賦值給自己（i 等於 j）
while (j > i && arr[j] >= baseVal) { //找到一個比基準值小的數交換
j--
}
arr[i] = arr[j] // 將較小的值放在左邊如果沒有找到比基準值小的數就是將自己賦值給自己（i 等於 j）
}
arr[j] = baseVal // 將基準值放至中央位置完成一次循環（這時候 j 等於 i ）
sort(arr, left, j-1) // 將左邊的無序數組重複上面的操作
sort(arr, j+1, right) // 將右邊的無序數組重複上面的操作
}
const newArr = array.concat() // 爲了保證這個函數是純函數拷貝一次數組
sort(newArr)
return newArr
}
堆排序
堆排序（英語：Heapsort）是指利用堆這種數據結構所設計的一種排序算法。堆是一個近似完全二叉樹的結構，並同時滿足堆積的性質：即子結點的鍵值或索引總是小於（或者大於）它的父節點。
歸併排序
歸併排序（MERGE-SORT）是建立在歸併操作上的一種有效的排序算法,該算法是採用分治法（Divide and
Conquer）的一個非常典型的應用。將已有序的子序列合併，得到完全有序的序列；即先使每個子序列有序，再使子序列段間有序。若將兩個有序表合併成一個有序表，稱爲二路歸併。歸併排序是一種穩定的排序方法。