排序算法——javascript算法實現

排序 Sorting

排序基本概念

排序是計算機程序設計中的一種重要操作，他的功能是將一個數據元素(或記錄)的任意排列，重新排列成一個按關鍵字有序的序列。
待排序的記錄序列中可能存在兩個或兩個以上的關鍵字相等的記錄，且在排序前Ri在Rj前面(即i

插入排序

直接插入排序 O(n2)

最爲簡單的一種排序，基本操作爲將一個記錄插入到已經排好序的有序表中，從而得到一個新的，記錄增1的有序表。

//直接插入排序，更爲高效的應該是折半插入排序¬≥
function insertSort (Arr) {
  if (Arr.length <= 1) {
    return Arr;
  }
  var temp;

  for (var i = 1; i < Arr.length; i++) { //從1開始，第一個不用排序
    temp = Arr[i]; //用temp緩存待插入的元素
    for (var j = i; j >= 0; j--) {
      if (temp < Arr[j]) {
        Arr[j + 1] = Arr[j]; //當Arr[i]<Arr[j],則將Arr[j]往後移一位
      } else if (temp > Arr[j]) {
        break; //第一種：如果找到了一個比Arr[i]小的Arr[j],則退出循環，結束
      }
      //第二種，當j循環，結束
    }
    //結束j循環，將temp中緩存的待插入元素插入
    Arr[j + 1] = temp;
  }

}; //insert結束

其他插入排序

1. 折半插入排序 O(n2) 通過減少比較關鍵字大小次數來優化排序算法。
2. 2路插入排序
3. 表插入排序

希爾排序 O(n3/2)

又被稱爲”縮小增量排序”。基本思想：先將整個待排記錄序列分割成若干個子序列分別進行直接插入排序，待整個序列中的記錄
“基本有序”時，再對全體記錄進行一次直接插入排序。

function shellSort(Arr) {
  var gap = Math.floor(Arr.length / 2);
  while (gap > 0) {
    for (var i = 0; i < Arr.length; i++) {
      var temp = Arr[i];
      for (var j = i; j >= gap && Arr[j - gap] > temp; j -= gap) {
        Arr[j] = Arr[j - gap];
      }
      Arr[j] = temp;
    }
    gap = Math.floor(gap / 2);
  }
  return Arr;
}; //shell結束

快速排序

起泡排序 bubble sort

// 起泡排序,
function bibbleSort(Arr) {
  for (var i = Arr.length - 1; i >= 0; i--) {
    for (var j = 0; j < i; j++) {
      if (Arr[j] > Arr[j + 1]) {
        swap(j, j + 1, Arr);
      }
    }
  }
  return Arr;
};

快速排序 quick sort

// 一趟快速排序的算法是
// 1.設置初始值x=0,y=n-1,令keyValuey=Arr[0],2.從Arr[y]開始向前遍歷，如果keyValue>Arr[y],則將Arr[i]和Arr[y]交換，3.從Arr[x]向後遍歷，當keyValue<Arr[x]時；進行Arr[i]和Arr[y]交換，4.結束條件爲x==y;

function quickSort (Arr) {
  if (Arr.length <= 1) {
    return Arr;
  }
  var pivotIndex = Math.floor(Arr.length / 2);
  var pivot = Arr.splice(pivotIndex, 1);
  var leftArr = [];
  var rightArr = [];
  for (var i = 0; i < Arr.length; i++) {
    if (Arr[i] < pivot) {
      leftArr.push(Arr[i]);
    } else {
      rightArr.push(Arr[i]);
    }
  }
  return quickSort(leftArr).concat(pivot, quickSort(rightArr));
  //quickSortOnce結束
}; //quick結束

選擇排序

簡單的選擇排序

//選擇排序 從待排序的數組中找出最小值放在最前面
function selectSort(Arr) {
  for (var i = 0; i < Arr.length; i++) {
    for (var j = i; j < Arr.length; j++) {
      if (Arr[i] > Arr[j]) {
        swap(Arr, i, j);
      }
    }
  }
  return Arr;
}; //select結束

樹形選擇排序

留

堆排序 heap sort

留！！！

歸併排序 merging sort O(m+n)

假設初始序列含義n個記錄，則可以看成是n個有序的子序列，每個子序列的長度爲1,然後兩兩歸併，等到Math.floor(n/2)個長度爲2或1的有序子序列，再兩兩歸併，如此重複，直至得到一個長度爲n的有序序列爲止。

function mergeSort (){
    var merge=function(left,right){
        var final=[];
        while(left.length&&right.length){
            final.push(left[0]<=right[0]?left.shift():right.shift());
        }
        return final.concat(left.concat(right));
    };

    var len=this.length;
    if(len<2){
        return this;
    }

    var mid=parseInt(len/2),
        _left=this.slice(0,mid),
        _right=this.slice(mid);
    return merge(_left.mergeSort(),_right.mergeSort());
};

基數排序 radix Sorting

留

各種排序算法比較

以上用到的swap函數

//swap函數
function swap(Arr, firPos, secPos) {
  var temp = Arr[firPos];
  Arr[firPos] = Arr[secPos];
  Arr[secPos] = temp;
  return Arr; //返回生成的數組
} //swap結束