算法小白——基本排序算法入門

計算的 時間複雜度（最差、平均、和最好性能），依據列表（list）的大小(n)。通常而言，好的性能是O(n log n)，且壞的性能是O(n^2)。對於一個排序理想的性能是O(n)。僅使用一個抽象關鍵比較運算的排序算法總平均上老是至少須要O(n log n)。

插入排序(insertion sort)

插入排序應該算是最簡單和容易理解的排序算法。它的工做原理是經過構建有序序列，對於未排序數據，在已排序序列中從後向前掃描，找到相應位置並插入。具備n個元素時它須要通過n-1趟排序。對於p = 1到p = n-1趟，插入排序保證從位置0到位置p上的元素爲已排序狀態。它就是基於這個事實來排序的。

function sort(arr) {
  if(arr.length <= 1) {
    return arr
  }

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

  return arr
}

若是目標是把n個元素的序列升序排列，那麼採用插入排序存在最好狀況和最壞狀況。最好狀況就是，序列已是升序排列了，在這種狀況下，須要進行的比較操做需(n-1)次便可。最壞狀況就是，序列是降序排列，那麼此時須要進行的比較共有n(n-1)/2次。插入排序的賦值操做是比較操做的次數減去(n-1)次。平均來講插入排序算法複雜度爲O(n^2)。於是，插入排序不適合對於數據量比較大的排序應用。可是，若是須要排序的數據量很小，例如，量級小於千，那麼插入排序仍是一個不錯的選擇。 插入排序在工業級庫中也有着普遍的應用，在STL的sort算法和stdlib的qsort算法中，都將插入排序做爲快速排序的補充，用於少許元素的排序（一般爲8個或如下）

冒泡排序(bubble sort)

冒泡排序是與插入排序擁有相等的運行時間，可是兩種算法在須要的交換次數卻很大地不一樣。在最好的狀況，冒泡排序須要O(n^2)次交換，而插入排序只要最多O(n)交換。冒泡排序的實現（相似下面）一般會對已經排序好的數列拙劣地運行O(n^2)，而插入排序在這個例子只須要O(n)個運算。所以不少現代的算法教科書避免使用冒泡排序，而用插入排序替換之。冒泡排序若是能在內部循環第一次運行時，使用一個旗標來表示有無須要交換的可能，也能夠把最好的複雜度下降到O(n)。在這個狀況，已經排序好的數列就無交換的須要。若在每次走訪數列時，把走訪順序反過來，也能夠稍微地改進效率。有時候稱爲雞尾酒排序，由於算法會從數列的一端到另外一端之間穿梭往返。

冒泡排序算法的運做以下：

• 比較相鄰的元素。若是第一個比第二個大，就交換他們兩個。

• 對每一對相鄰元素做一樣的工做，從開始第一對到結尾的最後一對。這步作完後，最後的元素會是最大的數。

• 針對全部的元素重複以上的步驟，除了最後一個。

• 持續每次對愈來愈少的元素重複上面的步驟，直到沒有任何一對數字須要比較。

因爲它的簡潔，冒泡排序一般被用來對於程序設計入門的學生介紹算法的概念。

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

  return arr;
}

選擇排序(selection sort)

選擇排序（Selection sort）是一種簡單直觀的排序算法。它的工做原理以下。首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，而後，再從剩餘未排序元素中繼續尋找最小（大）元素，而後放到已排序序列的末尾。以此類推，直到全部元素均排序完畢。
選擇排序的主要優勢與數據移動有關。若是某個元素位於正確的最終位置上，則它不會被移動。選擇排序每次交換一對元素，它們當中至少有一個將被移到其最終位置上，所以對n個元素的表進行排序總共進行至多n-1次交換。在全部的徹底依靠交換去移動元素的排序方法中，選擇排序屬於很是好的一種。

複雜度分析

選擇排序的交換操做介於 0 和(n-1)次之間。選擇排序的比較操做爲n(n-1)/2次之間。選擇排序的賦值操做介於0和3(n-1)次之間。比較次數O(n^2)，比較次數與關鍵字的初始狀態無關，總的比較次數 N=(n-1)+(n-2)+...+1=n(n-1)/2。交換次數O(n),最好狀況是，已經有序，交換0次；最壞狀況是，逆序，交換n-1次。交換次數比冒泡排序較少，因爲交換所需CPU時間比比較所需的CPU時間多, n值較小時，選擇排序比冒泡排序快。
原地操做幾乎是選擇排序的惟一優勢，當空間複雜度要求較高時，能夠考慮選擇排序；實際適用的場合很是罕見。

function selectionSort(arr) {
    if(arr.length <= 1) {
        return arr
    }
    var i, j, min;
    var temp;
    for (i = 0; i < arr.length - 1; i++) {
        min = i;
        for (j = i + 1; j < arr.length; j++) {
            if (arr[min] > arr[j])
                min = j;
                temp = arr[min];
                arr[min] = arr[i];
                arr[i] = temp;
        }
    }
    return arr
}

快速排序(quick sort)

快速排序使用分治法（Divide and conquer）策略來把一個序列（list）分爲兩個子序列（sub-lists）。

步驟爲：

1. 從數列中挑出一個元素，稱爲"基準"（pivot），

2. 從新排序數列，全部元素比基準值小的擺放在基準前面，全部元素比基準值大的擺在基準的後面（相同的數能夠到任一邊）。在這個分區結束以後，該基準就處於數列的中間位置。這個稱爲分區（partition）操做。

3. 遞歸地（recursive）把小於基準值元素的子數列和大於基準值元素的子數列排序。
   遞歸的最底部情形，是數列的大小是零或一，也就是永遠都已經被排序好了。雖然一直遞歸下去，可是這個算法總會結束，由於在每次的迭代（iteration）中，它至少會把一個元素擺到它最後的位置去。

正如它的名字，快速排序是在時間中最快的已知排序算法，它的平均運行時間是O(NlogN)。快速排序也是一種分治的遞歸算法。將數組S排序的基本算法由下列簡單的四步組成：

1. 若是S中元素個數是0或1，則返回

2. 取S中任一元素v，稱之爲樞紐元

3. 將S - {v}分紅兩個不相交的集合：S1 = {x∈S - {v} | x ≤ v}和S2 = {x∈S - {v} | x ≥ v}

4. 返回{quicksort(S1)}，繼續v，繼而quicksort(S2)
   因爲對樞紐元的處理會致使第三步中的分割不惟一，所以，咱們但願把等於樞紐元的大約一半的關鍵字分到S1中，而另一半分到S2中，那怎麼去選擇一個好的樞紐元呢？

選取樞紐元
一種錯誤的方法
一般的，沒有通過充分考慮的選擇是將第一個元素用做樞紐元。若是輸入是隨機的，那麼這是能夠接受的，可是若是輸入是預排序或是反序的，那麼這樣的樞紐元就會產生一個劣質的分割，由於全部的元素不是都被劃入S1就是被劃入S2。
一種安全的做法
一種安全的方針是隨機選取樞紐元。可是另外一方面，隨機數的生成通常是昂貴的，根本減小不了算法奇遇部分的平均運行時間。
三數中值分割法
一組N個數的中值是第Math.ceil(N/2)個最大的數。樞紐元的最好的選擇是數組的中值。不幸的是，這很難算出，且會減慢快速排序的速度。所以通常的作法是使用左端、右端和中心位置上的三個元素的中值做爲樞紐元。例如，輸入爲8, 1, 4, 9, 6, 3, 5, 2, 7, 0，它的左邊元素是8，右邊元素是0，中心位置爲Math.floor((left + right) / 2)上的元素是6，因而樞紐元v=6。

function quickSort(arr) {
  if (arr.length <= 1) {
    return arr.slice(0);
  }

  var left = [];
  var right = [];
  var mid = [arr[0]]; //first number as a pivot

  for (var i = 1; i < arr.length; i++) {
    if (arr[i] < mid[0]) {
      left.push(arr[i]);
    } else {
      right.push(arr[i]);
    }
  }

  return quickSort(left).concat(mid.concat(quickSort(right)));
}