前言
查詢和排序演算法是演算法的入門知識，其經典思想可以用於很多演算法當中。因為其實現程式碼較短，應用較常見。所以在面試中經常會問到排序演算法及其相關的問題。但萬變不離其宗，只要熟悉了思想，靈活運用也不是難事。一般在面試中最常考的是快速排序和歸併排序，並且經常有面試官要求現場寫出這兩種排序的程式碼。對這兩種排序的程式碼一定要信手拈來才行。還有插入排序、氣泡排序、堆排序、基數排序、桶排序等。
面試官對於這些排序可能會要求比較各自的優劣、各種演算法的思想及其使用場景。還有要會分析演算法的時間和空間複雜度。通常查詢和排序演算法的考察是面試的開始，如果這些問題回答不好，估計面試官都沒有繼續面試下去的興趣都沒了。所以想開個好頭就要把常見的排序演算法思想及其特點要熟練掌握，有必要時要熟練寫出程式碼。
接下來我們就分析一下常見的排序演算法及其使用場景。限於篇幅，某些演算法的詳細演示和圖示請自行尋找詳細的參考。
氣泡排序
氣泡排序是最簡單的排序之一了，其大體思想就是通過與相鄰元素的比較和交換來把小的數交換到最前面。這個過程類似於水泡向上升一樣，因此而得名。舉個例子，對5,3,8,6,4這個無序序列進行氣泡排序。首先從後向前冒泡，4和6比較，把4交換到前面，序列變成5,3,8,4,6。同理4和8交換，變成5,3,4,8,6,3和4無需交換。5和3交換，變成3,5,4,8,6,3.這樣一次冒泡就完了，把最小的數3排到最前面了。對剩下的序列依次冒泡就會得到一個有序序列。氣泡排序的時間複雜度為O(n^2)。
實現程式碼：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
/** *@Description:氣泡排序演算法實現 *@author 王旭 */ public class BubbleSort { public static void bubbleSort(int[] arr) { if(arr == null || arr.length == 0) return ; for(int i=0; i) { for(int j=arr.length-1; j>i; j--) { if(arr[j] ]) { swap(arr, j-1, j); } } } } public static void swap(int[] arr, int i, int j) { int temp = arr[i]; arr[i] = arr[j]; arr[j] = temp; } } |
選擇排序
選擇排序的思想其實和氣泡排序有點類似，都是在一次排序後把最小的元素放到最前面。但是過程不同，氣泡排序是通過相鄰的比較和交換。而選擇排序是通過對整體的選擇。舉個例子，對5,3,8,6,4這個無序序列進行簡單選擇排序，首先要選擇5以外的最小數來和5交換，也就是選擇3和5交換，一次排序後就變成了3,5,8,6,4.對剩下的序列一次進行選擇和交換，最終就會得到一個有序序列。其實選擇排序可以看成氣泡排序的優化，因為其目的相同，只是選擇排序只有在確定了最小數的前提下才進行交換，大大減少了交換的次數。選擇排序的時間複雜度為O(n^2)。
實現程式碼：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 |
/** *@Description:簡單選擇排序演算法的實現 *@author 王旭 */ public class SelectSort { public static void selectSort(int[] arr) { if(arr == null || arr.length == 0) return ; int minIndex = 0; for(int i=0; i//只需要比較n-1次 minIndex = i; for(int j=i+1; j//從i+1開始比較，因為minIndex預設為i了，i就沒必要比了。 if(arr[j] arr[minIndex]) { minIndex = j; } } if(minIndex != i) { //如果minIndex不為i，說明找到了更小的值，交換之。 swap(arr, i, minIndex); } } } public static void swap(int[] arr, int i, int j) { int temp = arr[i]; arr[i] = arr[j]; arr[j] = temp; } } |
插入排序
插入排序不是通過交換位置而是通過比較找到合適的位置插入元素來達到排序的目的的。相信大家都有過打撲克牌的經歷，特別是牌數較大的。在分牌時可能要整理自己的牌，牌多的時候怎麼整理呢？就是拿到一張牌，找到一個合適的位置插入。這個原理其實和插入排序是一樣的。舉個例子，對5,3,8,6,4這個無序序列進行簡單插入排序，首先假設第一個數的位置時正確的，想一下在拿到第一張牌的時候，沒必要整理。然後3要插到5前面，把5後移一位，變成3,5,8,6,4.想一下整理牌的時候應該也是這樣吧。然後8不用動，6插在8前面，8後移一位，4插在5前面，從5開始都向後移一位。注意在插入一個數的時候要保證這個數前面的數已經有序。簡單插入排序的時間複雜度也是O(n^2)。
實現程式碼：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 |
/** *@Description:簡單插入排序演算法實現 *@author 王旭 */ public class InsertSort { public static void insertSort(int[] arr) { if(arr == null || arr.length == 0) return ; for(int i=1; i//假設第一個數位置時正確的；要往後移，必須要假設第一個。 int j = i; int target = arr[i]; //待插入的 //後移 while(j > 0 & target ]) { arr[j] = arr[j-1]; j --; } //插入 arr[j] = target; } } } |
快速排序
快速排序一聽名字就覺得很高階，在實際應用當中快速排序確實也是表現最好的排序演算法。快速排序雖然高階，但其實其思想是來自氣泡排序，氣泡排序是通過相鄰元素的比較和交換把最小的冒泡到最頂端，而快速排序是比較和交換小數和大數，這樣一來不僅把小數冒泡到上面同時也把大數沉到下面。
舉個例子：對5,3,8,6,4這個無序序列進行快速排序，思路是右指標找比基準數小的，左指標找比基準數大的，交換之。
5,3,8,6,4 用5作為比較的基準，最終會把5小的移動到5的左邊，比5大的移動到5的右邊。
5,3,8,6,4 首先設定i,j兩個指標分別指向兩端，j指標先掃描（思考一下為什麼？）4比5小停止。然後i掃描，8比5大停止。交換i,j位置。
5,3,4,6,8 然後j指標再掃描，這時j掃描4時兩指標相遇。停止。然後交換4和基準數。
4,3,5,6,8 一次劃分後達到了左邊比5小，右邊比5大的目的。之後對左右子序列遞迴排序，最終得到有序序列。
上面留下來了一個問題為什麼一定要j指標先動呢？首先這也不是絕對的，這取決於基準數的位置，因為在最後兩個指標相遇的時候，要交換基準數到相遇的位置。一般選取第一個數作為基準數，那麼就是在左邊，所以最後相遇的數要和基準數交換，那麼相遇的數一定要比基準數小。所以j指標先移動才能先找到比基準數小的數。
快速排序是不穩定的，其時間平均時間複雜度是O(nlgn)。
實現程式碼：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 |
/** *@Description:實現快速排序演算法 *@author 王旭 */ public class QuickSort { //一次劃分 public static int partition(int[] arr, int left, int right) { int pivotKey = arr[left]; int pivotPointer = left; while(left right) { while(left = pivotKey) right --; while(left pivotKey) left ++; swap(arr, left, right); //把大的交換到右邊，把小的交換到左邊。 } swap(arr, pivotPointer, left); //最後把pivot交換到中間 return left; } public static void quickSort(int[] arr, int left, int right) { if(left >= right) return ; int pivotPos = partition(arr, left, right); quickSort(arr, left, pivotPos-1); quickSort(arr, pivotPos+1, right); } public static void sort(int[] arr) { if(arr == null || arr.length == 0) return ; quickSort(arr, 0, arr.length-1); } public static void swap(int[] arr, int left, int right) { int temp = arr[left]; arr[left] = arr[right]; arr[right] = temp; } } |
其實上面的程式碼還可以再優化，上面程式碼中基準數已經在pivotKey中儲存了，所以不需要每次交換都設定一個temp變數，在交換左右指標的時候只需要先後覆蓋就可以了。這樣既能減少空間的使用還能降低賦值運算的次數。優化程式碼如下：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 |
/** *@Description:實現快速排序演算法 *@author 王旭 */ public class QuickSort { /** * 劃分 * @param arr * @param left * @param right * @return */ public static int partition(int[] arr, int left, int right) { int pivotKey = arr[left]; while(left right) { while(left = pivotKey) right --; arr[left] = arr[right]; //把小的移動到左邊 while(left pivotKey) left ++; arr[right] = arr[left]; //把大的移動到右邊 } arr[left] = pivotKey; //最後把pivot賦值到中間 return left; } /** * 遞迴劃分子序列 * @param arr * @param left * @param right */ public static void quickSort(int[] arr, int left, int right) { if(left >= right) return ; int pivotPos = partition(arr, left, right); quickSort(arr, left, pivotPos-1); quickSort(arr, pivotPos+1, right); } public static void sort(int[] arr) { if(arr == null || arr.length == 0) return ; quickSort(arr, 0, arr.length-1); } } |
總結快速排序的思想：冒泡+二分+遞迴分治，慢慢體會。。。
堆排序
堆排序是藉助堆來實現的選擇排序，思想同簡單的選擇排序，以下以大頂堆為例。注意：如果想升序排序就使用大頂堆，反之使用小頂堆。原因是堆頂元素需要交換到序列尾部。
首先，實現堆排序需要解決兩個問題：
1. 如何由一個無序序列鍵成一個堆？
2. 如何在輸出堆頂元素之後，調整剩餘元素成為一個新的堆？
第一個問題，可以直接使用線性陣列來表示一個堆，由初始的無序序列建成一個堆就需要自底向上從第一個非葉元素開始挨個調整成一個堆。
第二個問題，怎麼調整成堆？首先是將堆頂元素和最後一個元素交換。然後比較當前堆頂元素的左右孩子節點，因為除了當前的堆頂元素，左右孩子堆均滿足條件，這時需要選擇當前堆頂元素與左右孩子節點的較大者（大頂堆）交換，直至葉子節點。我們稱這個自堆頂自葉子的調整成為篩選。
從一個無序序列建堆的過程就是一個反覆篩選的過程。若將此序列看成是一個完全二叉樹，則最後一個非終端節點是n/2取底個元素，由此篩選即可。舉個例子：
49,38,65,97,76,13,27,49序列的堆排序建初始堆和調整的過程如下：
實現程式碼：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 |
/** *@Description:堆排序演算法的實現，以大頂堆為例。 *@author 王旭 */ public class HeapSort { /** * 堆篩選，除了start之外，start~end均滿足大頂堆的定義。 * 調整之後start~end稱為一個大頂堆。 * @param arr 待調整陣列 * @param start 起始指標 * @param end 結束指標 */ public static void heapAdjust(int[] arr, int start, int end) { int temp = arr[start]; for(int i=2*start+1; i) { //左右孩子的節點分別為2*i+1,2*i+2 //選擇出左右孩子較小的下標 if(i ]) { i ++; } if(temp >= arr[i]) { break; //已經為大頂堆，=保持穩定性。 } arr[start] = arr[i]; //將子節點上移 start = i; //下一輪篩選 } arr[start] = temp; //插入正確的位置 } public static void heapSort(int[] arr) { if(arr == null || arr.length == 0) return ; //建立大頂堆 for(int i=arr.length/2; i>=0; i--) { heapAdjust(arr, i, arr.length-1); } for(int i=arr.length-1; i>=0; i--) { swap(arr, 0, i); heapAdjust(arr, 0, i-1); } } public static void swap(int[] arr, int i, int j) { int temp = arr[i]; arr[i] = arr[j]; arr[j] = temp; } } |
希爾排序
希爾排序是插入排序的一種高效率的實現，也叫縮小增量排序。簡單的插入排序中，如果待排序列是正序時，時間複雜度是O(n)，如果序列是基本有序的，使用直接插入排序效率就非常高。希爾排序就利用了這個特點。基本思想是：先將整個待排記錄序列分割成為若干子序列分別進行直接插入排序，待整個序列中的記錄基本有序時再對全體記錄進行一次直接插入排序。
舉個例子：
從上述排序過程可見，希爾排序的特點是，子序列的構成不是簡單的逐段分割，而是將某個相隔某個增量的記錄組成一個子序列。如上面的例子，第一堂排序時的增量為5，第二趟排序的增量為3。由於前兩趟的插入排序中記錄的關鍵字是和同一子序列中的前一個記錄的關鍵字進行比較，因此關鍵字較小的記錄就不是一步一步地向前挪動，而是跳躍式地往前移，從而使得進行最後一趟排序時，整個序列已經做到基本有序，只要作記錄的少量比較和移動即可。因此希爾排序的效率要比直接插入排序高。
希爾排序的分析是複雜的，時間複雜度是所取增量的函式，這涉及一些數學上的難題。但是在大量實驗的基礎上推出當n在某個範圍內時，時間複雜度可以達到O(n^1.3)。
實現程式碼：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 |
/** *@Description:希爾排序演算法實現 *@author 王旭 */ public class ShellSort { /** * 希爾排序的一趟插入 * @param arr 待排陣列 * @param d 增量 */ public static void shellInsert(int[] arr, int d) { for(int i=d; i) { int j = i - d; int temp = arr[i]; //記錄要插入的資料 while (j>=0 & arr[j]>temp) { //從後向前，找到比其小的數的位置 arr[j+d] = arr[j]; //向後挪動 j -= d; } if (j != i - d) //存在比其小的數 arr[j+d] = temp; } } public static void shellSort(int[] arr) { if(arr == null || arr.length == 0) return ; int d = arr.length / 2; while(d >= 1) { shellInsert(arr, d); d /= 2; } } } |
歸併排序
歸併排序是另一種不同的排序方法，因為歸併排序使用了遞迴分治的思想，所以理解起來比較容易。其基本思想是，先遞迴劃分子問題，然後合併結果。把待排序列看成由兩個有序的子序列，然後合併兩個子序列，然後把子序列看成由兩個有序序列。。。。。倒著來看，其實就是先兩兩合併，然後四四合並。。。最終形成有序序列。空間複雜度為O(n)，時間複雜度為O(nlogn)。
舉個例子：
實現程式碼：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 |
/** *@Description:歸併排序演算法的實現 *@author 王旭 */ public class MergeSort { public static void mergeSort(int[] arr) { mSort(arr, 0, arr.length-1); } /** * 遞迴分治 * @param arr 待排陣列 * @param left 左指標 * @param right 右指標 */ public static void mSort(int[] arr, int left, int right) { if(left >= right) return ; int mid = (left + right) / 2; mSort(arr, left, mid); //遞迴排序左邊 mSort(arr, mid+1, right); //遞迴排序右邊 merge(arr, left, mid, right); //合併 } /** * 合併兩個有序陣列 * @param arr 待合併陣列 * @param left 左指標 * @param mid 中間指標 * @param right 右指標 */ public static void merge(int[] arr, int left, int mid, int right) { //[left, mid] [mid+1, right] int[] temp = new int[right - left + 1]; //中間陣列 int i = left; int j = mid + 1; int k = 0; while(i right) { if(arr[i] arr[j]) { temp[k++] = arr[i++]; } else { temp[k++] = arr[j++]; } } while(i mid) { temp[k++] = arr[i++]; } while(j right) { temp[k++] = arr[j++]; } for(int p=0; p) { arr[left + p] = temp[p]; } } } |
計數排序
如果在面試中有面試官要求你寫一個O(n)時間複雜度的排序演算法，你千萬不要立刻說：這不可能！雖然前面基於比較的排序的下限是O(nlogn)。但是確實也有線性時間複雜度的排序，只不過有前提條件，就是待排序的數要滿足一定的範圍的整數，而且計數排序需要比較多的輔助空間。其基本思想是，用待排序的數作為計數陣列的下標，統計每個數字的個數。然後依次輸出即可得到有序序列。
實現程式碼：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 |
/** *@Description:計數排序演算法實現 *@author 王旭 */ public class CountSort { public static void countSort(int[] arr) { if(arr == null || arr.length == 0) return ; int max = max(arr); int[] count = new int[max+1]; Arrays.fill(count, 0); for(int i=0; i) { count[arr[i]] ++; } int k = 0; for(int i=0; i) { for(int j=0; j) { arr[k++] = i; } } } public static int max(int[] arr) { int max = Integer.MIN_VALUE; for(int ele : arr) { if(ele > max) max = ele; } return max; } } |
桶排序
桶排序算是計數排序的一種改進和推廣，但是網上有許多資料把計數排序和桶排序混為一談。其實桶排序要比計數排序複雜許多。
對桶排序的分析和解釋借鑑這位兄弟的文章（有改動）：http://hxraid.iteye.com/blog/647759
桶排序的基本思想：
假設有一組長度為N的待排關鍵字序列K[1….n]。首先將這個序列劃分成M個的子區間(桶) 。然後基於某種對映函式 ，將待排序列的關鍵字k對映到第i個桶中(即桶陣列B的下標 i) ，那麼該關鍵字k就作為B[i]中的元素(每個桶B[i]都是一組大小為N/M的序列)。接著對每個桶B[i]中的所有元素進行比較排序(可以使用快排)。然後依次列舉輸出B[0]….B[M]中的全部內容即是一個有序序列。bindex=f(key) 其中，bindex 為桶陣列B的下標(即第bindex個桶), k為待排序列的關鍵字。桶排序之所以能夠高效，其關鍵在於這個對映函式，它必須做到：如果關鍵字k1
舉個例子：
假如待排序列K= {49、 38 、 35、 97 、 76、 73 、 27、 49 }。這些資料全部在1—100之間。因此我們定製10個桶，然後確定對映函式f(k)=k/10。則第一個關鍵字49將定位到第4個桶中(49/10=4)。依次將所有關鍵字全部堆入桶中，並在每個非空的桶中進行快速排序後得到如圖所示。只要順序輸出每個B[i]中的資料就可以得到有序序列了。
桶排序分析：
桶排序利用函式的對映關係，減少了幾乎所有的比較工作。實際上，桶排序的f(k)值的計算，其作用就相當於快排中劃分，希爾排序中的子序列，歸併排序中的子問題，已經把大量資料分割成了基本有序的資料塊(桶)。然後只需要對桶中的少量資料做先進的比較排序即可。
對N個關鍵字進行桶排序的時間複雜度分為兩個部分：
(1) 迴圈計算每個關鍵字的桶對映函式，這個時間複雜度是O(N)。
(2) 利用先進的比較排序演算法對每個桶內的所有資料進行排序，其時間複雜度為 ∑ O(Ni*logNi) 。其中Ni 為第i個桶的資料量。
很顯然，第(2)部分是桶排序效能好壞的決定因素。儘量減少桶內資料的數量是提高效率的唯一辦法(因為基於比較排序的最好平均時間複雜度只能達到O(N*logN)了)。因此，我們需要儘量做到下面兩點：
(1) 對映函式f(k)能夠將N個資料平均的分配到M個桶中，這樣每個桶就有[N/M]個資料量。
(2) 儘量的增大桶的數量。極限情況下每個桶只能得到一個資料，這樣就完全避開了桶內資料的“比較”排序操作。當然，做到這一點很不容易，資料量巨大的情況下，f(k)函式會使得桶集合的數量巨大，空間浪費嚴重。這就是一個時間代價和空間代價的權衡問題了。
對於N個待排資料，M個桶，平均每個桶[N/M]個資料的桶排序平均時間複雜度為：
O(N)+O(M*(N/M)*log(N/M))=O(N+N*(logN-logM))=O(N+N*logN-N*logM)
當N=M時，即極限情況下每個桶只有一個資料時。桶排序的最好效率能夠達到O(N)。
總結： 桶排序的平均時間複雜度為線性的O(N+C)，其中C=N*(logN-logM)。如果相對於同樣的N，桶數量M越大，其效率越高，最好的時間複雜度達到O(N)。 當然桶排序的空間複雜度 為O(N+M)，如果輸入資料非常龐大，而桶的數量也非常多，則空間代價無疑是昂貴的。此外，桶排序是穩定的。
實現程式碼：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 |
/** *@Description:桶排序演算法實現 *@author 王旭 */ public class BucketSort { public static void bucketSort(int[] arr) { if(arr == null & arr.length == 0) return ; int bucketNums = 10; //這裡預設為10，規定待排數[0,100) List> buckets = new ArrayList>(); //桶的索引 for(int i=0; i) { buckets.add(new LinkedList()); //用連結串列比較合適 } //劃分桶 for(int i=0; i) { buckets.get(f(arr[i])).add(arr[i]); } //對每個桶進行排序 for(int i=0; i) { if(!buckets.get(i).isEmpty()) { Collections.sort(buckets.get(i)); //對每個桶進行快排 } } //還原排好序的陣列 int k = 0; for(List bucket : buckets) { for(int ele : bucket) { arr[k++] = ele; } } } /** * 對映函式 * @param x * @return */ public static int f(int x) { return x / 10; } } |
基數排序
基數排序又是一種和前面排序方式不同的排序方式，基數排序不需要進行記錄關鍵字之間的比較。基數排序是一種藉助多關鍵字排序思想對單邏輯關鍵字進行排序的方法。所謂的多關鍵字排序就是有多個優先順序不同的關鍵字。比如說成績的排序，如果兩個人總分相同，則語文高的排在前面，語文成績也相同則數學高的排在前面。。。如果對數字進行排序，那麼個位、十位、百位就是不同優先順序的關鍵字，如果要進行升序排序，那麼個位、十位、百位優先順序一次增加。基數排序是通過多次的收分配和收集來實現的，關鍵字優先順序低的先進行分配和收集。
舉個例子：
實現程式碼：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 |
/** *@Description:基數排序演算法實現 *@author 王旭 */ public class RadixSort { public static void radixSort(int[] arr) { if(arr == null & arr.length == 0) return ; int maxBit = getMaxBit(arr); for(int i=1; i) { List> buf = distribute(arr, i); //分配 collecte(arr, buf); //收集 } } /** * 分配 * @param arr 待分配陣列 * @param iBit 要分配第幾位 * @return */ public static List> distribute(int[] arr, int iBit) { List> buf = new ArrayList>(); for(int j=0; j) { buf.add(new LinkedList()); } for(int i=0; i) { buf.get(getNBit(arr[i], iBit)).add(arr[i]); } return buf; } /** * 收集 * @param arr 把分配的資料收集到arr中 * @param buf */ public static void collecte(int[] arr, List> buf) { int k = 0; for(List bucket : buf) { for(int ele : bucket) { arr[k++] = ele; } } } /** * 獲取最大位數 * @param x * @return */ public static int getMaxBit(int[] arr) { int max = Integer.MIN_VALUE; for(int ele : arr) { int len = (ele+"").length(); if(len > max) max = len; } return max; } /** * 獲取x的第n位，如果沒有則為0. * @param x * @param n * @return */ public static int getNBit(int x, int n) { String sx = x + ""; if(sx.length() n) return 0; else return sx.charAt(sx.length()-n) - '0'; } } |
總結
在前面的介紹和分析中我們提到了氣泡排序、選擇排序、插入排序三種簡單的排序及其變種快速排序、堆排序、希爾排序三種比較高效的排序。後面我們又分析了基於分治遞迴思想的歸併排序還有計數排序、桶排序、基數排序三種線性排序。我們可以知道排序演算法要麼簡單有效，要麼是利用簡單排序的特點加以改進，要麼是以空間換取時間在特定情況下的高效排序。但是這些排序方法都不是固定不變的，需要結合具體的需求和場景來選擇甚至組合使用。才能達到高效穩定的目的。沒有最好的排序，只有最適合的排序。
下面就總結一下排序演算法的各自的使用場景和適用場合。
1. 從平均時間來看，快速排序是效率最高的，但快速排序在最壞情況下的時間效能不如堆排序和歸併排序。而後者相比較的結果是，在n較大時歸併排序使用時間較少，但使用輔助空間較多。
2. 上面說的簡單排序包括除希爾排序之外的所有氣泡排序、插入排序、簡單選擇排序。其中直接插入排序最簡單，但序列基本有序或者n較小時，直接插入排序是好的方法，因此常將它和其他的排序方法，如快速排序、歸併排序等結合在一起使用。
3. 基數排序的時間複雜度也可以寫成O(d*n)。因此它最使用於n值很大而關鍵字較小的的序列。若關鍵字也很大，而序列中大多數記錄的最高關鍵字均不同，則亦可先按最高關鍵字不同，將序列分成若干小的子序列，而後進行直接插入排序。
4. 從方法的穩定性來比較，基數排序是穩定的內排方法，所有時間複雜度為O(n^2)的簡單排序也是穩定的。但是快速排序、堆排序、希爾排序等時間效能較好的排序方法都是不穩定的。穩定性需要根據具體需求選擇。
5. 上面的演算法實現大多數是使用線性儲存結構，像插入排序這種演算法用連結串列實現更好，省去了移動元素的時間。具體的儲存結構在具體的實現版本中也是不同的。
附：基於比較排序演算法時間下限為O(nlogn)的證明：
基於比較排序下限的證明是通過決策樹證明的，決策樹的高度Ω（nlgn），這樣就得出了比較排序的下限。
首先要引入決策樹。 首先決策樹是一顆二叉樹，每個節點表示元素之間一組可能的排序，它予以京進行的比較相一致，比較的結果是樹的邊。 先來說明一些二叉樹的性質，令T是深度為d的二叉樹，則T最多有2^片樹葉。 具有L片樹葉的二叉樹的深度至少是logL。 所以，對n個元素排序的決策樹必然有n!片樹葉（因為n個數有n!種不同的大小關係），所以決策樹的深度至少是log(n!)，即至少需要log(n!)次比較。 而 log(n!)=logn+log(n-1)+log(n-2)+…+log2+log1 >=logn+log(n-1)+log(n-2)+…+log(n/2) >=(n/2)log(n/2) >=(n/2)logn-n/2 =O(nlogn) 所以只用到比較的排序演算法最低時間複雜度是O(nlogn)。
參考資料：
《資料結構》 嚴蔚敏 吳偉民 編著
桶排序分析：http://hxraid.iteye.com/blog/647759
部分排序演算法分析與介紹：http://www.cnblogs.com/weixliu/archive/2012/12/23/2829671.html
打賞支援我寫出更多好文章，謝謝！
打賞作者
打賞支援我寫出更多好文章，謝謝！
任選一種支付方式
