常用排序算法總結(jié)一(冒泡排序，選擇排序，插入排序，歸并排序，堆排序，快速排序)
目錄
我們通常所說(shuō)的排序算法往往指的是內(nèi)部排序算法，即數(shù)據(jù)記錄在內(nèi)存中進(jìn)行排序。
排序算法大體可分為兩種：
一種是比較排序，時(shí)間復(fù)雜度O(nlogn) ~ O(n^2)，主要有：冒泡排序，選擇排序，插入排序，歸并排序，堆排序，快速排序等。
另一種是非比較排序，時(shí)間復(fù)雜度可以達(dá)到O(n)，主要有：計(jì)數(shù)排序，基數(shù)排序，桶排序等。
這里我們來(lái)探討一下常用的比較排序算法，非比較排序算法將在下一篇文章中介紹。下表給出了常見比較排序算法的性能：
有一點(diǎn)我們很容易忽略的是排序算法的穩(wěn)定性(騰訊校招2016筆試題曾考過(guò))。
排序算法穩(wěn)定性的簡(jiǎn)單形式化定義為：如果Ai = Aj，排序前Ai在Aj之前，排序后Ai還在Aj之前，則稱這種排序算法是穩(wěn)定的。通俗地講就是保證排序前后兩個(gè)相等的數(shù)的相對(duì)順序不變。
對(duì)于不穩(wěn)定的排序算法，只要舉出一個(gè)實(shí)例，即可說(shuō)明它的不穩(wěn)定性；而對(duì)于穩(wěn)定的排序算法，必須對(duì)算法進(jìn)行分析從而得到穩(wěn)定的特性。需要注意的是，排序算法是否為穩(wěn)定的是由具體算法決定的，不穩(wěn)定的算法在某種條件下可以變?yōu)榉€(wěn)定的算法，而穩(wěn)定的算法在某種條件下也可以變?yōu)椴环€(wěn)定的算法。
例如，對(duì)于冒泡排序，原本是穩(wěn)定的排序算法，如果將記錄交換的條件改成A[i] >= A[i + 1]，則兩個(gè)相等的記錄就會(huì)交換位置，從而變成不穩(wěn)定的排序算法。
其次，說(shuō)一下排序算法穩(wěn)定性的好處。排序算法如果是穩(wěn)定的，那么從一個(gè)鍵上排序，然后再?gòu)牧硪粋€(gè)鍵上排序，前一個(gè)鍵排序的結(jié)果可以為后一個(gè)鍵排序所用。基數(shù)排序就是這樣，先按低位排序，逐次按高位排序，低位排序后元素的順序在高位也相同時(shí)是不會(huì)改變的。
冒泡排序(Bubble Sort)
冒泡排序是一種極其簡(jiǎn)單的排序算法，也是我所學(xué)的第一個(gè)排序算法。它重復(fù)地走訪過(guò)要排序的元素，依次比較相鄰兩個(gè)元素，如果他們的順序錯(cuò)誤就把他們調(diào)換過(guò)來(lái)，直到?jīng)]有元素再需要交換，排序完成。這個(gè)算法的名字由來(lái)是因?yàn)樵叫?或越大)的元素會(huì)經(jīng)由交換慢慢“浮”到數(shù)列的頂端。
冒泡排序算法的運(yùn)作如下：
- 比較相鄰的元素，如果前一個(gè)比后一個(gè)大，就把它們兩個(gè)調(diào)換位置。
- 對(duì)每一對(duì)相鄰元素作同樣的工作，從開始第一對(duì)到結(jié)尾的最后一對(duì)。這步做完后，最后的元素會(huì)是最大的數(shù)。
- 針對(duì)所有的元素重復(fù)以上的步驟，除了最后一個(gè)。
- 持續(xù)每次對(duì)越來(lái)越少的元素重復(fù)上面的步驟，直到?jīng)]有任何一對(duì)數(shù)字需要比較。
由于它的簡(jiǎn)潔，冒泡排序通常被用來(lái)對(duì)于程序設(shè)計(jì)入門的學(xué)生介紹算法的概念。冒泡排序的代碼如下：
#include <stdio.h> // 分類 -------------- 內(nèi)部比較排序 // 數(shù)據(jù)結(jié)構(gòu) ---------- 數(shù)組 // 最差時(shí)間復(fù)雜度 ---- O(n^2) // 最優(yōu)時(shí)間復(fù)雜度 ---- 如果能在內(nèi)部循環(huán)第一次運(yùn)行時(shí),使用一個(gè)旗標(biāo)來(lái)表示有無(wú)需要交換的可能,可以把最優(yōu)時(shí)間復(fù)雜度降低到O(n) // 平均時(shí)間復(fù)雜度 ---- O(n^2) // 所需輔助空間 ------ O(1) // 穩(wěn)定性 ------------ 穩(wěn)定 void Swap(int A[], int i, int j) { int temp = A[i]; A[i] = A[j]; A[j] = temp; } void BubbleSort(int A[], int n) { for (int j = 0; j < n - 1; j++) // 每次最大元素就像氣泡一樣"浮"到數(shù)組的最后 { for (int i = 0; i < n - 1 - j; i++) // 依次比較相鄰的兩個(gè)元素,使較大的那個(gè)向后移 { if (A[i] > A[i + 1]) // 如果條件改成A[i] >= A[i + 1],則變?yōu)椴环€(wěn)定的排序算法 { Swap(A, i, i + 1); } } } } int main() { int A[] = { 6, 5, 3, 1, 8, 7, 2, 4 }; // 從小到大冒泡排序 int n = sizeof(A) / sizeof(int); BubbleSort(A, n); printf("冒泡排序結(jié)果："); for (int i = 0; i < n; i++) { printf("%d ", A[i]); } printf("\n"); return 0; }
上述代碼對(duì)序列{ 6, 5, 3, 1, 8, 7, 2, 4 }進(jìn)行冒泡排序的實(shí)現(xiàn)過(guò)程如下
使用冒泡排序?yàn)橐涣袛?shù)字進(jìn)行排序的過(guò)程如右圖所示： 
盡管冒泡排序是最容易了解和實(shí)現(xiàn)的排序算法之一，但它對(duì)于少數(shù)元素之外的數(shù)列排序是很沒有效率的。
冒泡排序的改進(jìn)：雞尾酒排序
雞尾酒排序，也叫定向冒泡排序，是冒泡排序的一種改進(jìn)。此算法與冒泡排序的不同處在于從低到高然后從高到低，而冒泡排序則僅從低到高去比較序列里的每個(gè)元素。他可以得到比冒泡排序稍微好一點(diǎn)的效能。
雞尾酒排序的代碼如下：
#include <stdio.h> // 分類 -------------- 內(nèi)部比較排序 // 數(shù)據(jù)結(jié)構(gòu) ---------- 數(shù)組 // 最差時(shí)間復(fù)雜度 ---- O(n^2) // 最優(yōu)時(shí)間復(fù)雜度 ---- 如果序列在一開始已經(jīng)大部分排序過(guò)的話,會(huì)接近O(n) // 平均時(shí)間復(fù)雜度 ---- O(n^2) // 所需輔助空間 ------ O(1) // 穩(wěn)定性 ------------ 穩(wěn)定 void Swap(int A[], int i, int j) { int temp = A[i]; A[i] = A[j]; A[j] = temp; } void CocktailSort(int A[], int n) { int left = 0; // 初始化邊界 int right = n - 1; while (left < right) { for (int i = left; i < right; i++) // 前半輪,將最大元素放到后面 { if (A[i] > A[i + 1]) { Swap(A, i, i + 1); } } right--; for (int i = right; i > left; i--) // 后半輪,將最小元素放到前面 { if (A[i - 1] > A[i]) { Swap(A, i - 1, i); } } left++; } } int main() { int A[] = { 6, 5, 3, 1, 8, 7, 2, 4 }; // 從小到大定向冒泡排序 int n = sizeof(A) / sizeof(int); CocktailSort(A, n); printf("雞尾酒排序結(jié)果："); for (int i = 0; i < n; i++) { printf("%d ", A[i]); } printf("\n"); return 0; }
使用雞尾酒排序?yàn)橐涣袛?shù)字進(jìn)行排序的過(guò)程如右圖所示： 
以序列(2,3,4,5,1)為例，雞尾酒排序只需要訪問(wèn)一次序列就可以完成排序，但如果使用冒泡排序則需要四次。但是在亂數(shù)序列的狀態(tài)下，雞尾酒排序與冒泡排序的效率都很差勁。
選擇排序(Selection Sort)
選擇排序也是一種簡(jiǎn)單直觀的排序算法。它的工作原理很容易理解：初始時(shí)在序列中找到最小（大）元素，放到序列的起始位置作為已排序序列；然后，再?gòu)氖Ｓ辔磁判蛟刂欣^續(xù)尋找最小（大）元素，放到已排序序列的末尾。以此類推，直到所有元素均排序完畢。
注意選擇排序與冒泡排序的區(qū)別：冒泡排序通過(guò)依次交換相鄰兩個(gè)順序不合法的元素位置，從而將當(dāng)前最?。ù螅┰胤诺胶线m的位置；而選擇排序每遍歷一次都記住了當(dāng)前最?。ù螅┰氐奈恢?，最后僅需一次交換操作即可將其放到合適的位置。
選擇排序的代碼如下：
#include <stdio.h> // 分類 -------------- 內(nèi)部比較排序 // 數(shù)據(jù)結(jié)構(gòu) ---------- 數(shù)組 // 最差時(shí)間復(fù)雜度 ---- O(n^2) // 最優(yōu)時(shí)間復(fù)雜度 ---- O(n^2) // 平均時(shí)間復(fù)雜度 ---- O(n^2) // 所需輔助空間 ------ O(1) // 穩(wěn)定性 ------------ 不穩(wěn)定 void Swap(int A[], int i, int j) { int temp = A[i]; A[i] = A[j]; A[j] = temp; } void SelectionSort(int A[], int n) { for (int i = 0; i < n - 1; i++) // i為已排序序列的末尾 { int min = i; for (int j = i + 1; j < n; j++) // 未排序序列 { if (A[j] < A[min]) // 找出未排序序列中的最小值 { min = j; } } if (min != i) { Swap(A, min, i); // 放到已排序序列的末尾，該操作很有可能把穩(wěn)定性打亂，所以選擇排序是不穩(wěn)定的排序算法 } } } int main() { int A[] = { 8, 5, 2, 6, 9, 3, 1, 4, 0, 7 }; // 從小到大選擇排序 int n = sizeof(A) / sizeof(int); SelectionSort(A, n); printf("選擇排序結(jié)果："); for (int i = 0; i < n; i++) { printf("%d ", A[i]); } printf("\n"); return 0; }
上述代碼對(duì)序列{ 8, 5, 2, 6, 9, 3, 1, 4, 0, 7 }進(jìn)行選擇排序的實(shí)現(xiàn)過(guò)程如右圖 
使用選擇排序?yàn)橐涣袛?shù)字進(jìn)行排序的宏觀過(guò)程： 
選擇排序是不穩(wěn)定的排序算法，不穩(wěn)定發(fā)生在最小元素與A[i]交換的時(shí)刻。
比如序列：{ 5, 8, 5, 2, 9 }，一次選擇的最小元素是2，然后把2和第一個(gè)5進(jìn)行交換，從而改變了兩個(gè)元素5的相對(duì)次序。
插入排序(Insertion Sort)
插入排序是一種簡(jiǎn)單直觀的排序算法。它的工作原理非常類似于我們抓撲克牌
對(duì)于未排序數(shù)據(jù)(右手抓到的牌)，在已排序序列(左手已經(jīng)排好序的手牌)中從后向前掃描，找到相應(yīng)位置并插入。
插入排序在實(shí)現(xiàn)上，通常采用in-place排序（即只需用到O(1)的額外空間的排序），因而在從后向前掃描過(guò)程中，需要反復(fù)把已排序元素逐步向后挪位，為最新元素提供插入空間。
具體算法描述如下：
- 從第一個(gè)元素開始，該元素可以認(rèn)為已經(jīng)被排序
- 取出下一個(gè)元素，在已經(jīng)排序的元素序列中從后向前掃描
- 如果該元素（已排序）大于新元素，將該元素移到下一位置
- 重復(fù)步驟3，直到找到已排序的元素小于或者等于新元素的位置
- 將新元素插入到該位置后
- 重復(fù)步驟2~5
插入排序的代碼如下：
#include <stdio.h> // 分類 ------------- 內(nèi)部比較排序 // 數(shù)據(jù)結(jié)構(gòu) ---------- 數(shù)組 // 最差時(shí)間復(fù)雜度 ---- 最壞情況為輸入序列是降序排列的,此時(shí)時(shí)間復(fù)雜度O(n^2) // 最優(yōu)時(shí)間復(fù)雜度 ---- 最好情況為輸入序列是升序排列的,此時(shí)時(shí)間復(fù)雜度O(n) // 平均時(shí)間復(fù)雜度 ---- O(n^2) // 所需輔助空間 ------ O(1) // 穩(wěn)定性 ------------ 穩(wěn)定 void InsertionSort(int A[], int n) { for (int i = 1; i < n; i++) // 類似抓撲克牌排序 { int get = A[i]; // 右手抓到一張撲克牌 int j = i - 1; // 拿在左手上的牌總是排序好的 while (j >= 0 && A[j] > get) // 將抓到的牌與手牌從右向左進(jìn)行比較 { A[j + 1] = A[j]; // 如果該手牌比抓到的牌大，就將其右移 j--; } A[j + 1] = get; // 直到該手牌比抓到的牌小(或二者相等)，將抓到的牌插入到該手牌右邊(相等元素的相對(duì)次序未變，所以插入排序是穩(wěn)定的) } } int main() { int A[] = { 6, 5, 3, 1, 8, 7, 2, 4 };// 從小到大插入排序 int n = sizeof(A) / sizeof(int); InsertionSort(A, n); printf("插入排序結(jié)果："); for (int i = 0; i < n; i++) { printf("%d ", A[i]); } printf("\n"); return 0; }
上述代碼對(duì)序列{ 6, 5, 3, 1, 8, 7, 2, 4 }進(jìn)行插入排序的實(shí)現(xiàn)過(guò)程如下
使用插入排序?yàn)橐涣袛?shù)字進(jìn)行排序的宏觀過(guò)程： 
插入排序不適合對(duì)于數(shù)據(jù)量比較大的排序應(yīng)用。但是，如果需要排序的數(shù)據(jù)量很小，比如量級(jí)小于千，那么插入排序還是一個(gè)不錯(cuò)的選擇。 插入排序在工業(yè)級(jí)庫(kù)中也有著廣泛的應(yīng)用，在STL的sort算法和stdlib的qsort算法中，都將插入排序作為快速排序的補(bǔ)充，用于少量元素的排序（通常為8個(gè)或以下）。
插入排序的改進(jìn)：二分插入排序
對(duì)于插入排序，如果比較操作的代價(jià)比交換操作大的話，可以采用二分查找法來(lái)減少比較操作的次數(shù)，我們稱為二分插入排序，代碼如下：
#include <stdio.h> // 分類 -------------- 內(nèi)部比較排序 // 數(shù)據(jù)結(jié)構(gòu) ---------- 數(shù)組 // 最差時(shí)間復(fù)雜度 ---- O(n^2) // 最優(yōu)時(shí)間復(fù)雜度 ---- O(nlogn) // 平均時(shí)間復(fù)雜度 ---- O(n^2) // 所需輔助空間 ------ O(1) // 穩(wěn)定性 ------------ 穩(wěn)定 void InsertionSortDichotomy(int A[], int n) { for (int i = 1; i < n; i++) { int get = A[i]; // 右手抓到一張撲克牌 int left = 0; // 拿在左手上的牌總是排序好的，所以可以用二分法 int right = i - 1; // 手牌左右邊界進(jìn)行初始化 while (left <= right) // 采用二分法定位新牌的位置 { int mid = (left + right) / 2; if (A[mid] > get) right = mid - 1; else left = mid + 1; } for (int j = i - 1; j >= left; j--) // 將欲插入新牌位置右邊的牌整體向右移動(dòng)一個(gè)單位 { A[j + 1] = A[j]; } A[left] = get; // 將抓到的牌插入手牌 } } int main() { int A[] = { 5, 2, 9, 4, 7, 6, 1, 3, 8 };// 從小到大二分插入排序 int n = sizeof(A) / sizeof(int); InsertionSortDichotomy(A, n); printf("二分插入排序結(jié)果："); for (int i = 0; i < n; i++) { printf("%d ", A[i]); } printf("\n"); return 0; }
當(dāng)n較大時(shí)，二分插入排序的比較次數(shù)比直接插入排序的最差情況好得多，但比直接插入排序的最好情況要差，所當(dāng)以元素初始序列已經(jīng)接近升序時(shí)，直接插入排序比二分插入排序比較次數(shù)少。二分插入排序元素移動(dòng)次數(shù)與直接插入排序相同，依賴于元素初始序列。
插入排序的更高效改進(jìn)：希爾排序(Shell Sort)
希爾排序，也叫遞減增量排序，是插入排序的一種更高效的改進(jìn)版本。希爾排序是不穩(wěn)定的排序算法。
希爾排序是基于插入排序的以下兩點(diǎn)性質(zhì)而提出改進(jìn)方法的：
- 插入排序在對(duì)幾乎已經(jīng)排好序的數(shù)據(jù)操作時(shí)，效率高，即可以達(dá)到線性排序的效率
- 但插入排序一般來(lái)說(shuō)是低效的，因?yàn)椴迦肱判蛎看沃荒軐?shù)據(jù)移動(dòng)一位
希爾排序通過(guò)將比較的全部元素分為幾個(gè)區(qū)域來(lái)提升插入排序的性能。這樣可以讓一個(gè)元素可以一次性地朝最終位置前進(jìn)一大步。然后算法再取越來(lái)越小的步長(zhǎng)進(jìn)行排序，算法的最后一步就是普通的插入排序，但是到了這步，需排序的數(shù)據(jù)幾乎是已排好的了（此時(shí)插入排序較快）。
假設(shè)有一個(gè)很小的數(shù)據(jù)在一個(gè)已按升序排好序的數(shù)組的末端。如果用復(fù)雜度為O(n^2)的排序（冒泡排序或直接插入排序），可能會(huì)進(jìn)行n次的比較和交換才能將該數(shù)據(jù)移至正確位置。而希爾排序會(huì)用較大的步長(zhǎng)移動(dòng)數(shù)據(jù)，所以小數(shù)據(jù)只需進(jìn)行少數(shù)比較和交換即可到正確位置。
希爾排序的代碼如下：
#include <stdio.h> // 分類 -------------- 內(nèi)部比較排序 // 數(shù)據(jù)結(jié)構(gòu) ---------- 數(shù)組 // 最差時(shí)間復(fù)雜度 ---- 根據(jù)步長(zhǎng)序列的不同而不同。已知最好的為O(n(logn)^2) // 最優(yōu)時(shí)間復(fù)雜度 ---- O(n) // 平均時(shí)間復(fù)雜度 ---- 根據(jù)步長(zhǎng)序列的不同而不同。 // 所需輔助空間 ------ O(1) // 穩(wěn)定性 ------------ 不穩(wěn)定 void ShellSort(int A[], int n) { int h = 0; while (h <= n) // 生成初始增量 { h = 3 * h + 1; } while (h >= 1) { for (int i = h; i < n; i++) { int j = i - h; int get = A[i]; while (j >= 0 && A[j] > get) { A[j + h] = A[j]; j = j - h; } A[j + h] = get; } h = (h - 1) / 3; // 遞減增量 } } int main() { int A[] = { 5, 2, 9, 4, 7, 6, 1, 3, 8 };// 從小到大希爾排序 int n = sizeof(A) / sizeof(int); ShellSort(A, n); printf("希爾排序結(jié)果："); for (int i = 0; i < n; i++) { printf("%d ", A[i]); } printf("\n"); return 0; }
以23, 10, 4, 1的步長(zhǎng)序列進(jìn)行希爾排序： 
希爾排序是不穩(wěn)定的排序算法，雖然一次插入排序是穩(wěn)定的，不會(huì)改變相同元素的相對(duì)順序，但在不同的插入排序過(guò)程中，相同的元素可能在各自的插入排序中移動(dòng)，最后其穩(wěn)定性就會(huì)被打亂。
比如序列：{ 3, 5, 10, 8, 7, 2, 8, 1, 20, 6 }，h=2時(shí)分成兩個(gè)子序列 { 3, 10, 7, 8, 20 } 和 { 5, 8, 2, 1, 6 } ，未排序之前第二個(gè)子序列中的8在前面，現(xiàn)在對(duì)兩個(gè)子序列進(jìn)行插入排序，得到 { 3, 7, 8, 10, 20 } 和 { 1, 2, 5, 6, 8 } ，即 { 3, 1, 7, 2, 8, 5, 10, 6, 20, 8 } ，兩個(gè)8的相對(duì)次序發(fā)生了改變。
歸并排序(Merge Sort)
歸并排序是創(chuàng)建在歸并操作上的一種有效的排序算法，效率為O(nlogn)，1945年由馮·諾伊曼首次提出。
歸并排序的實(shí)現(xiàn)分為遞歸實(shí)現(xiàn)與非遞歸(迭代)實(shí)現(xiàn)。遞歸實(shí)現(xiàn)的歸并排序是算法設(shè)計(jì)中分治策略的典型應(yīng)用，我們將一個(gè)大問(wèn)題分割成小問(wèn)題分別解決，然后用所有小問(wèn)題的答案來(lái)解決整個(gè)大問(wèn)題。非遞歸(迭代)實(shí)現(xiàn)的歸并排序首先進(jìn)行是兩兩歸并，然后四四歸并，然后是八八歸并，一直下去直到歸并了整個(gè)數(shù)組。
歸并排序算法主要依賴歸并(Merge)操作。歸并操作指的是將兩個(gè)已經(jīng)排序的序列合并成一個(gè)序列的操作，歸并操作步驟如下：
- 申請(qǐng)空間，使其大小為兩個(gè)已經(jīng)排序序列之和，該空間用來(lái)存放合并后的序列
- 設(shè)定兩個(gè)指針，最初位置分別為兩個(gè)已經(jīng)排序序列的起始位置
- 比較兩個(gè)指針?biāo)赶虻脑?，選擇相對(duì)小的元素放入到合并空間，并移動(dòng)指針到下一位置
- 重復(fù)步驟3直到某一指針到達(dá)序列尾
- 將另一序列剩下的所有元素直接復(fù)制到合并序列尾
歸并排序的代碼如下：
#include <stdio.h> #include <limits.h> // 分類 -------------- 內(nèi)部比較排序 // 數(shù)據(jù)結(jié)構(gòu) ---------- 數(shù)組 // 最差時(shí)間復(fù)雜度 ---- O(nlogn) // 最優(yōu)時(shí)間復(fù)雜度 ---- O(nlogn) // 平均時(shí)間復(fù)雜度 ---- O(nlogn) // 所需輔助空間 ------ O(n) // 穩(wěn)定性 ------------ 穩(wěn)定 void Merge(int A[], int left, int mid, int right)// 合并兩個(gè)已排好序的數(shù)組A[left...mid]和A[mid+1...right] { int len = right - left + 1; int *temp = new int[len]; // 輔助空間O(n) int index = 0; int i = left; // 前一數(shù)組的起始元素 int j = mid + 1; // 后一數(shù)組的起始元素 while (i <= mid && j <= right) { temp[index++] = A[i] <= A[j] ? A[i++] : A[j++]; // 帶等號(hào)保證歸并排序的穩(wěn)定性 } while (i <= mid) { temp[index++] = A[i++]; } while (j <= right) { temp[index++] = A[j++]; } for (int k = 0; k < len; k++) { A[left++] = temp[k]; } } void MergeSortRecursion(int A[], int left, int right) // 遞歸實(shí)現(xiàn)的歸并排序(自頂向下) { if (left == right) // 當(dāng)待排序的序列長(zhǎng)度為1時(shí)，遞歸開始回溯，進(jìn)行merge操作 return; int mid = (left + right) / 2; MergeSortRecursion(A, left, mid); MergeSortRecursion(A, mid + 1, right); Merge(A, left, mid, right); } void MergeSortIteration(int A[], int len) // 非遞歸(迭代)實(shí)現(xiàn)的歸并排序(自底向上) { int left, mid, right;// 子數(shù)組索引,前一個(gè)為A[left...mid]，后一個(gè)子數(shù)組為A[mid+1...right] for (int i = 1; i < len; i *= 2) // 子數(shù)組的大小i初始為1，每輪翻倍 { left = 0; while (left + i < len) // 后一個(gè)子數(shù)組存在(需要?dú)w并) { mid = left + i - 1; right = mid + i < len ? mid + i : len - 1;// 后一個(gè)子數(shù)組大小可能不夠 Merge(A, left, mid, right); left = right + 1; // 前一個(gè)子數(shù)組索引向后移動(dòng) } } } int main() { int A1[] = { 6, 5, 3, 1, 8, 7, 2, 4 }; // 從小到大歸并排序 int A2[] = { 6, 5, 3, 1, 8, 7, 2, 4 }; int n1 = sizeof(A1) / sizeof(int); int n2 = sizeof(A2) / sizeof(int); MergeSortRecursion(A1, 0, n1 - 1); // 遞歸實(shí)現(xiàn) MergeSortIteration(A2, n2); // 非遞歸實(shí)現(xiàn) printf("遞歸實(shí)現(xiàn)的歸并排序結(jié)果："); for (int i = 0; i < n1; i++) { printf("%d ", A1[i]); } printf("\n"); printf("非遞歸實(shí)現(xiàn)的歸并排序結(jié)果："); for (int i = 0; i < n2; i++) { printf("%d ", A2[i]); } printf("\n"); return 0; }
上述代碼對(duì)序列{ 6, 5, 3, 1, 8, 7, 2, 4 }進(jìn)行歸并排序的實(shí)例如下
使用歸并排序?yàn)橐涣袛?shù)字進(jìn)行排序的宏觀過(guò)程： 
歸并排序除了可以對(duì)數(shù)組進(jìn)行排序，還可以高效的求出數(shù)組小和（即單調(diào)和）以及數(shù)組中的逆序?qū)?，詳見這篇博文。
堆排序(Heap Sort)
堆排序是指利用堆這種數(shù)據(jù)結(jié)構(gòu)所設(shè)計(jì)的一種選擇排序算法。堆是一種近似完全二叉樹的結(jié)構(gòu)（通常堆是通過(guò)一維數(shù)組來(lái)實(shí)現(xiàn)的），并滿足性質(zhì)：以最大堆（也叫大根堆、大頂堆）為例，其中父結(jié)點(diǎn)的值總是大于它的孩子節(jié)點(diǎn)。
我們可以很容易的定義堆排序的過(guò)程：
- 由輸入的無(wú)序數(shù)組構(gòu)造一個(gè)最大堆，作為初始的無(wú)序區(qū)
- 把堆頂元素（最大值）和堆尾元素互換
- 把堆（無(wú)序區(qū)）的尺寸縮小1，并調(diào)用heapify(A, 0)從新的堆頂元素開始進(jìn)行堆調(diào)整
- 重復(fù)步驟2，直到堆的尺寸為1
堆排序的代碼如下：
#include <stdio.h> // 分類 -------------- 內(nèi)部比較排序 // 數(shù)據(jù)結(jié)構(gòu) ---------- 數(shù)組 // 最差時(shí)間復(fù)雜度 ---- O(nlogn) // 最優(yōu)時(shí)間復(fù)雜度 ---- O(nlogn) // 平均時(shí)間復(fù)雜度 ---- O(nlogn) // 所需輔助空間 ------ O(1) // 穩(wěn)定性 ------------ 不穩(wěn)定 void Swap(int A[], int i, int j) { int temp = A[i]; A[i] = A[j]; A[j] = temp; } void Heapify(int A[], int i, int size) // 從A[i]向下進(jìn)行堆調(diào)整 { int left_child = 2 * i + 1; // 左孩子索引 int right_child = 2 * i + 2; // 右孩子索引 int max = i; // 選出當(dāng)前結(jié)點(diǎn)與其左右孩子三者之中的最大值 if (left_child < size && A[left_child] > A[max]) max = left_child; if (right_child < size && A[right_child] > A[max]) max = right_child; if (max != i) { Swap(A, i, max); // 把當(dāng)前結(jié)點(diǎn)和它的最大(直接)子節(jié)點(diǎn)進(jìn)行交換 Heapify(A, max, size); // 遞歸調(diào)用，繼續(xù)從當(dāng)前結(jié)點(diǎn)向下進(jìn)行堆調(diào)整 } } int BuildHeap(int A[], int n) // 建堆，時(shí)間復(fù)雜度O(n) { int heap_size = n; for (int i = heap_size / 2 - 1; i >= 0; i--) // 從每一個(gè)非葉結(jié)點(diǎn)開始向下進(jìn)行堆調(diào)整 Heapify(A, i, heap_size); return heap_size; } void HeapSort(int A[], int n) { int heap_size = BuildHeap(A, n); // 建立一個(gè)最大堆 while (heap_size > 1) // 堆（無(wú)序區(qū)）元素個(gè)數(shù)大于1，未完成排序 { // 將堆頂元素與堆的最后一個(gè)元素互換，并從堆中去掉最后一個(gè)元素 // 此處交換操作很有可能把后面元素的穩(wěn)定性打亂，所以堆排序是不穩(wěn)定的排序算法 Swap(A, 0, --heap_size); Heapify(A, 0, heap_size); // 從新的堆頂元素開始向下進(jìn)行堆調(diào)整，時(shí)間復(fù)雜度O(logn) } } int main() { int A[] = { 5, 2, 9, 4, 7, 6, 1, 3, 8 };// 從小到大堆排序 int n = sizeof(A) / sizeof(int); HeapSort(A, n); printf("堆排序結(jié)果："); for (int i = 0; i < n; i++) { printf("%d ", A[i]); } printf("\n"); return 0; }
堆排序算法的演示： 
動(dòng)畫中在排序過(guò)程之前簡(jiǎn)單的表現(xiàn)了創(chuàng)建堆的過(guò)程以及堆的邏輯結(jié)構(gòu)。
堆排序是不穩(wěn)定的排序算法，不穩(wěn)定發(fā)生在堆頂元素與A[i]交換的時(shí)刻。
比如序列：{ 9, 5, 7, 5 }，堆頂元素是9，堆排序下一步將9和第二個(gè)5進(jìn)行交換，得到序列 { 5, 5, 7, 9 }，再進(jìn)行堆調(diào)整得到{ 7, 5, 5, 9 }，重復(fù)之前的操作最后得到{ 5, 5, 7, 9 }從而改變了兩個(gè)5的相對(duì)次序。
快速排序(Quick Sort)
快速排序是由東尼·霍爾所發(fā)展的一種排序算法。在平均狀況下，排序n個(gè)元素要O(nlogn)次比較。在最壞狀況下則需要O(n^2)次比較，但這種狀況并不常見。事實(shí)上，快速排序通常明顯比其他O(nlogn)算法更快，因?yàn)樗膬?nèi)部循環(huán)可以在大部分的架構(gòu)上很有效率地被實(shí)現(xiàn)出來(lái)。
快速排序使用分治策略(Divide and Conquer)來(lái)把一個(gè)序列分為兩個(gè)子序列。步驟為：
- 從序列中挑出一個(gè)元素，作為"基準(zhǔn)"(pivot).
- 把所有比基準(zhǔn)值小的元素放在基準(zhǔn)前面，所有比基準(zhǔn)值大的元素放在基準(zhǔn)的后面（相同的數(shù)可以到任一邊），這個(gè)稱為分區(qū)(partition)操作。
- 對(duì)每個(gè)分區(qū)遞歸地進(jìn)行步驟1~2，遞歸的結(jié)束條件是序列的大小是0或1，這時(shí)整體已經(jīng)被排好序了。
快速排序的代碼如下：
#include <stdio.h> // 分類 ------------ 內(nèi)部比較排序 // 數(shù)據(jù)結(jié)構(gòu) --------- 數(shù)組 // 最差時(shí)間復(fù)雜度 ---- 每次選取的基準(zhǔn)都是最大（或最?。┑脑?，導(dǎo)致每次只劃分出了一個(gè)分區(qū)，需要進(jìn)行n-1次劃分才能結(jié)束遞歸，時(shí)間復(fù)雜度為O(n^2) // 最優(yōu)時(shí)間復(fù)雜度 ---- 每次選取的基準(zhǔn)都是中位數(shù)，這樣每次都均勻的劃分出兩個(gè)分區(qū)，只需要logn次劃分就能結(jié)束遞歸，時(shí)間復(fù)雜度為O(nlogn) // 平均時(shí)間復(fù)雜度 ---- O(nlogn) // 所需輔助空間 ------ 主要是遞歸造成的棧空間的使用(用來(lái)保存left和right等局部變量)，取決于遞歸樹的深度，一般為O(logn)，最差為O(n) // 穩(wěn)定性 ---------- 不穩(wěn)定 void Swap(int A[], int i, int j) { int temp = A[i]; A[i] = A[j]; A[j] = temp; } int Partition(int A[], int left, int right) // 劃分函數(shù) { int pivot = A[right]; // 這里每次都選擇最后一個(gè)元素作為基準(zhǔn) int tail = left - 1; // tail為小于基準(zhǔn)的子數(shù)組最后一個(gè)元素的索引 for (int i = left; i < right; i++) // 遍歷基準(zhǔn)以外的其他元素 { if (A[i] <= pivot) // 把小于等于基準(zhǔn)的元素放到前一個(gè)子數(shù)組末尾 { Swap(A, ++tail, i); } } Swap(A, tail + 1, right); // 最后把基準(zhǔn)放到前一個(gè)子數(shù)組的后邊，剩下的子數(shù)組既是大于基準(zhǔn)的子數(shù)組 // 該操作很有可能把后面元素的穩(wěn)定性打亂，所以快速排序是不穩(wěn)定的排序算法 return tail + 1; // 返回基準(zhǔn)的索引 } void QuickSort(int A[], int left, int right) { if (left >= right) return; int pivot_index = Partition(A, left, right); // 基準(zhǔn)的索引 QuickSort(A, left, pivot_index - 1); QuickSort(A, pivot_index + 1, right); } int main() { int A[] = { 5, 2, 9, 4, 7, 6, 1, 3, 8 }; // 從小到大快速排序 int n = sizeof(A) / sizeof(int); QuickSort(A, 0, n - 1); printf("快速排序結(jié)果："); for (int i = 0; i < n; i++) { printf("%d ", A[i]); } printf("\n"); return 0; }
使用快速排序法對(duì)一列數(shù)字進(jìn)行排序的過(guò)程： 
快速排序是不穩(wěn)定的排序算法，不穩(wěn)定發(fā)生在基準(zhǔn)元素與A[tail+1]交換的時(shí)刻。
比如序列：{ 1, 3, 4, 2, 8, 9, 8, 7, 5 }，基準(zhǔn)元素是5，一次劃分操作后5要和第一個(gè)8進(jìn)行交換，從而改變了兩個(gè)元素8的相對(duì)次序。
Java系統(tǒng)提供的Arrays.sort函數(shù)。對(duì)于基礎(chǔ)類型，底層使用快速排序。對(duì)于非基礎(chǔ)類型，底層使用歸并排序。請(qǐng)問(wèn)是為什么？
答：這是考慮到排序算法的穩(wěn)定性。對(duì)于基礎(chǔ)類型，相同值是無(wú)差別的，排序前后相同值的相對(duì)位置并不重要，所以選擇更為高效的快速排序，盡管它是不穩(wěn)定的排序算法；而對(duì)于非基礎(chǔ)類型，排序前后相等實(shí)例的相對(duì)位置不宜改變，所以選擇穩(wěn)定的歸并排序。
如對(duì)本文有疑問(wèn)，請(qǐng)?zhí)峤坏浇涣髡搲?，廣大熱心網(wǎng)友會(huì)為你解答??！ 點(diǎn)擊進(jìn)入論壇
