前言
你好，我是小趙，最近在系統的整理算法方面的知識，當你度過了新手階段，想要成為牛逼的技術達人，算法是必須要掌握的東西，而算法中的排序，是每個程序員都繞不開的基本功，重要性就沒必要多說了。
在工作之余堅持學習總是非常辛苦，經常不知不覺熬夜到四五點才去睡，文中的每一張圖（除了最后一張,哈哈 ^_^）都是親手所畫，每一份實現代碼，都是仔細測試並添加注釋，當然在這個紛雜的信息世界中， 沒有百分之一百的原創，免不了有的東西有所借鑒與參考。
如果你還處在新手階段無憂無慮，請一定要盡量學一學，如果你是前輩，歡迎提一些寶貴意見。
如果你覺得喜歡，請留個評論，或者給個關注，有粉必回哈，絕不會讓你有來無回，非常感謝。
本文篇幅過大，字符總數一萬八千余個，配圖60余張，放在書籍里已經可以寫一個大章節了，強烈推薦先收藏再閱讀。
冒泡排序
冒泡排序無疑是最為出名的排序算法之一，從序列的一端開始往另一端冒泡（你可以從左往右冒泡，也可以從右往左冒泡，看心情），依次比較相鄰的兩個數的大小（到底是比大還是比小也看你心情）。
圖解冒泡
我們以[8,2,5,9,7]這組數字來做示例，上圖來戰：
我們從左往右依次冒泡，將小的往右移動
首先比較第一個數和第二個數的大小，我們發現2比8要小，那么保持原位，不做改動。位置還是8,2,5,9,7。
指針往右移動一格，接着比較：
比較第二個數和第三個數的大小，發現2比5要小，所以位置交換，交換后數組更新為：[8,5,2,9,7]。
指針再往右移動一格，繼續比較：
比較第三個數和第四個數的大小，發現2比9要小，所以位置交換，交換后數組更新為：[8,5,9,2,7]
同樣，指針再往右移動，繼續比較：
比較第4個數和第5個數的大小，發現2比7要小，所以位置交換，交換后數組更新為：[8,5,9,7,2]
下一步，指針再往右移動，發現已經到底了，則本輪冒泡結束，處於最右邊的2就是已經排好序的數字。
通過這一輪不斷的對比交換，數組中最小的數字移動到了最右邊。
接下來繼續第二輪冒泡：
由於右邊的2已經是排好序的數字，就不再參與比較，所以本輪冒泡結束，本輪冒泡最終冒到頂部的數字5也歸於有序序列中，現在數組已經變化成了[8,9,7,5,2]。
讓我們開始第三輪冒泡吧！
由於8比7大，所以位置不變，此時第三輪冒泡也已經結束，第三輪冒泡的最后結果是[9,8,7,5,2]
緊接着第四輪冒泡：
9和8比，位置不變，即確定了8進入有序序列，那么最后只剩下一個數字9，放在末尾，自此排序結束。
代碼實現
public static void sort(int arr[]) { for(int i=0;i<arr.length-1;i++){ for(int j=0;j<arr.length-1-i;j++){ int temp = 0; if(arr[j] < arr[j+1]){ temp = arr[j]; arr[j] = arr[j+1]; arr[j+1] = temp; } } } }
冒泡的代碼還是相當簡單的，兩層循環，外層冒泡輪數，里層依次比較，江湖中人人盡皆知。
我們看到嵌套循環，應該立馬就可以得出這個算法的時間復雜度為O(n^2)。
冒泡優化
冒泡有一個最大的問題就是這種算法不管不管你有序還是沒序，閉着眼睛把你循環比較了再說。
比如我舉個數組例子：[9,8,7,6,5]，一個有序的數組，根本不需要排序，它仍然是雙層循環一個不少的把數據遍歷干凈，這其實就是做了沒必要做的事情，屬於浪費資源。
針對這個問題，我們可以設定一個臨時遍歷來標記該數組是否已經有序，如果有序了就不用遍歷了。
public static void sort(int arr[]) { for(int i=0;i<arr.length-1;i++){ boolean isSort = true; for(int j=0;j<arr.length-1-i;j++){ int temp = 0; if(arr[j] < arr[j+1]){ temp = arr[j]; arr[j] = arr[j+1]; arr[j+1] = temp; isSort = false; } } if(isSort){ break; } } }
選擇排序
選擇排序的思路是這樣的：首先，找到數組中最小的元素，拎出來，將它和數組的第一個元素交換位置，第二步，在剩下的元素中繼續尋找最小的元素，拎出來，和數組的第二個元素交換位置，如此循環，直到整個數組排序完成。
至於選大還是選小，這個都無所謂，你也可以每次選擇最大的拎出來排，也可以每次選擇最小的拎出來的排，只要你的排序的手段是這種方式，都叫選擇排序。
圖解選排
我們還是以[8,2,5,9,7]這組數字做例子。
第一次選擇，先找到數組中最小的數字2，然后和第一個數字交換位置。（如果第一個數字就是最小值，那么自己和自己交換位置，也可以不做處理，就是一個if的事情）
第二次選擇，由於數組第一個位置已經是有序的，所以只需要查找剩余位置，找到其中最小的數字5，然后和數組第二個位置的元素交換。
第三次選擇，找到最小值7，和第三個位置的元素交換位置。
第四次選擇，找到最小值8，和第四個位置的元素交換位置。
最后一個到達了數組末尾，沒有可對比的元素，結束選擇。
如此整個數組就排序完成了。
代碼實現
public static void sort(int arr[]) { for(int i=0;i<arr.length;i++){ int min = i;//最小元素的下標 for(int j=i+1;j<arr.length;j++){ if(arr[j] < arr[min]){ min = j;//找最小值 } } //交換位置 int temp = arr[i]; arr[i] = arr[min]; arr[min] = temp; } }
雙層循環，時間復雜度和冒泡一模一樣，都是O(n^2)
插入排序
插入排序的思想和我們打撲克摸牌的時候一樣，從牌堆里一張一張摸起來的牌都是亂序的，我們會把摸起來的牌插入到左手中合適的位置，讓左手中的牌時刻保持一個有序的狀態。
那如果我們不是從牌堆里摸牌，而是左手里面初始化就是一堆亂牌呢？ 一樣的道理，我們把牌往手的右邊挪一挪，把手的左邊空出一點位置來，然后在亂牌中抽一張出來，插入到左邊，再抽一張出來，插入到左邊，再抽一張，插入到左邊，每次插入都插入到左邊合適的位置，時刻保持左邊的牌是有序的，直到右邊的牌抽完，則排序完畢。
圖解插入
數組初始化：[8,2,5,9,7]，我們把數組中的數據分成兩個區域，已排序區域和未排序區域，初始化的時候所有的數據都處在未排序區域中，已排序區域是空。
第一輪，從未排序區域中隨機拿出一個數字，既然是隨機，那么我們就獲取第一個，然后插入到已排序區域中，已排序區域是空，那么就不做比較，默認自身已經是有序的了。（當然了，第一輪在代碼中是可以省略的，從下標為1的元素開始即可）
第二輪，繼續從未排序區域中拿出一個數，插入到已排序區域中，這個時候要遍歷已排序區域中的數字挨個做比較，比大比小取決於你是想升序排還是想倒序排，這里排升序：
第三輪，排5：
第四輪，排9：
第五輪，排7
排序結束。
代碼實現
我們來看一下插入排序的代碼實現
public static void sort(int[] arr) { int n = arr.length; for (int i = 1; i < n; ++i) { int value = arr[i]; int j = 0;//插入的位置 for (j = i-1; j >= 0; j--) { if (arr[j] > value) { arr[j+1] = arr[j];//移動數據 } else { break; } } arr[j+1] = value; //插入數據 } }
從代碼里我們可以看出，如果找到了合適的位置，就不會再進行比較了，就好比牌堆里抽出的一張牌本身就比我手里的牌都小，那么我只需要直接放在末尾就行了，不用一個一個去移動數據騰出位置插入到中間。
所以說，最好情況的時間復雜度是O(n)，最壞情況的時間復雜度是O(n^2)，然而時間復雜度這個指標看的是最壞的情況，而不是最好的情況，所以插入排序的時間復雜度是O(n^2)。
希爾排序
希爾排序這個名字，來源於它的發明者希爾，也稱作“縮小增量排序”，是插入排序的一種更高效的改進版本。
我們知道，插入排序對於大規模的亂序數組的時候效率是比較慢的，因為它每次只能將數據移動一位，希爾排序為了加快插入的速度，讓數據移動的時候可以實現跳躍移動，節省了一部分的時間開支。
圖解希爾
待排序數組 10個數據：
假設計算出的排序區間為4，那么我們第一次比較應該是用第5個數據與第1個數據相比較。
調換后的數據為[7,2,5,9,8,10,1,15,12,3]，然后指針右移，第6個數據與第2個數據相比較。
指針右移，繼續比較。
如果交換數據后，發現減去區間得到的位置還存在數據，那么繼續比較，比如下面這張圖，12和8相比較，原地不動后，指針從12跳到8身上，繼續減去區間發現前面還有一個下標為0的數據7，那么8和7相比較。
比較完之后的效果是7,8,12三個數為有序排列。
當最后一個元素比較完之后，我們會發現大部分值比較大的數據都似乎調整到數組的中后部分了。
假設整個數組比較長的話，比如有100個數據，那么我們的區間肯定是四五十，調整后區間再縮小成一二十還會重新調整一輪，直到最后區間縮小為1，就是真正的排序來了。
指針右移，繼續比較：
重復步驟，即可完成排序，重復的圖就不多畫了。
我們可以發現，當區間為1的時候，它使用的排序方式就是插入排序。
代碼實現
public static void sort(int[] arr) { int length = arr.length; //區間 int gap = 1; while (gap < length) { gap = gap * 3 + 1; } while (gap > 0) { for (int i = gap; i < length; i++) { int tmp = arr[i]; int j = i - gap; //跨區間排序 while (j >= 0 && arr[j] > tmp) { arr[j + gap] = arr[j]; j -= gap; } arr[j + gap] = tmp; } gap = gap / 3; } }
可能你會問為什么區間要以gap=gap*3+1去計算，其實最優的區間計算方法是沒有答案的，這是一個長期未解決的問題，不過差不多都會取在二分之一到三分之一附近。
歸並排序
歸並字面上的意思是合並，歸並算法的核心思想是分治法，就是將一個數組一刀切兩半，遞歸切，直到切成單個元素，然后重新組裝合並，單個元素合並成小數組，兩個小數組合並成大數組，直到最終合並完成，排序完畢。
圖解歸並
我們以[8,2,5,9,7]這組數字來舉例
首先，一刀切兩半：
再切：
再切
粒度切到最小的時候，就開始歸並
數據量設定的比較少，是為了方便圖解，數據量為單數，是為了讓你看到細節，下面我畫了一張更直觀的圖可能你會更喜歡：
代碼實現
我們上面講過，歸並排序的核心思想是分治，分而治之，將一個大問題分解成無數的小問題進行處理，處理之后再合並，這里我們采用遞歸來實現：
/** * 歸並排序 * @param arr */ public static void sort(int[] arr) { int[] tempArr = new int[arr.length]; sort(arr, tempArr, 0, arr.length-1); } /** * 歸並排序 * @param arr 排序數組 * @param tempArr 臨時存儲數組 * @param startIndex 排序起始位置 * @param endIndex 排序終止位置 */ private static void sort(int[] arr,int[] tempArr,int startIndex,int endIndex){ if(endIndex <= startIndex){ return; } //中部下標 int middleIndex = startIndex + (endIndex - startIndex) / 2; //分解 sort(arr,tempArr,startIndex,middleIndex); sort(arr,tempArr,middleIndex + 1,endIndex); //歸並 merge(arr,tempArr,startIndex,middleIndex,endIndex); } /** * 歸並 * @param arr 排序數組 * @param tempArr 臨時存儲數組 * @param startIndex 歸並起始位置 * @param middleIndex 歸並中間位置 * @param endIndex 歸並終止位置 */ private static void merge(int[] arr, int[] tempArr, int startIndex, int middleIndex, int endIndex) { //復制要合並的數據 for (int s = startIndex; s <= endIndex; s++) { tempArr[s] = arr[s]; } int left = startIndex;//左邊首位下標 int right = middleIndex + 1;//右邊首位下標 for (int k = startIndex; k <= endIndex; k++) { if(left > middleIndex){ //如果左邊的首位下標大於中部下標，證明左邊的數據已經排完了。 arr[k] = tempArr[right++]; } else if (right > endIndex){ //如果右邊的首位下標大於了數組長度，證明右邊的數據已經排完了。 arr[k] = tempArr[left++]; } else if (tempArr[right] < tempArr[left]){ arr[k] = tempArr[right++];//將右邊的首位排入，然后右邊的下標指針+1。 } else { arr[k] = tempArr[left++];//將左邊的首位排入，然后左邊的下標指針+1。 } } }
我們可以發現merge方法中只有一個for循環，直接就可以得出每次合並的時間復雜度為O(n)，而分解數組每次對半切割，屬於對數時間O(log n)，合起來等於O(log2n)，也就是說，總的時間復雜度為O(nlogn)。
關於空間復雜度，其實大部分人寫的歸並都是在merge方法里面申請臨時數組，用臨時數組來輔助排序工作，空間復雜度為O(n)，而我這里做的是原地歸並，只在最開始申請了一個臨時數組，所以空間復雜度為O(1)。
快速排序
快速排序的核心思想也是分治法，分而治之。它的實現方式是每次從序列中選出一個基准值，其他數依次和基准值做比較，比基准值大的放右邊，比基准值小的放左邊，然后再對左邊和右邊的兩組數分別選出一個基准值，進行同樣的比較移動，重復步驟，直到最后都變成單個元素，整個數組就成了有序的序列。
圖解快排
我們以[8,2,5,0,7,4,6,1]這組數字來進行演示
首先，我們隨機選擇一個基准值：
與其他元素依次比較，大的放右邊，小的放左邊：
然后我們以同樣的方式排左邊的數據：
繼續排0和1：
由於只剩下一個數，所以就不用排了，現在的數組序列是下圖這個樣子：
右邊以同樣的操作進行，即可排序完成。
單邊掃描
快速排序的關鍵之處在於切分，切分的同時要進行比較和移動，這里介紹一種叫做單邊掃描的做法。
我們隨意抽取一個數作為基准值，同時設定一個標記mark代表左邊序列最右側的下標位置，當然初始為0，接下來遍歷數組，如果元素大於基准值，無操作，繼續遍歷，如果元素小於基准值，則把mark+1，再將mark所在位置的元素和遍歷到的元素交換位置，mark這個位置存儲的是比基准值小的數據，當遍歷結束后，將基准值與mark所在元素交換位置即可。
代碼實現：
public static void sort(int[] arr) { sort(arr, 0, arr.length - 1); } private static void sort(int[] arr, int startIndex, int endIndex) { if (endIndex <= startIndex) { return; } //切分 int pivotIndex = partitionV2(arr, startIndex, endIndex); sort(arr, startIndex, pivotIndex-1); sort(arr, pivotIndex+1, endIndex); } private static int partition(int[] arr, int startIndex, int endIndex) { int pivot = arr[startIndex];//取基准值 int mark = startIndex;//Mark初始化為起始下標 for(int i=startIndex+1; i<=endIndex; i++){ if(arr[i]<pivot){ //小於基准值 則mark+1，並交換位置。 mark ++; int p = arr[mark]; arr[mark] = arr[i]; arr[i] = p; } } //基准值與mark對應元素調換位置 arr[startIndex] = arr[mark]; arr[mark] = pivot; return mark; }
雙邊掃描
另外還有一種雙邊掃描的做法，看起來比較直觀：我們隨意抽取一個數作為基准值，然后從數組左右兩邊進行掃描，先從左往右找到一個大於基准值的元素，將下標指針記錄下來，然后轉到從右往左掃描，找到一個小於基准值的元素，交換這兩個元素的位置，重復步驟，直到左右兩個指針相遇，再將基准值與左側最右邊的元素交換。
我們來看一下實現代碼，不同之處只有partition方法：
public static void sort(int[] arr) { sort(arr, 0, arr.length - 1); } private static void sort(int[] arr, int startIndex, int endIndex) { if (endIndex <= startIndex) { return; } //切分 int pivotIndex = partition(arr, startIndex, endIndex); sort(arr, startIndex, pivotIndex-1); sort(arr, pivotIndex+1, endIndex); } private static int partition(int[] arr, int startIndex, int endIndex) { int left = startIndex; int right = endIndex; int pivot = arr[startIndex];//取第一個元素為基准值 while (true) { //從左往右掃描 while (arr[left] <= pivot) { left++; if (left == right) { break; } } //從右往左掃描 while (pivot < arr[right]) { right--; if (left == right) { break; } } //左右指針相遇 if (left >= right) { break; } //交換左右數據 int temp = arr[left]; arr[left] = arr[right]; arr[right] = temp; } //將基准值插入序列 int temp = arr[startIndex]; arr[startIndex] = arr[right]; arr[right] = temp; return right; }
極端情況
快速排序的時間復雜度和歸並排序一樣，O(n log n)，但這是建立在每次切分都能把數組一刀切兩半差不多大的前提下，如果出現極端情況，比如排一個有序的序列，如[9,8,7,6,5,4,3,2,1]，選取基准值9，那么需要切分n-1次才能完成整個快速排序的過程，這種情況下，時間復雜度就退化成了O(n^2)，當然極端情況出現的概率也是比較低的。
所以說，快速排序的時間復雜度是O(nlogn)，極端情況下會退化成O(n^2)，為了避免極端情況的發生，選取基准值應該做到隨機選取，或者是打亂一下數組再選取。
另外，快速排序的空間復雜度為O(1)。
堆排序
堆排序顧名思義，是利用堆這種數據結構來進行排序的算法。
如果你了解堆這種數據結構，你應該知道堆是一種優先隊列，兩種實現，最大堆和最小堆，由於我們這里排序按升序排，所以就直接以最大堆來說吧。
我們完全可以把堆（以下全都默認為最大堆）看成一棵完全二叉樹，但是位於堆頂的元素總是整棵樹的最大值，每個子節點的值都比父節點小，由於堆要時刻保持這樣的規則特性，所以一旦堆里面的數據發生變化，我們必須對堆重新進行一次構建。
既然堆頂元素永遠都是整棵樹中的最大值，那么我們將數據構建成堆后，只需要從堆頂取元素不就好了嗎？ 第一次取的元素，是否取的就是最大值？取完后把堆重新構建一下，然后再取堆頂的元素，是否取的就是第二大的值？ 反復的取，取出來的數據也就是有序的數據。
圖解堆排
我們以[8,2,5,9,7,3]這組數據來演示。
首先，將數組構建成堆。
既然構建成堆結構了，那么接下來，我們取出堆頂的數據，也就是數組第一個數，9，取法是將數組的第一位和最后一位調換，然后將數組的待排序范圍-1，
現在的待排序數據是[3,8,5,2,7]，我們繼續將待排序數據構建成堆。
取出堆頂數據，這次就是第一位和倒數第二位交換了，因為待排序的邊界已經減1。
繼續構建堆
從堆頂取出來的數據最終形成一個有序列表，重復的步驟就不再贅述了，我們來看一下代碼實現。
代碼實現
如果你對堆這個數據結構不熟悉，不太理解代碼，那么我建議你打斷點，一行一行的觀察數據的變化，伴隨着注釋說明，你肯定會豁然開朗。
/** * 堆排序 * @param arr 排序數組 */ public static void sort(int[] arr) { int length = arr.length; //構建堆 buildHeap(arr, length); for (int i = length - 1; i > 0; i--) { //將堆頂元素與末位元素調換 int temp = arr[0]; arr[0] = arr[i]; arr[i] = temp; //數組長度-1 隱藏堆尾元素 length--; //將堆頂元素下沉 目的是將最大的元素浮到堆頂來 sink(arr, 0, length); } } /** * 構建堆 * @param arr 數組 * @param length 數組范圍 */ private static void buildHeap(int[] arr, int length) { for (int i = length / 2; i >= 0; i--) { sink(arr, i, length); } } /** * 下沉調整 * @param arr 數組 * @param index 調整位置 * @param length 數組范圍 */ private static void sink(int[] arr, int index, int length) { int leftChild = 2 * index + 1;//左子節點下標 int rightChild = 2 * index + 2;//右子節點下標 int present = index;//要調整的節點下標 //下沉左邊 if (leftChild < length && arr[leftChild] > arr[present]) { present = leftChild; } //下沉右邊 if (rightChild < length && arr[rightChild] > arr[present]) { present = rightChild; } //如果下標不相等 證明調換過了 if (present != index) { //交換值 int temp = arr[index]; arr[index] = arr[present]; arr[present] = temp; //繼續下沉 sink(arr, present, length); } }
堆排序和快速排序的時間復雜度都一樣是O(nlogn)。
計數排序
計數排序是一種非基於比較的排序算法，我們之前介紹的各種排序算法幾乎都是基於元素之間的比較來進行排序的，計數排序的時間復雜度為O(n+m)，m指的是數據量，說的簡單點，計數排序算法的時間復雜度約等於O(n)，快於任何比較型的排序算法。
圖解計數
以下以[3,5,8,2,5,4]這組數字來演示。
首先，我們找到這組數字中最大的數，也就是8，創建一個最大下標為8的空數組arr。
遍歷數據，將數據的出現次數填入arr中對應的下標位置中。
遍歷arr，將數據依次取出即可。
代碼實現
public static void sort(int[] arr) { //找出數組中的最大值 int max = arr[0]; for (int i = 1; i < arr.length; i++) { if (arr[i] > max) { max = arr[i]; } } //初始化計數數組 int[] countArr = new int[max + 1]; //計數 for (int i = 0; i < arr.length; i++) { countArr[arr[i]]++; arr[i] = 0; } //排序 int index = 0; for (int i = 0; i < countArr.length; i++) { if (countArr[i] > 0) { arr[index++] = i; } } }
穩定排序
有一個需求就是當對成績進行排名次的時候，如何在原來排前面的人，排序后還是處於相同成績的人的前面。
解題的思路是對countArr計數數組進行一個變形，變來和名次掛鈎，我們知道countArr存放的是分數的出現次數，那么其實我們可以算出每個分數的最大名次，就是將countArr中的每個元素順序求和。
如下圖：
變形之后是什么意思呢？
我們把原數組[2,5,8,2,5,4]中的數據依次拿來去countArr去找，你會發現3這個數在countArr[3]中的值是2，代表着排名第二名，（因為第一名是最小的2，對吧？），5這個數在countArr[5]中的值是5，為什么是5呢？我們來數數，排序后的數組應該是[2,3,4,5,5,8]，5的排名是第五名，那4的排名是第幾名呢？對應countArr[4]的值是3，第三名，5的排名是第五名是因為5這個數有兩個，自然占據了第4名和第5名。
所以我們取排名的時候應該特別注意，原數組中的數據要從右往左取，從countArr取出排名后要把countArr中的排名減1，以便於再次取重復數據的時候排名往前一位。
啊哦，圖都畫完了才發現我的排名是按升序來排的，竟然有這種排分數的邏輯，尷尬。
下面是代碼實現：
public static void sort(int[] arr) { //找出數組中的最大值 int max = arr[0]; for (int i = 1; i < arr.length; ++i) { if (arr[i] > max) { max = arr[i]; } } //初始化計數數組 int[] countArr = new int[max + 1]; //計數 for (int i = 0; i < arr.length; ++i) { countArr[arr[i]]++; } //順序累加 for (int i = 1; i < max + 1; ++i) { countArr[i] = countArr[i-1] + countArr[i]; } //排序后的數組 int[] sortedArr = new int[arr.length]; //排序 for (int i = arr.length - 1; i >= 0; --i) { sortedArr[countArr[arr[i]]-1] = arr[i]; countArr[arr[i]]--; } //將排序后的數據拷貝到原數組 for (int i = 0; i < arr.length; ++i) { arr[i] = sortedArr[i]; } }
計數局限性
計數排序的毛病很多，我們來找找bug。
如果我要排的數據里有0呢？ int[]初始化內容全是0，排毛線。
如果我要排的數據范圍比較大呢？比如[1,9999]，我排兩個數你要創建一個int[10000]的數組來計數？
對於第一個bug，我們可以使用偏移量來解決，比如我要排[-1,0,-3]這組數字，這個簡單，我全給你們加10來計數，變成[9,10,7]計完數后寫回原數組時再減10。不過有可能也會踩到坑，萬一你數組里恰好有一個-10，你加上10后又變0了，排毛線。
對於第二個bug，確實解決不了，如果是[9998,9999]這種雖然值大但是相差范圍不大的數據我們也可以使用偏移量解決，比如這兩個數據，我減掉9997后只需要申請一個int[3]的數組就可以進行計數。
由此可見，計數排序只適用於正整數並且取值范圍相差不大的數組排序使用，它的排序的速度是非常可觀的。
桶排序
桶排序可以看成是計數排序的升級版，它將要排的數據分到多個有序的桶里，每個桶里的數據再單獨排序，再把每個桶的數據依次取出，即可完成排序。
圖解桶排序
我們拿一組計數排序啃不掉的數據[500,6123,1700,10,9999]來舉例。
第一步，我們創建10個桶，分別來裝0-1000、1000-2000、2000-3000、3000-4000、4000-5000、5000-6000、6000-7000、7000-8000、8000-9000區間的數據。
第二步，遍歷原數組，對號入桶。
第三步，對桶中的數據進行單獨排序，只有第一個桶中的數量大於1，顯然只需要排第一個桶。
最后，依次將桶中的數據取出，排序完成。
代碼實現
這個桶排序乍一看好像挺簡單的，但是要敲代碼就需要考慮幾個問題了。
桶這個東西怎么表示？
怎么確定桶的數量？
桶內排序用什么方法排？
我們先來看看我的實現：
public static void sort(int[] arr){ //最大最小值 int max = arr[0]; int min = arr[0]; int length = arr.length; for(int i=1; i<length; i++) { if(arr[i] > max) { max = arr[i]; } else if(arr[i] < min) { min = arr[i]; } } //最大值和最小值的差 int diff = max - min; //桶列表 ArrayList<ArrayList<Integer>> bucketList = new ArrayList<>(); for(int i = 0; i < length; i++){ bucketList.add(new ArrayList<>()); } //每個桶的存數區間 float section = (float) diff / (float) (length - 1); //數據入桶 for(int i = 0; i < length; i++){ //當前數除以區間得出存放桶的位置 減1后得出桶的下標 int num = (int) (arr[i] / section) - 1; if(num < 0){ num = 0; } bucketList.get(num).add(arr[i]); } //桶內排序 for(int i = 0; i < bucketList.size(); i++){ //jdk的排序速度當然信得過 Collections.sort(bucketList.get(i)); } //寫入原數組 int index = 0; for(ArrayList<Integer> arrayList : bucketList){ for(int value : arrayList){ arr[index] = value; index++; } } }
桶當然是一個可以存放數據的集合，我這里使用arrayList，如果你使用LinkedList那其實也是沒有問題的。
桶的數量我認為設置為原數組的長度是合理的，因為理想情況下每個數據裝一個桶。
數據入桶的映射算法其實是一個開放性問題，由於難度原因我找了一下網絡上的文章博客，目前我沒有發現什么最優的答案，大部分對桶排序的實現都是遮遮掩掩的，少部分寫的代碼也是瞎整，我承認我這里寫的方案並不佳，因為我測試過不同的數據集合來排序，如果你有什么更好的方案或想法，歡迎留言討論。
桶內排序為了方便起見使用了當前語言提供的排序方法，如果對於穩定排序有所要求，可以選擇使用自定義的排序算法。
桶排序的思考及其應用
在額外空間充足的情況下，盡量增大桶的數量，極限情況下每個桶只有一個數據時，或者是每只桶只裝一個值時，完全避開了桶內排序的操作，桶排序的最好時間復雜度就能夠達到O(n)
比如高考總分750分，全國幾百萬人，我們只需要創建751個桶，循環一遍挨個扔進去，排序速度是毫秒級。
但是如果數據經過桶的划分之后，桶與桶的數據分布極不均勻，有些數據非常多，有些數據非常少，比如[8,2,9,10,1,23,53,22,12,9000]這十個數據，我們分成十個桶裝，結果發現第一個桶裝了9個數據，這是非常影響效率的情況，會使時間復雜度下降到O(nlogn)，解決辦法是我們每次桶內排序時判斷一下數據量，如果桶里的數據量過大，那么應該在桶里面回調自身再進行一次桶排序。
基數排序
基數排序是一種非比較型整數排序算法，其原理是將數據按位數切割成不同的數字，然后按每個位數分別比較。
假設說，我們要對100萬個手機號碼進行排序，應該選擇什么排序算法呢？排的快的有歸並、快排時間復雜度是O(nlogn)，計數排序和桶排序雖然更快一些，但是手機號碼位數是11位，那得需要多少桶？內存條表示不服。
這個時候，我們使用基數排序是最好的選擇。
圖解雞排
我們以[892, 846, 821, 199, 810,700]這組數字來做例子演示。
首先，創建十個桶，用來輔助排序。
先排個位數，根據個位數的值將數據放到對應下標值的桶中。
排完后，我們將桶中的數據依次取出。
那么接下來，我們排十位數。
最后，排百位數。
排序完成。
代碼實現
基數排序可以看成桶排序的擴展，也是用桶來輔助排序，我們來看下代碼：
public static void sort(int[] arr) { int length = arr.length; //最大值 int max = arr[0]; for(int i=0;i<length;i++){ if(arr[i] > max){ max = arr[i]; } } //當前排序位置 int location = 1; //桶列表 ArrayList<ArrayList<Integer>> bucketList = new ArrayList<>(); //長度為10 裝入余數0-9的數據 for(int i = 0; i < 10; i++){ bucketList.add(new ArrayList()); } while(true) { //判斷是否排完 int dd = (int)Math.pow(10,(location - 1)); if(max < dd){ break; } //數據入桶 for(int i = 0; i < length; i++) { //計算余數 放入相應的桶 int number = ((arr[i] / dd) % 10); bucketList.get(number).add(arr[i]); } //寫回數組 int nn = 0; for (int i=0;i<10;i++){ int size = bucketList.get(i).size(); for(int ii = 0;ii < size;ii ++){ arr[nn++] = bucketList.get(i).get(ii); } bucketList.get(i).clear(); } location++; } }
其實它的思想很簡單，不管你的數字有多大，我一位一位的排，0-9最多也就十個桶，先按權重小的位置排序，然后按權重大的位置排序。
當然，如果你有需求，也可以選擇從高位往低位排。
效率對比
最后，在菜鳥教程上扒了張圖，真的是太詳細了，非扒不可。
最后，感謝閱讀。