1 快速排序（QuickSort）
快速排序是一個就地排序，分而治之，大規模遞歸的算法。從本質上來說，它是歸並排序的就地版本。快速排序可以由下面四步組成。
（1） 如果不多於1個數據，直接返回。
（2） 一般選擇序列最左邊的值作為支點數據。
（3） 將序列分成2部分，一部分都大於支點數據，另外一部分都小於支點數據。
（4） 對兩邊利用遞歸排序數列。
快速排序比大部分排序算法都要快。盡管我們可以在某些特殊的情況下寫出比快速排序快的算法，但是就通常情況而言，沒有比它更快的了。快速排序是遞歸的，對於內存非常有限的機器來說，它不是一個好的選擇。
2 歸並排序（MergeSort）
歸並排序先分解要排序的序列，從1分成2，2分成4，依次分解，當分解到只有1個一組的時候，就可以排序這些分組，然后依次合並回原來的序列中，這樣就可以排序所有數據。合並排序比堆排序稍微快一點，但是需要比堆排序多一倍的內存空間，因為它需要一個額外的數組。
3 堆排序（HeapSort）
堆排序適合於數據量非常大的場合（百萬數據）。
堆排序不需要大量的遞歸或者多維的暫存數組。這對於數據量非常巨大的序列是合適的。比如超過數百萬條記錄，因為快速排序，歸並排序都使用遞歸來設計算法，在數據量非常大的時候，可能會發生堆棧溢出錯誤。
堆排序會將所有的數據建成一個堆，最大的數據在堆頂，然后將堆頂數據和序列的最后一個數據交換。接下來再次重建堆，交換數據，依次下去，就可以排序所有的數據。
4 Shell排序（ShellSort）
Shell排序通過將數據分成不同的組，先對每一組進行排序，然后再對所有的元素進行一次插入排序，以減少數據交換和移動的次數。平均效率是O(nlogn)。其中分組的合理性會對算法產生重要的影響。現在多用D.E.Knuth的分組方法。
Shell排序比冒泡排序快5倍，比插入排序大致快2倍。Shell排序比起QuickSort，MergeSort，HeapSort慢很多。但是它相對比較簡單，它適合於數據量在5000以下並且速度並不是特別重要的場合。它對於數據量較小的數列重復排序是非常好的。
5 插入排序（InsertSort）
插入排序通過把序列中的值插入一個已經排序好的序列中，直到該序列的結束。插入排序是對冒泡排序的改進。它比冒泡排序快2倍。一般不用在數據大於1000的場合下使用插入排序，或者重復排序超過200數據項的序列。
6 冒泡排序（BubbleSort）
冒泡排序是最慢的排序算法。在實際運用中它是效率最低的算法。它通過一趟又一趟地比較數組中的每一個元素，使較大的數據下沉，較小的數據上升。它是O(n^2)的算法。
7 交換排序（ExchangeSort）和選擇排序（SelectSort）
這兩種排序方法都是交換方法的排序算法，效率都是 O(n2)。在實際應用中處於和冒泡排序基本相同的地位。它們只是排序算法發展的初級階段，在實際中使用較少。
8 基數排序（RadixSort）
基數排序和通常的排序算法並不走同樣的路線。它是一種比較新穎的算法，但是它只能用於整數的排序，如果我們要把同樣的辦法運用到浮點數上，我們必須了解浮點數的存儲格式，並通過特殊的方式將浮點數映射到整數上，然后再映射回去，這是非常麻煩的事情，因此，它的使用同樣也不多。而且，最重要的是，這樣算法也需要較多的存儲空間。
9 總結
下面是一個總的表格，大致總結了我們常見的所有的排序算法的特點。
| 排序法 | 平均時間 | 最小時間 | 最大時間 | 穩定度 | 額外空間 | 備注 |
| 冒泡排序 | O(n2) | O(n) | O(n2) | 穩定 | O(1) | n小時較好 |
| 選擇排序 | O(n2) | O(n2) | O(n2) | 不穩定 | O(1) | n小時較好 |
| 插入排序 | O(n2) | O(n) | O(n2) | 穩定 | O(1) | 大部分已排序時較好 |
| 基數排序 | O(logRB) | O(n) | O(logRB) | 穩定 | O(n) | B是真數(0-9)， R是基數(個十百) |
| Shell排序 | O(nlogn) | - | O(ns) 1<s<2 | 不穩定 | O(1) | s是所選分組 |
| 快速排序 | O(nlogn) | O(n2) | O(n2) | 不穩定 | O(logn) | n大時較好 |
| 歸並排序 | O(nlogn) | O(nlogn) | O(nlogn) | 穩定 | O(n) | 要求穩定性時較好 |
| 堆排序 | O(nlogn) | O(nlogn) | O(nlogn) | 不穩定 | O(1) | n大時較好 |
參考原帖：http://blog.csdn.net/yuzhihui_no1/article/details/44198701
注：原帖中的表格有誤，快排空間復雜度為logN，歸排的空間復雜度為O(N)，本文已糾正。
附上Java實現：
package com.algorithms;
import java.util.Arrays;
import java.util.Collections;
import java.util.Random;
/**
* 各種排序的基本解決方案。
*
* @author Shixiang Wan (shixiangwan@gmail.com)
* @version 1.0
* */
public class LearnSort {
public static void main(String[] args)
{
int N = 50000;
Integer[] a = new Integer[N];
Random random = new Random();
for (int i=0; i<N; i++)
a[i] = random.nextInt(N);
SortFactory sortFactory = new SortFactory();
Collections.shuffle(Arrays.asList(a));
Long start = System.currentTimeMillis();
Arrays.sort(a);
assert sortFactory.isSorted(a);
System.out.println(">> 快排API:" + (System.currentTimeMillis() - start) + "ms");
Collections.shuffle(Arrays.asList(a));
start = System.currentTimeMillis();
sortFactory.sort_quick(a);
assert sortFactory.isSorted(a);
System.out.println(">> 快速排序:" + (System.currentTimeMillis() - start) + "ms");
Collections.shuffle(Arrays.asList(a));
start = System.currentTimeMillis();
sortFactory.sort_heap(a);
assert sortFactory.isSorted(a);
System.out.println(">> 堆排序:" + (System.currentTimeMillis() - start) + "ms");
Collections.shuffle(Arrays.asList(a));
start = System.currentTimeMillis();
sortFactory.sort_merge(a);
assert sortFactory.isSorted(a);
System.out.println(">> 歸並排序:" + (System.currentTimeMillis() - start) + "ms");
Collections.shuffle(Arrays.asList(a));
start = System.currentTimeMillis();
sortFactory.sort_selection(a);
assert sortFactory.isSorted(a);
System.out.println(">> 選擇排序:" + (System.currentTimeMillis() - start) + "ms");
Collections.shuffle(Arrays.asList(a));
start = System.currentTimeMillis();
sortFactory.sort_insertion(a);
assert sortFactory.isSorted(a);
System.out.println(">> 插入排序:" + (System.currentTimeMillis() - start) + "ms");
}
}
class SortFactory {
/*
* 堆排序
* 唯一能夠同時最優地利用空間和時間的方法，在嵌入式系統或低成本的移動設備中很流行
* 但是現代系統的許多應用很少使用它，因為它無法利用緩存。數組元素很少和相鄰的其他
* 元素進行比較，因此緩存命中的次數要遠遠高於大多數比較都在相鄰元素間進行的算法，
* 如快速排序，歸並排序甚至是希爾排序。但用堆實現的優先隊列卻越來越重要。因為它能在
* 插入操作、刪除最大元素操作混合的動態場景中保證對數級別的運行時間。
* */
public void sort_heap(Comparable[] a) {
int N = a.length;
for (int k = N/2; k >= 1; k--) {
sink(a, k, N);
}
while (N > 1) {
exch(a, 0, N-- - 1); // 算法第4版未考慮減1
sink(a, 1, N);
}
}
//由上到下的堆有序化（下沉）的實現
private void sink(Comparable[] a, int k, int N) {
while (2*k <= N) {
int j = 2*k;
if (j < N && less(a[j-1], a[j])) j++; // 算法第4版未考慮減1
if (!less(a[k-1], a[j-1])) break; // 算法第4版未考慮減1
exch(a, k-1, j-1); // 算法第4版未考慮減1
k = j;
}
}
/*歸並排序
* 時間復雜度與快速排序相同
* */
private Comparable[] aux;
public void sort_merge(Comparable[] a) {
aux = new Comparable[a.length];
sort(a, 0, a.length - 1);
}
private void sort(Comparable[] a, int lo, int hi) {
if (hi <= lo) return;
int mid = lo + (hi - lo) / 2;
sort(a, lo, mid); //將左半邊排序
sort(a, mid+1, hi); //將右半邊排序
merge(a, lo, mid, hi);
}
private void merge(Comparable[] a, int lo, int mid, int hi)
{
// 原地歸並，a數組在mid的左右兩側各自已經排好序，這里將左右合並
int i = lo, j = mid+1;
for (int k = lo; k <= hi; k++)
aux[k] = a[k];
for (int k = lo; k <= hi; k++)
if (i > mid)
a[k] = aux[j++];
else if (j > hi)
a[k] = aux[i++];
else if (less(aux[j], aux[i]))
a[k] = aux[j++];
else
a[k] = aux[i++];
}
/*快速排序*/
public void sort_quick(Comparable[] a)
{
Collections.shuffle(Arrays.asList(a));
sort_quick(a, 0, a.length - 1);
}
public void sort_quick(Comparable[] a, int lo, int hi)
{
if (hi <= lo) return;
int j = partition(a, lo, hi);
sort_quick(a, lo, j-1);
sort_quick(a, j+1, hi);
}
public int partition(Comparable[] a, int lo, int hi)
{
int i=lo, j=hi+1;
Comparable v = a[lo];
while (true)
{
while (less(a[++i], v)) if (i == hi) break;
while (less(v, a[--j])) if (j == lo) break;
if (i >= j) break;
exch(a, i, j);
}
exch(a, lo, j);
return j;
}
/*插入排序
* 插入排序的思想是數組是部分有序的，然后將無序的部分循環插入到已有序的序列中
* 插入排序對隨機順序的序列的時間復雜度也為O(N^2)，但是對於基本有序的序列進行排序時間復雜度為O(N)
* 插入排序能保證它排序時i之前的順序是i之前所有元素的局部排名
* */
public void sort_insertion(Comparable[] a)
{
int N = a.length;
for (int i=1; i<N; i++)
{
/*從第i個元素開始，往右一個元素向左依次比大小，插到合適的最左面*/
for (int j=i; j>0 && less(a[j], a[j-1]); j--)
{
exch(a, j, j-1);
}
}
}
/*選擇排序
* 冒泡排序是逐一比較，時間復雜度高，還要經常交換數組，時間復雜度為O(N^2)
* 選擇排序時間復雜度是O(N^2)，與冒泡排序相比減少了數組交換的次數
* 選擇排序能保證它排序時i之前的順序是全局確定排名
* */
public void sort_selection(Comparable[] a)
{
int N = a.length;
for (int i=0; i<N; i++)
{
int min = i;
/*找出從i個后的最小值，並與i索引值交換，以此類推*/
for (int j = i+1; j<N; j++)
if (less(a[j], a[min])) min = j;
exch(a, i, min);
}
}
/*基本函數*/
private boolean less(Comparable v, Comparable w)
{
return v.compareTo(w) < 0;
}
private void exch(Comparable[] a, int i, int j)
{
Comparable t = a[i];
a[i] = a[j];
a[j] = t;
}
public void show(Comparable[] a)
{
for (Comparable ai : a) {
System.out.print(ai + " ");
}
System.out.println();
}
public boolean isSorted(Comparable[] a)
{
for (int i=0; i<a.length; i++)
if (less(a[i], a[i-1]))
return false;
return true;
}
}
運行結果：
>> 快排API:31ms >> 快速排序:16ms >> 堆排序:31ms >> 歸並排序:47ms >> 選擇排序:5719ms >> 插入排序:3204ms