排序演算法是面試及筆試中必考點，本文通過動畫方式演示，通過例項講解，最後給出JavaScript版的排序演算法

插入排序

演算法描述：
1. 從第一個元素開始，該元素可以認為已經被排序
2. 取出下一個元素，在已經排序的元素序列中從後向前掃描
3. 如果該元素（已排序）大於新元素，將該元素移到下一位置
4. 重複步驟 3，直到找到已排序的元素小於或者等於新元素的位置
5. 將新元素插入到該位置後
6. 重複步驟 2~5

現有一組陣列 arr = [5, 6, 3, 1, 8, 7, 2, 4]

[5] 6 3 1 8 7 2 4  //第一個元素被認為已經被排序
 


[5,6]  3 1 8 7 2 4 //6與5比較，放在5的右邊

[3，5，6]  1 8 7 2 4 //3與6和5比較，都小，則放入陣列頭部

[1,3,5,6]   8 7 2 4 //1與3,5,6比較，則放入頭部

[1,3，5，6，8]   7 2 4

[1,3，5，6,7，8]  2 4

[1，2,3，5，6,7，8] 4

[1，2,3，4，5，6,7，8] 

程式設計思路：雙層迴圈，外迴圈控制未排序的元素，內迴圈控制已排序的元素，將未排序元素設為標杆，與已排序的元素進行比較，小於則交換位置，大於則位置不動

function insertSort(arr){
    var
 
 tmp;
    for(var i=1;i<arr.length;i++){
        tmp  = arr[i];
        for(var j=i;j>=0;j--){
            if(arr[j-1]>tmp){
                arr[j]=arr[j-1];
            }else{
                arr[j]=tmp;
                break;
            }
        }
    }
    return arr
}

時間複雜度O(n^2)

選擇排序

演算法描述：直接從待排序陣列中選擇一個最小（或最大）數字，放入新陣列中。

[1] 5 6 3  8 7 2 4 
[1,2] 5 6 3  8 7  4 
[1,2,3] 5 6  8 7 2 4 
[1,2,3,4] 5 6 8 7
[1,2,3,4,5] 6  8 7 
[1,2,3,4,5,6] 8 7  
[1,2,3,4,5,6,7] 8  
[1,2,3,4,5,6,7,8] 

程式設計思路：先假設第一個元素為最小的，然後通過迴圈找出最小元素，然後同第一個元素交換，接著假設第二個元素，重複上述操作即可

function selectSort(array) {
  var length = array.length,
      i,
      j,
      minIndex,
      minValue,
      temp;
  for (i = 0; i < length - 1; i++) {
    minIndex = i;
    minValue = array[minIndex];
    for (j = i + 1; j < length; j++) {//通過迴圈選出最小的
      if (array[j] < minValue) {
        minIndex = j;
        minValue = array[minIndex];
      }
    }
    // 交換位置
    temp = array[i];
    array[i] = minValue;
    array[minIndex] = temp;
  }
  return array
}

時間複雜度O(n^2)

歸併排序

演算法描述：
1. 把 n 個記錄看成 n 個長度為 l 的有序子表
2. 進行兩兩歸併使記錄關鍵字有序，得到 n/2 個長度為 2 的有序子表
3. 重複第 2 步直到所有記錄歸併成一個長度為 n 的有序表為止。

5 6 3 1 8 7 2 4

[5,6] [3,1] [8,7] [2,4]

[5,6] [1,3] [7,8] [2,4]

[5,6,1,3] [7,8,2,4]

[1,3,5,6] [2,4,7,8]

[1,2,3,4,5,6,7,8]

程式設計思路：將陣列一直等分，然後合併

function merge(left, right) {
  var tmp = [];

  while (left.length && right.length) {
    if (left[0] < right[0])
      tmp.push(left.shift());
    else
      tmp.push(right.shift());
  }

  return tmp.concat(left, right);
}

function mergeSort(a) {
  if (a.length === 1) 
    return a;

  var mid = Math.floor(a.length / 2)
    , left = a.slice(0, mid)
    , right = a.slice(mid);

  return merge(mergeSort(left), mergeSort(right));
}

時間複雜度O(nlogn)

快速排序

演算法描述：

1. 在資料集之中，選擇一個元素作為”基準”（pivot）。
2. 所有小於”基準”的元素，都移到”基準”的左邊；所有大於”基準”的元素，都移到”基準”的右邊。這個操作稱為分割槽 (partition)操作，分割槽操作結束後，基準元素所處的位置就是最終排序後它的位置。
3. 對”基準”左邊和右邊的兩個子集，不斷重複第一步和第二步，直到所有子集只剩下一個元素為止。

5 6 3 1 8 7 2 4

pivot
|
5 6 3 1 9 7 2 4
|
storeIndex

5 6 3 1 9 7 2 4//將5同6比較，大於則不更換
|
storeIndex

3 6 5 1 9 7 2 4//將5同3比較，小於則更換
  |
  storeIndex

3 6 1 5 9 7 2 4//將5同1比較，小於則不更換
    |
   storeIndex
...

3 6 1 4 9 7 2 5//將5同4比較，小於則更換
      |
      storeIndex

3 6 1 4 5 7 2 9//將標準元素放到正確位置
      |
storeIndex pivot

上述講解了分割槽的過程，然後就是對每個子區進行同樣做法

function quickSort(arr){
    if(arr.length<=1) return arr;
    var partitionIndex=Math.floor(arr.length/2);
    var tmp=arr[partitionIndex];
    var left=[];
    var right=[];
    for(var i=0;i<arr.length;i++){
        if(arr[i]<tmp){
            left.push(arr[i])
        }else{
            right.push(arr[i])
        }
    }
    return quickSort(left).concat([tmp],quickSort(right))
}

上述版本會造成堆疊溢位，所以建議使用下面版本

原地分割槽版：主要區別在於先進行分割槽處理，將陣列分為左小右大

function quickSort(arr){
    function swap(arr,right,left){
        var tmp = arr[right];
        arr[right]=arr[left];
        arr[left]=tmp;
    }
    function partition(arr,left,right){//分割槽操作，
        var pivotValue=arr[right]//最右面設為標準
        var storeIndex=left;
        for(var i=left;i<right;i++){
            if(arr[i]<=pivotValue){
                swap(arr,storeIndex,i);
                storeIndex++;
            }
        }
        swap(arr,right,storeIndex);
        return storeIndex//返回標杆元素的索引值
    }
    function sort(arr,left,right){
        if(left>right) return;
        var storeIndex=partition(arr,left,right);
        sort(arr,left,storeIndex-1);
        sort(arr,storeIndex+1,right);
    }
    sort(arr,0,arr.length-1);
    return arr;
}

時間複雜度O(nlogn)

氣泡排序

演算法描述：
1. 比較相鄰的元素。如果第一個比第二個大，就交換他們兩個。
2. 對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最後一對。在這一點，最後的元素應該會是最大的數。
3. 針對所有的元素重複以上的步驟，除了最後一個。
4. 持續每次對越來越少的元素重複上面的步驟，直到沒有任何一對數字需要比較。5.

5 6 3 1 8 7 2 4

[5 6] 3 1 8 7 2 4 //比較5和6

5 [6 3] 1 8 7 2 4

5 3 [6 1] 8 7 2 4

5 3 1 [6 8] 7 2 4

5 3 1 6 [8 7] 2 4

5 3 1 6 7 [8 2] 4

5 3 1 6 7 2 [8 4]

5 3 1 6 7 2 4 8  // 這樣最後一個元素已經在正確位置，所以下一次開始時候就不需要再比較最後一個

程式設計思路：外迴圈控制需要比較的元素，比如第一次排序後，最後一個元素就不需要比較了，內迴圈則負責兩兩元素比較，將元素放到正確位置上

function bubbleSort(arr){
    var len=arr.length;
    for(var i=len-1;i>0;i--){
        for(var j=0;j<i;j++){
            if(arr[j]>arr[j+1]){
                var tmp = arr[j];
                arr[j]=arr[j+1];
                arr[j+1]=tmp
            }
        }
    }
    return arr;
}

時間複雜度O(n^2)

參考資料

歡迎訂閱[]和知乎專欄