JavaScript中幾種排序演算法的簡單實作_基礎知識

排序演算法的實作

我的JS等級就是渣渣，所以我就用類似JAVA和C的方式來寫JavaScript的排序演算法了。

而且這裡我不講演算法原理，只是程式碼實現，可能會有Bug，歡迎大家部落格評論指導。
插入排序

插入排序（Insertion-Sort）的演算法描述是一種簡單直覺的排序演算法。它的工作原理是透過建立有序序列，對於未排序數據，在已排序序列中從後向前掃描，找到相應位置並插入。插入排序在實作上，通常採用in-place排序（即只需用到O(1)的額外空間的排序），因而在從後向前掃描過程中，需要反覆把已排序元素逐步向後挪位，為最新元素提供插入空間。

實作程式碼如下：

function insertSort(arr) {
  if (!arr) return;
  var len = arr.length;
  if (len == 0 || len == 1) return;

  for (var i = 1, len = arr.length; i < len; i ++) {
    var stand = arr[i];
    for (var j = i - 1; j >= 0; j --) {
      if (arr[j] > stand) {
        arr[j + 1] = arr[j];
      } else {
        arr[j + 1] = stand;
        break;
      }
    }
  }

  return arr;
}

 

時間複雜度為：O(n^2)

當然，該演算法是有最佳化餘地的，例如將搜尋替換的位置演算法改為二分查找。
冒泡排序

經典的排序演算法，提到冒泡排序我就心痛。本科時候的必須論文的冒泡排序演算法的改進，結果寫完論文之後都不能完整的實現冒泡排序演算法，好尷尬。

  if (!arr) return;
  var len = arr.length;
  if (len == 0 || len == 1) return;

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

  return arr;
}

時間複雜度為：O(n^2)
快速排序

非常經典的排序演算法，排序過程主要i分為三步：

1.     從數列中挑出一個元素，稱為 「基準」(pivot);
2.     重新排序數列，所有元素比基準值小的擺放在基準前面，所有元素比基準值大的擺在基準的後面（相同的數可以到任一邊）。在這個分區退出之後，該基準就處於數列的中間位置。這個稱為分區（partition）操作；
3.     遞歸地（recursive）將小於基準值元素的子數列和大於基準值元素的子數列排序。

實作程式碼如下：

function quickSort(arr, bt, ed) {
  if (bt < ed) {
    var pivot = findPartition(arr, bt, ed);
    quickSort(arr, bt, pivot - 1);
    quickSort(arr, pivot + 1, ed);
  }
}

function findPartition(arr, bt, ed) {
  var stand = arr[bt];

  while (bt < ed) {
    while (bt < ed && arr[ed] >= stand) {
      ed --;
    }
    if (bt < ed) {
      arr[bt ++] = arr[ed];
    }
    while (bt < ed && arr[bt] <= stand) {
      bt ++;
    }
    if (bt < ed) {
      arr[ed --] = arr[bt]; 
    }
  }

  arr[bt] = stand;
  return bt;
}

時間複雜度為：O(nlogn)。
歸併排序

也是非常經典的排序演算法，我就是藉著學習js的機會複習經典的排序演算法了。歸併排序的想法可以參考我的這篇部落格：歸併排序。我這裡只寫js實作。

function mergeSort(arr, bt, ed) {
  if (bt < ed) {
    var mid = bt + parseInt((ed - bt) / 2);
    mergeSort(arr, bt, mid);
    mergeSort(arr, mid + 1, ed);
    mergeArray(arr, bt, mid, ed);    
  }
}

function mergeArray(arr, bt, mid, ed) {
  var mArr = [];
  var i = bt, j = mid + 1;
  while (i <= mid && j <= ed) {
    if (arr[i] <= arr[j]) {
      mArr.push(arr[i++]);
    } else {
      mArr.push(arr[j ++]);
    }
  }

  if (i <= mid) {
    mArr = mArr.concat(arr.slice(i, mid + 1));
  }

  if (j <= ed) {
    mArr = mArr.concat(arr.slice(j, ed + 1));
  }

  for (var h = 0; h < mArr.length; h ++) {
    arr[bt + h] = mArr[h];
  }
}

寫歸排序的時候還有一個小插曲：就是js不能自動取整，後來用了parseInt方法，感覺萌萌大。