轉載自:http://cmsblogs.com/?p=3631
- 作者：chenssy
- 原文出處：http://cmsblogs.com
排序算法是《數據結構與算法》中最基本的算法之一。
排序算法可以分爲內部排序和外部排序，內部排序是數據記錄在內存中進行排序，而外部排序是因排序的數據很大，一次不能容納全部的排序記錄，在排序過程中需要訪問外存。常見的內部排序算法有：插入排序、希爾排序、選擇排序、冒泡排序、歸併排序、快速排序、堆排序、基數排序等。用一張圖概括：
關於時間複雜度：
1、平方階 (O(n2)) 排序 各類簡單排序：直接插入、直接選擇和冒泡排序。 2、線性對數階 (O(nlog2n)) 排序 快速排序、堆排序和歸併排序； 3、O(n1+§)) 排序，§ 是介於 0 和 1 之間的常數。 希爾排序 4、線性階 (O(n)) 排序 基數排序，此外還有桶、箱排序。
關於穩定性：
1、穩定的排序算法：冒泡排序、插入排序、歸併排序和基數排序。 2、不是穩定的排序算法：選擇排序、快速排序、希爾排序、堆排序。
名詞解釋：
n：數據規模k：“桶”的個數In-place：佔用常數內存，不佔用額外內存Out-place：佔用額外內存穩定性：排序後 2 個相等鍵值的順序和排序之前它們的順序相同
一、冒泡排序
冒泡排序（Bubble Sort）也是一種簡單直觀的排序算法。它重複地走訪過要排序的數列，一次比較兩個元素，如果他們的順序錯誤就把他們交換過來。走訪數列的工作是重複地進行直到沒有再需要交換，也就是說該數列已經排序完成。這個算法的名字由來是因爲越小的元素會經由交換慢慢“浮”到數列的頂端。
作爲最簡單的排序算法之一，冒泡排序給我的感覺就像 Abandon 在單詞書裏出現的感覺一樣，每次都在第一頁第一位，所以最熟悉。冒泡排序還有一種優化算法，就是立一個 flag，當在一趟序列遍歷中元素沒有發生交換，則證明該序列已經有序。但這種改進對於提升性能來說並沒有什麼太大作用。
1. 算法步驟
1、比較相鄰的元素。如果第一個比第二個大，就交換他們兩個。 2、對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最後一對。這步做完後，最後的元素會是最大的數。 3、針對所有的元素重複以上的步驟，除了最後一個。 4、持續每次對越來越少的元素重複上面的步驟，直到沒有任何一對數字需要比較。
2. 動圖演示
3. 什麼時候最快
當輸入的數據已經是正序時（都已經是正序了，我還要你冒泡排序有何用啊）。
4. 什麼時候最慢
當輸入的數據是反序時（寫一個 for 循環反序輸出數據不就行了，幹嘛要用你冒泡排序呢，我是閒的嗎）。
5. java代碼實現
public static void BubbleSort(int[] arr) {
int temp; //臨時變量
for (int i = 0; i < arr.length - 1; i++) { //表示趟數，一共arr.length-1次。
for (int j = arr.length - 1; j > i; j--) {
if (arr[j] < arr[j - 1]) {
temp = arr[j];
arr[j] = arr[j - 1];
arr[j - 1] = temp;
}
}
}
}
6. 優化
針對問題：
數據的順序排好之後，冒泡算法仍然會繼續進行下一輪的比較，直到arr.length-1次，後面的比較沒有意義的。
方案：
設置標誌位flag，如果發生了交換flag設置爲true；如果沒有交換就設置爲false。 這樣當一輪比較結束後如果flag仍爲false，即：這一輪沒有發生交換，說明數據的順序已經排好，沒有必要繼續進行下去。
public static void BubbleSort1(int[] arr) {
int temp;//臨時變量
boolean flag;//是否交換的標誌
for (int i = 0; i < arr.length - 1; i++) { //表示趟數，一共arr.length-1次。
flag = false;
for (int j = arr.length - 1; j > i; j--) {
if (arr[j] < arr[j - 1]) {
temp = arr[j];
arr[j] = arr[j - 1];
arr[j - 1] = temp;
flag = true;
}
}
if (!flag){
break;
}
}
}
二、選擇排序
選擇排序是一種簡單直觀的排序算法，無論什麼數據進去都是 O(n²) 的時間複雜度。所以用到它的時候，數據規模越小越好。唯一的好處可能就是不佔用額外的內存空間了吧。
1. 算法步驟
1、首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置 2、再從剩餘未排序元素中繼續尋找最小（大）元素，然後放到已排序序列的末尾。 3、重複第二步，直到所有元素均排序完畢。
2. 動圖演示
3. java代碼實現
public static void select_sort(int array[], int lenth) {
for (int i = 0; i < lenth - 1; i++) {
int minIndex = i;
for (int j = i + 1; j < lenth; j++) {
if (array[j] < array[minIndex]) {
minIndex = j;
}
}
if (minIndex != i) {
int temp = array[i];
array[i] = array[minIndex];
array[minIndex] = temp;
}
}
}
}
三、插入排序
插入排序的代碼實現雖然沒有冒泡排序和選擇排序那麼簡單粗暴，但它的原理應該是最容易理解的了，因爲只要打過撲克牌的人都應該能夠秒懂。插入排序是一種最簡單直觀的排序算法，它的工作原理是通過構建有序序列，對於未排序數據，在已排序序列中從後向前掃描，找到相應位置並插入。
插入排序和冒泡排序一樣，也有一種優化算法，叫做拆半插入。
1. 算法步驟
1、將第一待排序序列第一個元素看做一個有序序列，把第二個元素到最後一個元素當成是未排序序列。 2、從頭到尾依次掃描未排序序列，將掃描到的每個元素插入有序序列的適當位置。（如果待插入的元素與有序序列中的某個元素相等，則將待插入元素插入到相等元素的後面。）
2. 動圖演示
3. java代碼實現
public static void insert_sort(int array[], int lenth) {
int temp;
for (int i = 0; i < lenth - 1; i++) {
for (int j = i + 1; j > 0; j--) {
if (array[j] < array[j - 1]) {
temp = array[j - 1];
array[j - 1] = array[j];
array[j] = temp;
} else { //不需要交換
break;
}
}
}
}
四、希爾排序
希爾排序，也稱遞減增量排序算法，是插入排序的一種更高效的改進版本。但希爾排序是非穩定排序算法。
希爾排序是基於插入排序的以下兩點性質而提出改進方法的：
插入排序在對幾乎已經排好序的數據操作時，效率高，即可以達到線性排序的效率； 但插入排序一般來說是低效的，因爲插入排序每次只能將數據移動一位；
希爾排序的基本思想是：先將整個待排序的記錄序列分割成爲若干子序列分別進行直接插入排序，待整個序列中的記錄“基本有序”時，再對全體記錄進行依次直接插入排序。
1. 算法步驟
1、選擇一個增量序列 t1，t2，……，tk，其中 ti > tj, tk = 1；
2、按增量序列個數 k，對序列進行 k 趟排序； 3、每趟排序，根據對應的增量 ti，將待排序列分割成若干長度爲 m 的子序列，分別對各子表進行直接插入排序。僅增量因子爲 1 時，整個序列作爲一個表來處理，表長度即爲整個序列的長度。
2. java代碼實現
public static void shell_sort(int array[], int lenth) {
int temp = 0;
int incre = lenth;
while (true) {
incre = incre / 2;
for (int k = 0; k < incre; k++) { //根據增量分爲若干子序列
for (int i = k + incre; i < lenth; i += incre) {
for (int j = i; j > k; j -= incre) {
if (array[j] < array[j - incre]) {
temp = array[j - incre];
array[j - incre] = array[j];
array[j] = temp;
} else {
break;
}
}
}
}
if (incre == 1) {
break;
}
}
}
五、歸併排序
歸併排序（Merge sort）是建立在歸併操作上的一種有效的排序算法。該算法是採用分治法（Divide and Conquer）的一個非常典型的應用。
作爲一種典型的分而治之思想的算法應用，歸併排序的實現由兩種方法：
1、自上而下的遞歸（所有遞歸的方法都可以用迭代重寫，所以就有了第 2 種方法）；
2、自下而上的迭代；在《數據結構與算法 JavaScript 描述》中，作者給出了自下而上的迭代方法。但是對於遞歸法，作者卻認爲：However, it is not possible to do so in JavaScript, as the recursion goes too deep for the language to handle.然而，在 JavaScript 中這種方式不太可行，因爲這個算法的遞歸深度對它來講太深了。說實話，我不太理解這句話。意思是 JavaScript 編譯器內存太小，遞歸太深容易造成內存溢出嗎？還望有大神能夠指教。和選擇排序一樣，歸併排序的性能不受輸入數據的影響，但表現比選擇排序好的多，因爲始終都是 O(nlogn) 的時間複雜度。代價是需要額外的內存空間。
1. 算法步驟
1、申請空間，使其大小爲兩個已經排序序列之和，該空間用來存放合併後的序列；
2、設定兩個指針，最初位置分別爲兩個已經排序序列的起始位置； 3、比較兩個指針所指向的元素，選擇相對小的元素放入到合併空間，並移動指針到下一位置； 4、重複步驟 3 直到某一指針達到序列尾； 5、將另一序列剩下的所有元素直接複製到合併序列尾。
2. 動圖演示
3. java 代碼實現
//將有序數組a[]和b[]合併到c[]中
void MemeryArray(int a[], int n, int b[], int m, int c[]) {
int i, j, k;
i = j = k = 0;
while (i < n && j < m) {
if (a[i] < b[j]) {
c[k++] = a[i++];
} else {
c[k++] = b[j++];
}
}
while (i < n) {
c[k++] = a[i++];
}
while (j < m) {
c[k++] = b[j++];
}
}
六、快速排序
快速排序是由東尼·霍爾所發展的一種排序算法。在平均狀況下，排序 n 個項目要 Ο(nlogn) 次比較。在最壞狀況下則需要 Ο(n2) 次比較，但這種狀況並不常見。事實上，快速排序通常明顯比其他 Ο(nlogn) 算法更快，因爲它的內部循環（inner loop）可以在大部分的架構上很有效率地被實現出來。
快速排序使用分治法（Divide and conquer）策略來把一個串行（list）分爲兩個子串行（sub-lists）。
快速排序又是一種分而治之思想在排序算法上的典型應用。本質上來看，快速排序應該算是在冒泡排序基礎上的遞歸分治法。
快速排序的名字起的是簡單粗暴，因爲一聽到這個名字你就知道它存在的意義，就是快，而且效率高！它是處理大數據最快的排序算法之一了。雖然 Worst Case 的時間複雜度達到了 O(n²)，但是人家就是優秀，在大多數情況下都比平均時間複雜度爲 O(n logn) 的排序算法表現要更好，可是這是爲什麼呢，我也不知道。好在我的強迫症又犯了，查了 N 多資料終於在《算法藝術與信息學競賽》上找到了滿意的答案：
快速排序的最壞運行情況是 O(n²)，比如說順序數列的快排。但它的平攤期望時間是 O(nlogn)，且 O(nlogn) 記號中隱含的常數因子很小，比複雜度穩定等於 O(nlogn) 的歸併排序要小很多。所以，對絕大多數順序性較弱的隨機數列而言，快速排序總是優於歸併排序。
1. 算法步驟
1、從數列中挑出一個元素，稱爲 “基準”（pivot）;
2、重新排序數列，所有元素比基準值小的擺放在基準前面，所有元素比基準值大的擺在基準的後面（相同的數可以到任一邊）。在這個分區退出之後，該基準就處於數列的中間位置。這個稱爲分區（partition）操作； 3、遞歸地（recursive）把小於基準值元素的子數列和大於基準值元素的子數列排序；
遞歸的最底部情形，是數列的大小是零或一，也就是永遠都已經被排序好了。雖然一直遞歸下去，但是這個算法總會退出，因爲在每次的迭代（iteration）中，它至少會把一個元素擺到它最後的位置去。
基本思想：（分治）
-
先從數列中取出一個數作爲key值；
-
將比這個數小的數全部放在它的左邊，大於或等於它的數全部放在它的右邊；
-
對左右兩個小數列重複第二步，直至各區間只有1個數。
輔助理解：挖坑填數
初始時 i = 0; j = 9; key=72
1、由於已經將a[0]中的數保存到key中，可以理解成在數組a[0]上挖了個坑，可以將其它數據填充到這來。 2、從j開始向前找一個比key小的數。當j=8，符合條件，a[0] = a[8] ; i++ ; 將a[8]挖出再填到上一個坑a[0]中。 3、這樣一個坑a[0]就被搞定了，但又形成了一個新坑a[8]，這怎麼辦了？簡單，再找數字來填a[8]這個坑。 4、這次從i開始向後找一個大於key的數，當i=3，符合條件，a[8] = a[3] ; j– ; 將a[3]挖出再填到上一個坑中。
1. 數組：72 - 6 - 57 - 88 - 60 - 42 - 83 - 73 - 48 - 85
2. 0 1 2 3 4 5 6 7 8 9
- 1、此時 i = 3; j = 7; key=72
- 2、再重複上面的步驟，先從後向前找，再從前向後找。
- 3、從j開始向前找，當j=5，符合條件，將a[5]挖出填到上一個坑中，a[3] = a[5]; i++;
- 4、從i開始向後找，當i=5時，由於i==j退出。
- 5、此時，i = j = 5，而a[5]剛好又是上次挖的坑，因此將key填入a[5]。
1. 數組：48 - 6 - 57 - 88 - 60 - 42 - 83 - 73 - 88 - 85
2. 0 1 2 3 4 5 6 7 8 9
可以看出a[5]前面的數字都小於它，a[5]後面的數字都大於它。因此再對a[0…4]和a[6…9]這二個子區間重複上述步驟就可以了。
1. 數組：48 - 6 - 57 - 42 - 60 - 72 - 83 - 73 - 88 - 85
2. 0 1 2 3 4 5 6 7 8 9
2. 動圖演示
3. java版
public static void quickSort(int a[], int l, int r) {
if (l >= r) return;
int i = l;
int j = r;
int key = a[l]; //選擇第一個數爲key
while (i < j) {
while (i < j && a[j] >= key) //從右向左找第一個小於key的值
j--;
if (i < j) {
a[i] = a[j];
i++;
}
while (i < j && a[i] < key) //從左向右找第一個大於key的值
i++;
if (i < j) {
a[j] = a[i];
j--;
}
}
//i == j
a[i] = key;
quickSort(a, l, i - 1); //遞歸調用
quickSort(a, i + 1, r); //遞歸調用
}
key值的選取可以有多種形式，例如中間數或者隨機數，分別會對算法的複雜度產生不同的影響。
七、堆排序
堆排序（Heapsort）是指利用堆這種數據結構所設計的一種排序算法。堆積是一個近似完全二叉樹的結構，並同時滿足堆積的性質：即子結點的鍵值或索引總是小於（或者大於）它的父節點。堆排序可以說是一種利用堆的概念來排序的選擇排序。分爲兩種方法：
1、大頂堆：每個節點的值都大於或等於其子節點的值，在堆排序算法中用於升序排列； 2、小頂堆：每個節點的值都小於或等於其子節點的值，在堆排序算法中用於降序排列；
堆排序的平均時間複雜度爲 Ο(nlogn)。
1. 算法步驟
1、創建一個堆 H[0……n-1]； 2、把堆首（最大值）和堆尾互換； 3、把堆的尺寸縮小 1，並調用 shift_down(0)，目的是把新的數組頂端數據調整到相應位置； 4、重複步驟 2，直到堆的尺寸爲 1。
2. 動圖演示
3. java代碼實現
//構建最小堆
public static void MakeMinHeap(int a[], int n) {
for (int i = (n - 1) / 2; i >= 0; i--) {
MinHeapFixdown(a, i, n);
}
}
//從i節點開始調整,n爲節點總數 從0開始計算 i節點的子節點爲 2*i+1, 2*i+2
public static void MinHeapFixdown(int a[], int i, int n) {
int j = 2 * i + 1; //子節點
int temp = 0;
while (j < n) {
//在左右子節點中尋找最小的
if (j + 1 < n && a[j + 1] < a[j]) {
j++;
}
if (a[i] <= a[j]) break;
//較大節點下移
temp = a[i];
a[i] = a[j];
a[j] = temp;
i = j;
j = 2 * i + 1;
}
}
public static void MinHeap_Sort(int a[], int n) {
int temp = 0;
MakeMinHeap(a, n);
for (int i = n - 1; i > 0; i--) {
temp = a[0];
a[0] = a[i];
a[i] = temp;
MinHeapFixdown(a, 0, i);
}
}
八、計數排序
計數排序的核心在於將輸入的數據值轉化爲鍵存儲在額外開闢的數組空間中。作爲一種線性時間複雜度的排序，計數排序要求輸入的數據必須是有確定範圍的整數。
1、計數排序是一種非常快捷的穩定性強的排序方法，時間複雜度O(n+k),其中n爲要排序的數的個數，k爲要排序的數的組大值。計數排序對一定量的整數排序時候的速度非常快，一般快於其他排序算法。但計數排序侷限性比較大，只限於對整數進行排序。計數排序是消耗空間發雜度來獲取快捷的排序方法，其空間發展度爲O（K）同理K爲要排序的最大值。
2、計數排序的基本思想爲一組數在排序之前先統計這組數中其他數小於這個數的個數，則可以確定這個數的位置。例如要排序的數爲 7 4 2 1 5 3 1 5；則比7小的有7個數，所有7應該在排序好的數列的第八位，同理3在第四位，對於重複的數字，1在1位和2位（暫且認爲第一個1比第二個1小），5和1一樣位於6位和7位。
1. 動圖演示
2. java 代碼實現
public static void main(String[] args) throws Exception {
int[] array = {
9, 8, 7, 6, 5, 4, 3, 2, 6, 1, 0
};
System.out.println("Before sort:");
ArrayUtils.printArray(array);
countingSort(array, 9);
System.out.println("After sort:");
ArrayUtils.printArray(array);
}
public static void countingSort(int[] array, int range) throws Exception {
if (range <= 0) {
throw new Exception("range can't be negative or zero.");
}
if (array.length <= 1) {
return;
}
int[] countArray = new int[range + 1];
for (int i = 0; i < array.length; i++) {
int value = array[i];
if (value < 0 || value > range) {
throw new Exception("array element overflow range.");
}
countArray[value] += 1;
}
for (int i = 1; i < countArray.length; i++) {
countArray[i] += countArray[i - 1];
}
int[] temp = new int[array.length];
for (int i = array.length - 1; i >= 0; i--) {
int value = array[i];
int position = countArray[value] - 1;
temp[position] = value;
countArray[value] -= 1;
}
for (int i = 0; i < array.length; i++) {
array[i] = temp[i];
}
}
九、桶排序
桶排序是計數排序的升級版。它利用了函數的映射關係，高效與否的關鍵就在於這個映射函數的確定。爲了使桶排序更加高效，我們需要做到這兩點：
1、在額外空間充足的情況下，儘量增大桶的數量 2、使用的映射函數能夠將輸入的 N 個數據均勻的分配到 K 個桶中
同時，對於桶中元素的排序，選擇何種比較排序算法對於性能的影響至關重要。
1. 什麼時候最快
當輸入的數據可以均勻的分配到每一個桶中。
2. 什麼時候最慢
當輸入的數據被分配到了同一個桶中。
3. Java 代碼實現
/**
* . * 桶排序假設輸入元素均勻而獨立的分佈在區間[0，1）上；
* 桶排序的核心思想是，將[0，1）分爲n個大小相同的子區間，
* 上一個區間裏的元素都比下一個區間裏的元素小，然後對
* 所有區間裏的元素排序，最後順序輸出所有區間裏的元素，
* 達到對所有元素排序的目的。
*/
public class BucketSort {
public void sort(Double[] a) {
int n = a.length;
/**
. * 創建鏈表（桶）集合並初始化，集合中的鏈表用於存放相應的元素
*/
int bucketNum = 10; // 桶數
LinkedList<LinkedList<Double>> buckets = new LinkedList<LinkedList<Double>>();
for (int i = 0; i < bucketNum; i++) {
LinkedList<Double> bucket = new LinkedList<Double>();
buckets.add(bucket);
}
// 把元素放進相應的桶中
for (int i = 0; i < n; i++) {
int index = (int) (a[i] * bucketNum);
buckets.get(index).add(a[i]);
}
// 對每個桶中的元素排序，並放進a中
int index = 0;
for (LinkedList<Double> linkedList : buckets) {
int size = linkedList.size();
if (size == 0) {
continue;
}
/**
* 把LinkedList<Double>轉化爲Double[]的原因是，之前已經實現了
* 對數組進行排序的算法
*/
Double[] temp = new Double[size];
for (int i = 0; i < temp.length; i++) {
temp[i] = linkedList.get(i);
}
// 利用插入排序對temp排序
new InsertSort().sort(temp);
for (int i = 0; i < temp.length; i++) {
a[index] = temp[i];
index++;
}
}
}
public static void main(String[] args) {
Double[] a = new Double[]{0.3, 0.6, 0.5};
new BucketSort().sort(a);
for (int i = 0; i < a.length; i++) {
System.out.println(a[i]);
}
}
}
十、基數排序
基數排序是一種非比較型整數排序算法，其原理是將整數按位數切割成不同的數字，然後按每個位數分別比較。由於整數也可以表達字符串（比如名字或日期）和特定格式的浮點數，所以基數排序也不是隻能使用於整數。
1. 基數排序 vs 計數排序 vs 桶排序
基數排序有兩種方法：
這三種排序算法都利用了桶的概念，但對桶的使用方法上有明顯差異：
1、基數排序：根據鍵值的每位數字來分配桶； 2、計數排序：每個桶只存儲單一鍵值； 3、桶排序：每個桶存儲一定範圍的數值；
2. LSD 基數排序動圖演示
3. Java 代碼實現
1. /**
2. * 基數排序
3. * 考慮負數的情況還可以參考： https://code.i-harness.com/zh-CN/q/e98fa9
4. */
5. public class RadixSort implements IArraySort {@
6. Override
7. public int[] sort(int[] sourceArray) throws Exception {
8. // 對 arr 進行拷貝，不改變參數內容
9. int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
10. int maxDigit = getMaxDigit(arr);
11. return radixSort(arr, maxDigit);
12. }
13. /**
14. * 獲取最高位數
15. */
16. private int getMaxDigit(int[] arr) {
17. int maxValue = getMaxValue(arr);
18. return getNumLenght(maxValue);
19. }
20. private int getMaxValue(int[] arr) {
21. int maxValue = arr[0];
22. for (int value: arr) {
23. if (maxValue < value) {
24. maxValue = value;
25. }
26. }
27. return maxValue;
28. }
29. protected int getNumLenght(long num) {
30. if (num == 0) {
31. return 1;
32. }
33. int lenght = 0;
34. for (long temp = num; temp != 0; temp /= 10) {
35. lenght++;
36. }
37. return lenght;
38. }
39. private int[] radixSort(int[] arr, int maxDigit) {
40. int mod = 10;
41. int dev = 1;
42. for (int i = 0; i < maxDigit; i++, dev *= 10, mod *= 10) {
43. // 考慮負數的情況，這裏擴展一倍隊列數，其中 [0-9]對應負數，[10-19]對應正數 (bucket + 10)
44. int[][] counter = new int[mod * 2][0];
45. for (int j = 0; j < arr.length; j++) {
46. int bucket = ((arr[j] % mod) / dev) + mod;
47. counter[bucket] = arrayAppend(counter[bucket], arr[j]);
48. }
49. int pos = 0;
50. for (int[] bucket: counter) {
51. for (int value: bucket) {
52. arr[pos++] = value;
53. }
54. }
55. }
56. return arr;
57. }
58. /**
59. * 自動擴容，並保存數據
60. *
61. * @param arr
62. * @param value
63. */
64. private int[] arrayAppend(int[] arr, int value) {
65. arr = Arrays.copyOf(arr, arr.length + 1);
66. arr[arr.length - 1] = value;
67. return arr;
68. }
69. }