js排序算法總結——冒泡，快速，選擇，插入，希爾，歸併

相信排序是任何一個程序猿都會用到的東西，今天簡單總結記錄下常見的排序算法。

 

一.冒泡排序

     提及冒泡排序，可能每一個人都不會陌生，實現思路至關簡單明瞭，就是不停的對數組進行兩兩比較，將較大（較小）的一項放在前面；

     如 var arr = [7, 3, 10, 1, 8, 4, 2, 4, 4, 3] 進行升序排列,排序過程以下

     第一次 [3, 7, 1, 8, 4, 2, 4, 4, 3, 10]

     第二次 [3, 1, 7, 4, 2, 4, 4, 3, 8, 10]

     以此類推 。。。。

     結果 [1, 2, 3, 3, 4, 4, 4, 7, 8, 10]；

//冒泡排序
function bubbleSort(arr){
  var len = arr.length,t
  for(j=0;j<=len-1;j++){
      for(i=0;i<=len-j-1;i++){
          if(arr[i]>arr[i+1]){
             t = arr[i+1];
             arr[i+1] = arr[i];
             arr[i] = t;     
          }    
      }
  }
  return arr;
}

 

二.快速排序

      快速排序也是咱們經常使用到的一種排序方式，核心步驟以下

          1.選擇中間數。

          2.構建兩個臨時數組，比中間數小的放到左邊，大的放到右邊

          3.對臨時數組重複1-2；

     例如，咱們原始數組爲[2,4,1,5,6,3,12,9,7]，第一步咱們選擇第5項 6 爲中間數，建立臨時數組left，right，則left 結果爲[2,4,1,5,3],right 結果爲 [12,9,7]。而後再分別對left和right進行相同的操做，直至left及right數組長度爲1.

具體代碼以下：

//快速排序
function quickSort(arr){
    if(arr.length <= 1){   //數組長度爲1時，則中止遞歸
        return arr    
    }
    var l = Math.floor(arr.length/2);  //選擇中間數
    var left = [],right=[];
    var splitEle = arr.splice(l,1)[0]  //將中間數從原數組刪除並保存
    for(i=0;i<arr.length;i++){
        if(arr[i] < splitEle){
            left.push(arr[i])
        }else{
            right.push(arr[i])
        }
    }
    return arguments.callee(left).concat(splitEle,arguments.callee(right))
}

 

 

三.選擇排序

      選擇排序核心思想以下：

      加入咱們進行升序排列，咱們假設數組第一項爲最小值，而後將第一項與其餘項分別比較，若是其餘項小於第一項，則交換位置，這樣第一次循環結束咱們能夠保證第一項爲最小值。而後第二項作相似操做，而後以此類推，具體以下圖所示

     

      代碼以下：

//選擇排序
function selectQuot(arr){
    for(i=0; i<arr.length-1; i++){
        for(j=i+1;j<arr.length;j++){
            if(arr[i] > arr[j]){
                var temp;
                temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
    }
    return arr
}

 

四.插入排序

      插入排序很好理解，首先咱們取出第一項放入一個虛構的數組，而後取第二項，假如第二項小於第一項，則將第二項放於第一項的前面，不然放在後面；而後取第三項，分別與前兩項進行比較（是否是有點兒相似打撲克牌~~）

     如咱們的數組爲[2, 4, 1, 5, 3, 8 ,7 ,9 , 6]；

     假定咱們有一個虛擬數組，則第一步數組爲[2],而後咱們取數組的第二項，發現要比剛纔取得數組項大，則咱們放在後面即虛擬數組變成[2,4]，而後取下一項與虛擬數組中的項分別比較，按上述思路結果爲[1,2,4],以此類推……固然在實際編程中咱們並不須要單首創建數組。

     代碼以下：

//插入排序
function insertSort(arr){
    for(i=1 ; i<arr.length ; i++ ){
        var temp =  arr[i],
            j = i - 1;
        while(j>=0 && temp < arr[j]){
            arr[j+1] = arr[j];   //至關於將虛擬數組當前項後移一位，同時虛擬數組長度+1
            j--;
        }
        arr[j+1] = temp; //新加項最終插入的位置
    }
    return arr;
}

 

五.希爾排序

      希爾排序是插入排序的升級版，又稱爲縮小增量排序。

      對於插入排序算法來講，若是原來的數據就是有序的，那麼數據就不須要移動，基於此，希爾排序首先將數組按照必定間隔分爲若干個小數組分別進行插入排序，而後逐漸減少間隔，直至爲1，這樣最後一次處理即間隔爲1的排序，但因爲以前的操做後數組基本變爲有序數組，這樣就能提升些效率。示意以下：

      咱們原始數組爲[3, 4, 6, 5, 1, 9, 6, 10, 8, 8]

      第一步咱們假設增量爲3，按照希爾排序思路咱們將數組以下分割

      

     咱們每一次將一樣的分組賦予同一顏色，而後對每一分組進行插入排序，空白顏色爲結果。

     實現代碼以下：

//希爾排序
function shellSort(array) {
    var len = array.length;
    var gap = len;
    do {
        gap = Math.floor(gap/3)+1; // 減少增量
        // 把距離爲gap的元素編爲一個組，掃描全部組
        for (var i = gap; i < len; i++) {
           var  temp = array[i],
                j = i - gap;
           while(j>=0 && temp < array[j]){
               array[j + gap] = array[j];
               j -= gap;
           }
           array[j+gap] = temp; 
        }
    }while(gap > 1)
    return array
}

 

六.歸併排序

      歸併排序的核心思想是，首先將數組分紅若干個子數組變成有序數組，再合併有序數組。

      具體流程盜用網絡上一張圖，一看便知

      代碼以下：

var mergeSort = {
    splitArr : function(arr){
        if(arr.length == 1) return arr;
        var mid = Math.floor(arr.length/2),
            left = arr.slice(0,mid),
            right = arr.slice(mid);
        return this.merge(this.splitArr(left),this.splitArr(right))
    },
    merge : function(left , right){
        var result = [];
        while(left.length > 0 && right.length > 0){
            if(left[0] < right[0]){
                result.push(left.shift())
            }else{
                result.push(right.shift())
            }    
        }
        return result.concat(left).concat(right)
    }
}

      若是您以爲文章對您有幫助，請幫忙點擊右下角的推薦，文中不足之處也歡迎指出以便及時改正