排序算法是算法的入門知識，其經典思想可以用於很多算法當中。因爲其實現代碼較短，應用較常見。所以在面試中經常會問到排序算法及其相關的問題。但萬變不離其宗，只要熟悉了思想，靈活運用也不是難事。一般在面試中最常考的是快速排序和歸併排序，並且經常有面試官要求現場寫出這兩種排序的代碼。對這兩種排序的代碼一定要信手拈來才行。還有插入排序、冒泡排序、堆排序、選擇排序、基數排序、桶排序等。面試官對於這些排序可能會要求比較各自的優劣、各種算法的思想及其使用場景。還有要會分析算法的時間和空間複雜度。通常查找和排序算法的考察是面試的開始，如果這些問題回答不好，估計面試官都沒有繼續面試下去的興趣都沒了。所以想開個好頭就要把常見的排序算法思想及其特點要熟練掌握，有必要熟練寫出代碼[1]。
對排序算法的分類方式也有很多種[2]:
1、計算的時間複雜度（最差、平均、和最好性能），依據列表（list）的大小(n)。一般而言，好的性能是O(n log n)，壞的性能是O(n2)。對於一個排序理想的性能是O(n)，但平均而言不可能達到。基於比較的排序算法對大多數輸入而言至少需要O(n log n)。
2、空間複雜度。
3、穩定性：穩定排序算法會讓原本有相等鍵值的紀錄維持相對次序。也就是如果一個排序算法是穩定的，當有兩個相等鍵值的紀錄R和S，且在原本的列表中R出現在S之前，在排序過的列表中R也將會是在S之前。
4、排序的方法：交換、選擇、插入、合併等等。
首先給出一個對比的表格，以便從整體上理解排序算法：
接下來我們按照
交換排序：冒泡排序、快速排序
選擇排序：選擇排序、堆排序
插入排序：插入排序
歸併排序：歸併排序
的順序、分析一下這六種常見的排序算法及其使用場景。限於篇幅，某些算法的詳細演示和圖示請在算法導論中尋找詳細的參考。值得一提的是，本文中的代碼思想都源自算法導論，如果有不明白的代碼請翻閱算法導論一書。本文專爲面試前突擊而作，套路和思想和算法導論一模一樣，即以方便記憶爲主。
交換排序
交換排序的基本方法是在待排序的元素中選擇兩個元素，將他們的值進行比較，如果反序則交換他們的位置，直到沒有反序的記錄爲止。交換排序中常見的是冒泡排序和快速排序。
冒泡排序
冒泡排序算法的僞代碼如下：
function bubble_sort (array, length) {
var i, j;
for(i from 0 to length-1){
for(j from 0 to length-1-i){
if (array[j] > array[j+1])
swap(array[j], array[j+1])
}
}
}參考僞代碼不難寫出代碼：
/**
* @param arr
* 1、冒泡排序
* 冒泡排序時間複雜度O(n^2)，比較次數多，交換次數多。因此是效率極低的算法。
* 冒泡排序是一種穩定的算法。
*/
public static void bubbleSort(int[] arr){
int len = arr.length;
for(int i = 0; i < len - 1; i++){
for(int j = 0; j < len - 1 - i; j++){
if(arr[j] > arr[j + 1]){
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
} 冒泡排序對n個項目需要O(n^2)的比較次數，且可以原地排序。儘管這個算法是最簡單瞭解和實現的排序算法之一，但冒泡排序的實現通常會對已經排序好的數列拙劣地運行O(n^2),它對於包含大量的元素的數列排序是很沒有效率的。
快速排序
快速排序是冒泡排序的一種改進，冒泡排序排完一趟是最大值冒出來了，那麼可不可以先選定一個值，然後掃描待排序序列，把小於該值的記錄和大於該值的記錄分成兩個單獨的序列，然後分別對這兩個序列進行上述操作。這就是快速排序，我們把選定的那個值稱爲樞紐值，如果樞紐值爲序列中的最大值，那麼一趟快速排序就變成了一趟冒泡排序。
快速排序是基於分治模式的[3]：
分解：數組A【p..r】被劃分成兩個（可能空）子數組A【p..q-1】和A【q+1..r】，使得A【p..q-1】中的每個元素都小於等於A(q)，而且，小於等於A【q+1..r】中的元素。下 標q 也在返個劃分過程中迕行計算。
解決：通過遞歸調用快速排序，對子數組A【p..q-1】和A【q+1..r】排序。
合併：因爲兩個子數組使就地排序的，將它們的合併不需要操作：整個數組A【p..r】已排序。
/**
* @param arr
* @param p
* @param r
* 2、快排
* 快排最壞時間複雜度O(n^2)，平均時間複雜度O(nlgn)。空間複雜度爲O(nlgn)。
* 快排是一種不穩定的算法。
*/
public static void quickSort(int[] arr, int p, int r){
if(p < r){
int q = partition(arr, p, r);
quickSort(arr, p, q - 1);
quickSort(arr, q + 1, r);
}
return;
}
public static int partition(int[] arr, int p, int r){
int x = arr[r];
int i = p - 1;
for(int j = p; j < r; j++){
if(arr[j] < x){
swap(arr, ++i, j);
}
}
swap(arr, ++i, r);
return i;
}
private static void swap(int[] arr, int i,int j){
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}快速排序是最常用的一種排序算法，包括C的qsort，C++和Java的sort，都採用了快排（C++和Java的sort經過了優化，還混合了其他排序算法）。
快排最壞情況O( n^2 )，但平均效率O(n lg n)，而且這個O(n lg n)幾號中隱含的常數因子很小，快排可以說是最快的排序算法，並非浪得虛名。另外它還是就地排序。
舉一個例子，java中arrays.sort()方法：
1）當待排序的數組中的元素個數較少時，源碼中的閥值爲7，採用的是插入排序。儘管插入排序的時間複雜度爲0(n^2)，但是當數組元素較少時，插入排序優於快速排序，因爲這時快速排序的遞歸操作影響性能。
2）較好的選擇了劃分元（基準元素）。能夠將數組分成大致兩個相等的部分，避免出現最壞的情況。例如當數組有序的的情況下，選擇第一個元素作爲劃分元，將使得算法的時間複雜度達到O(n^2).
源碼中選擇劃分元的方法:
當數組大小爲 size=7 時 ，取數組中間元素作爲劃分元。int n=m>>1;(此方法值得借鑑)
當數組大小 7
選擇排序
選擇排序的基本思想是，每趟排序在待排序序列中，選擇值較小的元素，順序添加到有序序列的最後，直到全部記錄排序完畢。常用的有簡單選擇排序和堆排序。
簡單選擇排序
簡單選擇排序是一種簡單直觀的排序算法。它的工作原理如下。首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然後，再從剩餘未排序元素中繼續尋找最小（大）元素，然後放到已排序序列的末尾。以此類推，直到所有元素均排序完畢。
/**
* @param arr
* 3、選擇排序
* 選擇排序時間複雜度O(n^2)。比較次數多，交換次數少。
* 選擇排序是一種不穩定的排序算法。例如:(7) 2 5 9 3 4 [7] 1...
* 當我們利用直接選擇排序算法進行排序時,(7)和1調換,(7)就在[7]的後面了,原來的次序改變,這樣就不穩定.
*/
public static void selectSort(int[] arr){
int len = arr.length;
for(int i = 0; i < len - 1; i++){
int min = i;
for(int j = i + 1; j < len; j ++){
if(arr[min] > arr[j]){
min = j;
}
}
swap(arr, i, min);
}
}簡單選擇排序是移動次數最少的算法。原始序列爲正序時，比較次數O( n^2 )，移動次數爲0；逆序時，比較次數O( n^2 )，移動次數O( n )。平均情況下時間複雜度O( n^2 )，空間複雜度O( 1 )。
另外簡單選擇排序是不穩定的；簡單選擇排序是原地排序。
堆排序
在堆的數據結構中，堆中的最大值總是位於根節點(在優先隊列中使用堆的話堆中的最小值位於根節點)。堆排序需要用到堆中定義以下三個種操作：
- 最大堆調整（Max_Heapify）：將堆的末端子節點作調整，使得子節點永遠小於父節點。
- 創建最大堆（Build_Max_Heap）：將堆所有數據重新排序。
- 堆排序（HeapSort）：移除位在第一個數據的根節點，並做最大堆調整的遞歸運算。
/**
* @param arr
* 4、堆排序
* 堆排序有三個操作：1、維護堆性質；2、建堆；3、堆排序
* 1、維護堆性質，時間複雜度爲O(lgn)
* 2、建堆，時間複雜度O(n)
* 3、堆排序，n-1次調用維護堆性質函數，每次時間複雜度爲O(lgn)，因此總體時間複雜度爲O(nlgn)。
* 空間複雜度爲O(lgn)
* 堆排序是一種不穩定的排序。
*/
public static void heapSort(int[] arr){
/*
* 第一步：將數組堆化
* beginIndex = 第一個非葉子節點。
* 從第一個非葉子節點開始即可。無需從最後一個葉子節點開始。
* 葉子節點可以看作已符合堆要求的節點，根節點就是它自己且自己以下值爲最大。
*/
int len = arr.length - 1;
int beginIndex = (len - 1) >> 1;
for(int i = beginIndex; i >= 0; i--){
maxHeapify(arr, i, len);
}
/*
* 第二步：對堆化數據排序
* 每次都是移出最頂層的根節點A[0]，與最尾部節點位置調換，同時遍歷長度 - 1。
* 然後從新整理被換到根節點的末尾元素，使其符合堆的特性。
* 直至未排序的堆長度爲 0。
*/
for(int i = len; i > 0; i--){
swap(arr, 0, i);
maxHeapify(arr, 0, i - 1);
}
}
/**
* 調整索引爲 index 處的數據，使其符合堆的特性。
*
* @param index 需要堆化處理的數據的索引
* @param len 未排序的堆（數組）的長度
*/
public static void maxHeapify(int[] arr, int i, int len){
int l = 2 * i + 1; // 左子節點索引
int r = l + 1; // 右子節點索引
int largest = i; // 默認父節點索引爲最大值索引
if(l <= len && arr[l] > arr[i]){ //判斷左子節點是否比父節點大
largest = l;
}
if(r <= len && arr[r] > arr[largest]){ //判斷右子節點是否比父節點大
largest = r;
}
if(largest != i){
swap(arr, i, largest); // 如果父節點被子節點調換，
maxHeapify(arr, largest, len); // 則需要繼續判斷換下後的父節點是否符合堆的特性。
}
}插入排序
插入排序不是通過交換位置，而是通過比較找到合適的位置插入元素。類似於打撲克牌，整牌的時候就是拿到一張牌，找到一個合適的位置插入。這個原理其實和插入排序是一樣的。
直接插入排序
/**
* @param arr
* 5、插入排序
* 插入排序平均時間複雜度爲O(n^2)，空間複雜度爲O(1)。
* 直接插入排序是一種穩定的算法，當數組長度較小時，效果要比快排好。
*/
public static void insertSort(int[] arr){
int len = arr.length;
for(int i = 1; i < len; i++){
int temp = arr[i];
int j = i - 1;
// 找到合適的位置j來插入arr[i]
while(j >= 0 && arr[j] > temp){
arr[j + 1] = arr[j];
j--;
}
arr[j + 1] = temp;
}
}合併排序
合併排序的基本方法是，將兩個或兩個以上的有序序列歸併成一個有序序列。常見的算法有歸併排序。
歸併排序
/**
* @param arr
* 6、歸併排序
* 歸併排序平均時間複雜度爲O(nlgn)，空間複雜度爲O(n)。
* 歸併排序是一種穩定的算法。
*
*/
public static void mergeSort(int[] arr, int p, int r){
if (p < r){
int q = (p + r) / 2;
mergeSort(arr, p, q);
mergeSort(arr, q + 1, r);
merge(arr, p, q, r);
}
}
public static void merge(int[] arr, int p, int q, int r){
int len1 = q - p + 1;
int len2 = r - q;
// 創建長度爲len1和len2的新數組。
int[] arr1 = new int[len1 + 1];
int[] arr2 = new int[len2 + 1];
// 賦值，尾部值爲無窮。
for(int i = 0; i < len1; i++){
arr1[i] = arr[p + i];
}
for(int i = 0; i < len2; i++){
arr2[i] = arr[q + 1 + i];
}
arr1[len1] = Integer.MAX_VALUE;
arr2[len2] = Integer.MAX_VALUE;
// 比較兩個新數組的元素大小，將小的元素添加的arr，進行排序。
for(int k = 0, i = 0, j = 0; k < len1 + len2; k++){
if(arr1[i] < arr2[j]){
arr[p + k] = arr1[i++];
}else{
arr[p + k] = arr2[j++];
}
}
}參考文獻
[1] 面試中的 10 大排序算法總結
[2] 排序算法wiki
[3] 算法導論