排序就是將一組對象按照某種邏輯順序重新排列的過程。比如，訂單按照日期排序的——這種排序很可能使用了某種排序算法。現在計算機的廣泛使用使得數據無處不在，而整理數據的第一步通常就是進行排序。
學習排序算法三大實際意義
- IT從業人員必備技能，也是互聯網公司面試的必考點
- 其中包含的技術和思想也能有效解決其他類型的問題
- 排序算法常常是我們解決其他問題的第一步
圖片來源於網絡
十大排序算法：冒泡排序，選擇排序，插入排序，歸併排序，堆排序，快速排序、希爾排序、計數排序，基數排序，桶排序
一、冒泡排序算法
一種簡單的排序算法。它反覆地走訪過要排序的數列，一次比較兩個元素，如果它們的順序錯誤就把它們交換過來。這個工作重複地進行直到沒有元素再需要交換，也就是說該數列已經排序完成。這個算法的名字由來是因爲元素會經由交換慢慢“浮”到數列的頂端。
具體步驟
- 從數組頭開始，比較相鄰的元素。如果第一個比第二個大(小)，就交換它們兩個；
- 對每一對相鄰元素作同樣的工作，從開始第一對到尾部的最後一對，這樣在最後的元素應該會是最大(小)的數；
- 重複步驟1~2，重複次數等於數組的長度，直到排序完成
原理圖如下
代碼如下
public static int[] sort(int[] array) {
if (array.length == 0)
return array;
/*循環數組長度的次數*/
for (int i = 0; i < array.length; i++){
/*從第0個元素開始，依次和後面的元素進行比較
* j < array.length - 1 - i表示第[array.length - 1 - i]
* 個元素已經冒泡到了合適的位置，無需進行比較，可以減少比較次數*/
for (int j = 0; j < array.length - 1 - i; j++){
/*如果第j個元素比後面的第j+1元素大，交換兩者的位置*/
if (array[j + 1] < array[j]) {
int temp = array[j + 1];
array[j + 1] = array[j];
array[j] = temp;
}
PrintArray.print(array);
}
System.out.println("---------------");
//PrintArray.print(array);
}
return array;
}
二、簡單選擇排序
選擇排序的思想其實和冒泡排序有點類似，都是在一次排序後把最小的元素放到最前面。但是過程不同，冒泡排序是通過相鄰的比較和交換。而選擇排序是通過對整體的選擇。
其實選擇排序可以看成冒泡排序的優化，因爲其目的相同，只是選擇排序只有在確定了最小數的前提下才進行交換，大大減少了交換的次數。
舉個例子，對5,3,8,6,4這個無序序列進行簡單選擇排序，首先要選擇5以外的最小數來和5交換，也就是選擇3和5交換，一次排序後就變成了3,5,8,6,4.對剩下的序列繼續進行選擇和交換，最終就會得到一個有序序列。
具體步驟
- 首先，找到數組中最大（小）的那個元素；
- 其次，將它和數組的第一個元素交換位置（如果第一個元素就是最大（小）元素那麼它就和自己交換）；
- 再次，在剩下的元素中找到最大（小）的元素，將它與數組的第二個元素交換位置。如此往復，直到將整個數組排序。
原理圖如下
代碼如下
public static int[] sort(int[] array) {
if (array.length == 0)
return array;
for (int i = 0; i < array.length; i++) {
int minIndex=i;/*最小數的下標，每個循環開始總是假設第一個數最小*/
for (int j = i; j < array.length; j++) {
if (array[j] < array[minIndex]) /*找到最小的數*/
minIndex = j; /*將最小數的索引保存*/
}
System.out.println("最小數爲："+array[minIndex]);
/*交換最小數和i當前所指的元素*/
int temp = array[minIndex];
array[minIndex] = array[i];
array[i] = temp;
PrintArray.print(array);
System.out.println("---------------");
}
return array;
}
三、簡單插入排序
插入排序不是通過交換位置而是通過比較找到合適的位置插入元素來達到排序的目的的。相信大家都有過打撲克牌的經歷，特別是牌數較大的。在分牌時可能要整理自己的牌，牌多的時候怎麼整理呢？就是拿到一張牌，找到一個合適的位置插入。這個原理其實和插入排序是一樣的。
舉個例子，我們將要收到5,3,4,,8,6這幾張牌，我們先收到5這張牌，毫無疑問，這張牌的位置是正確的，沒必要整理。接着收到了牌3，然後3要插到5前面，把5後移一位，變成3,5。接着又收到了牌4，現在我們會怎麼做？把4插入到5前面，把5後移一位。
具體步驟
- 對於未排序數據，在已排序序列中從後向前掃描，找到相應位置並插入。
- 爲了給要插入的元素騰出空間，我們需要將插入位置之後的已排序元素在都向右移動一位。
插入排序所需的時間取決於輸入中元素的初始順序。例如，對一個很大且其中的元素已經有序（或接近有序）的數組進行排序將會比對隨機順序的數組或是逆序數組進行排序要快得多。
總的來說，插入排序對於部分有序的數組十分高效，也很適合小規模數組。
原理圖如下
代碼如下
public static int[] sort(int[] array) {
if (array.length == 0)
return array;
int currentValue;/*當前待排序數據，該元素之前的元素均已被排序過*/
for (int i = 0; i < array.length - 1; i++) {
int preIndex = i;/*已被排序數據的索引*/
currentValue = array[preIndex + 1];
System.out.println("待排序元素索引:"+(i + 1)+"，值爲：" +currentValue+
",已被排序數據的索引:"+preIndex);
/*在已被排序過數據中倒序尋找合適的位置，如果當前待排序數據比比較的元素要小，
將比較的元素元素後移一位*/
while (preIndex >= 0 && currentValue < array[preIndex]) {
//將當前元素後移一位
array[preIndex + 1] = array[preIndex];
preIndex--;
PrintArray.print(array);
}
/*while循環結束時，說明已經找到了當前待排序數據的合適位置，插入*/
array[preIndex + 1] = currentValue;
System.out.println("本輪被插入排序後的數組");
PrintArray.print(array);
System.out.println("--------------------");
}
return array;
}
四、希爾排序
一種基於插入排序的快速的排序算法(請大家先學習插入排序，瞭解基本的插入排序的思想。對於大規模亂序數組插入排序很慢，因爲元素只能一點一點地從數組的一端移動到另一端。例如，如果主鍵最小的元素正好在數組的盡頭，要將它挪到正確的位置就需要N-1 次移動。
希爾排序爲了加快速度簡單地改進了插入排序，也稱爲縮小增量排序，同時該算法是衝破O(n^2）的第一批算法之一。
希爾排序是把待排序數組按一定增量的分組，對每組使用直接插入排序算法排序；然後縮小增量繼續分組排序，隨着增量逐漸減少，每組包含的元素越來越多，當增量減至 1 時，整個數組恰被分成一組，排序便完成了。這個不斷縮小的增量，就構成了一個增量序列。
原理圖如下
希爾排序中的增量序列
- 在先前較大的增量下每個子序列的規模都不大,用直接插入排序效率都較高，儘管在隨後的增量遞減分組中子序列越來越大,由於整個序列的有序性也越來越明顯,則排序效率依然較高。
- 從理論上說，只要一個數組是遞減的，並且最後一個值是1，都可以作爲增量序列使用。有沒有一個步長序列,使得排序過程中所需的比較和移動次數相對較少,並且無論待排序列記錄數有多少,算法的時間複雜度都能漸近最佳呢？但是目前從數學上來說，無法證明某個序列是“最好的”。
- 常用的增量序列
希爾增量序列 ：{N/2, (N / 2)/2, ..., 1}，其中N爲原始數組的長度，這是最常用的序列，但卻不是最好的
Hibbard序列：{2^k-1, ..., 3,1}
Sedgewick序列： {... , 109 , 41 , 19 , 5，1}
代碼如下
public static int[] sort(int[] array) {
int len = array.length;
/*按增量分組後，每個分組中，temp代表當前待排序數據，該元素之前的元素均已被排序過*/
/*gap指用來分組的增量，會依次遞減*/
int currentValue, gap = len / 2;
while (gap > 0) {
for (int i = gap; i < len; i++) {
currentValue = array[i];
/*組內已被排序數據的索引*/
int preIndex = i - gap;
/*在組內已被排序過數據中倒序尋找合適的位置，如果當前待排序數據比比較的元素要小，
並將比較的元素元素在組內後移一位*/
while (preIndex >= 0 && array[preIndex] > currentValue) {
array[preIndex + gap] = array[preIndex];
preIndex -= gap;
}
/*while循環結束時，說明已經找到了當前待排序數據的合適位置，插入*/
array[preIndex + gap] = currentValue;
}
System.out.println("本輪增量【"+gap+"】排序後的數組");
PrintArray.print(array);
System.out.println("--------------------");
gap /= 2;
}
return array;
}
五、歸併排序
歸併排序是建立在歸併操作上的一種有效的排序算法。該算法是採用分治法的一個非常典型的應用。
對於給定的一組數據，利用遞歸與分治技術將數據序列劃分成爲越來越小的半子表，在對半子表排序後，再用遞歸方法將排好序的半子表合併成爲越來越大的有序序列。
爲了提升性能，有時我們在半子表的個數小於某個數（比如15）的情況下，對半子表的排序採用其他排序算法，比如插入排序。
若將兩個有序表合併成一個有序表，稱爲2-路歸併，與之對應的還有多路歸併
原理圖如下
代碼實現
public static int[] sort(int[] array) {
if (array.length < 2) return array;
/*切分數組，然後遞歸調用*/
int mid = array.length / 2;
int[] left = Arrays.copyOfRange(array, 0, mid);
int[] right = Arrays.copyOfRange(array, mid, array.length);
return merge(sort(left), sort(right));
}
/**
* 歸併排序——將兩段排序好的數組結合成一個排序數組
* @param left
* @param right
* @return
*/
public static int[] merge(int[] left, int[] right) {
int[] result = new int[left.length + right.length];
for (int index = 0, i = 0, j = 0; index < result.length; index++) {
if (i >= left.length)/*左邊數組已經取完，完全取右邊數組的值即可*/
result[index] = right[j++];
else if (j >= right.length)/*右邊數組已經取完，完全取左邊數組的值即可*/
result[index] = left[i++];
else if (left[i] > right[j])/*左邊數組的元素值大於右邊數組，取右邊數組的值*/
result[index] = right[j++];
else/*右邊數組的元素值大於左邊數組，取左邊數組的值*/
result[index] = left[i++];
}
System.out.print("左子數組:");
PrintArray.print(left);
System.out.print("右子數組:");
PrintArray.print(right);
System.out.print("合併後數組:");
PrintArray.print(result);
System.out.println("--------------------");
return result;
}
六、快速排序
快速排序被譽爲20 世紀科學和工程領域的十大算法之一。快速排序（Quicksort）是對冒泡排序的一種改進，也是採用分治法的一個典型的應用。
具體步驟
- 首先任意選取一個數據（比如數組的第一個數）作爲關鍵數據，我們稱爲基準數，然後將所有比它小的數都放到它前面，所有比它大的數都放到它後面，這個過程稱爲一趟快速排序，也稱爲分區（partition）操作。在實際實現時，一般會在原數組上直接操作。
- 通過一趟快速排序將要排序的數據分割成獨立的兩部分，其中一部分的所有數據都比另外一部分的所有數據都要小，然後再按此方法對這兩部分數據分別進行快速排序，整個排序過程可以遞歸進行，以此達到整個數據變成有序序列。
- 爲了提升性能，有時我們在分割後獨立的兩部分的個數小於某個數（比如15）的情況下，會採用其他排序算法，比如插入排序。
原理圖如下
基準數
- 基準的選取：最優的情況是基準值剛好取在無序區數值的中位數，這樣能夠最大效率地讓兩邊排序，同時最大地減少遞歸劃分的次數，但是一般很難做到最優。基準的選取一般有三種方式，選取數組的第一個元素，選取數組的最後一個元素，以及選取第一個、最後一個以及中間的元素的中位數（如4 5 6 7, 第一個4, 最後一個7, 中間的爲5, 這三個數的中位數爲５, 所以選擇5作爲基準）。
- Dual-Pivot快排：雙基準快速排序算法，其實就是用兩個基準數, 把整個數組分成三份來進行快速排序，在這種新的算法下面，比經典快排從實驗來看節省了10%的時間。
代碼如下
public static int[] sort(int[] array, int start, int end) {
if (array.length < 1 || start < 0 || end >= array.length || start > end)
return null;
/*數據分割成獨立的兩部分時，從哪兒分區的指示器*/
int zoneIndex = partition(array, start, end);
if (zoneIndex > start)
sort(array, start, zoneIndex - 1);
if (zoneIndex < end)
sort(array, zoneIndex + 1, end);
System.out.println("本輪排序後的數組");
PrintArray.printIndex(array,start,end);
System.out.println("--------------------");
return array;
}
/**
* 快速排序算法——partition
* @param array
* @param start
* @param end
* @return
*/
public static int partition(int[] array, int start, int end) {
int pivot = (int) (start + Math.random() * (end - start + 1));
System.out.println("開始下標："+start+",結束下標:"+end+",基準數下標："
+pivot+",元素值:"+array[pivot]);
/*zoneIndex是分割指示器
從業務上來說：比基準數小的，放到指示器的左邊，比基準數大的，放到指示器的右邊，
* 但在實際實現時，通過移動比基準數小的元素和分割指示器本身也可以達到一樣的效果*/
int zoneIndex = start - 1;
swap(array, pivot, end);/*將基準數和數組尾元素交換位置*/
for (int i = start; i <= end; i++){
if (array[i] <= array[end]) {/*當前元素小於等於基準數*/
zoneIndex++;/*首先分割指示器累加*/
if (i > zoneIndex)/*當前元素在分割指示器的右邊時，交換當前元素和分割指示器元素*/
swap(array, i, zoneIndex);
}
System.out.println("zoneIndex："+zoneIndex+",i:"+i);
PrintArray.printIndex(array,start,end);
}
System.out.println("---------------");
return zoneIndex;
}
/**
* 交換數組內兩個元素
* @param array
* @param i
* @param j
*/
public static void swap(int[] array, int i, int j) {
int temp = array[i];
array[i] = array[j];
array[j] = temp;
}
七、堆排序
許多應用程序都需要處理有序的元素，但不一定要求他們全部有序，或者不一定要一次就將他們排序，很多時候，我們每次只需要操作數據中的最大元素（最小元素），那麼有一種基於二叉堆的數據結構可以提供支持。
具體步驟
- 所謂二叉堆，是一個完全二叉樹的結構，同時滿足堆的性質：即子結點的鍵值或索引總是小於（或者大於）它的父節點。在一個二叉堆中，根節點總是最大（或者最小）節點。
- 堆排序算法就是抓住了這一特點，每次都取堆頂的元素，然後將剩餘的元素重新調整爲最大（最小）堆，依次類推，最終得到排序的序列。
完全二叉樹
原理圖如下
代碼如下
public class HeapSort {
//聲明全局變量，用於記錄數組array的長度；
private static int len;
public static int[] sort(int[] array) {
len = array.length;
if (len < 1) return array;
//1.構建一個最大堆
buildMaxHeap(array);
//2.循環將堆首位（最大值）與末位交換，然後在重新調整最大堆
while (len > 0) {
swap(array, 0, len - 1);
len--;
adjustHeap(array, 0);
PrintArray.print(array);
System.out.println("--------------------");
}
return array;
}
/**
* 建立最大堆
*
* @param array
*/
public static void buildMaxHeap(int[] array) {
//從最後一個非葉子節點開始向上構造最大堆
for (int i = (len/2-1); i >= 0; i--) {
adjustHeap(array, i);
}
System.out.println("構造完成最大堆");
PrintArray.print(array);
System.out.println("============================================");
}
/**
* 調整使之成爲最大堆
*
* @param array
* @param i
*/
public static void adjustHeap(int[] array, int i) {
int maxIndex = i;
int left = 2*i+1;
int right = 2*(i+1);
//如果有左子樹，且左子樹大於父節點，則將最大指針指向左子樹
if (left < len && array[left] > array[maxIndex])
maxIndex = left;
//如果有右子樹，且右子樹大於父節點，則將最大指針指向右子樹
if (right < len && array[right] > array[maxIndex])
maxIndex = right;
//如果父節點不是最大值，則將父節點與最大值交換，並且遞歸調整與父節點交換的位置。
if (maxIndex != i) {
swap(array, maxIndex, i);
adjustHeap(array, maxIndex);
}
}
/**
* 交換數組內兩個元素
* @param array
* @param i
* @param j
*/
public static void swap(int[] array, int i, int j) {
int temp = array[i];
array[i] = array[j];
array[j] = temp;
}
public static void main(String[] args) {
PrintArray.print(PrintArray.SRC);
System.out.println("============================================");
int[] dest = HeapSort.sort(PrintArray.SRC);
PrintArray.print(dest);
}
}
八、計數排序
具體步驟
- 計數排序對一定範圍內的整數排序時候的速度非常快，一般快於其他排序算法。但計數排序侷限性比較大，只限於對整數進行排序，而且待排序元素值分佈較連續、跨度小的情況。
- 計數排序是一個排序時不比較元素大小的排序算法。
- 如果一個數組裏所有元素都是整數，而且都在0-K以內。對於數組裏每個元素來說，如果能知道數組裏有多少項小於或等於該元素，就能準確地給出該元素在排序後的數組的位置。
原理圖如下
實際應用中我們會同時找出數組中的max和min，主要是爲了儘量節省空間。試想[1003, 1001, 1030, 1050]這樣的數據要排序，真的需要建立長度爲1050 + 1的數組嗎？我們只需要長度爲1050 - 1003 + 1= 48的數組（先不考慮額外+1的長度），就能囊括從最小到最大元素之間的所有元素了。
如果待排序數組的元素值跨度很大，比如[99999, 1, 2]，爲三個元素排序要使用99999 - 1 + 1的空間，實在是浪費。所以計數排序適用於待排序元素值分佈較連續、跨度小的情況。
代碼如下
public static int[] sort(int[] array) {
if (array.length == 0) return array;
/*尋找數組中最大值，最小值
* bias:偏移量,用以定位原始數組每個元素在計數數組中的下標位置*/
int bias, min = array[0], max = array[0];
for (int i = 1; i < array.length; i++) {
if (array[i] > max)
max = array[i];
if (array[i] < min)
min = array[i];
}
bias = 0 - min;
/*獲得計數數組的容量*/
int[] counterArray = new int[max - min + 1];
Arrays.fill(counterArray, 0);
/*遍歷整個原始數組，將原始數組中每個元素值轉化爲計數數組下標，
並將計數數組下標對應的元素值大小進行累加*/
for (int i = 0; i < array.length; i++) {
counterArray[array[i] + bias]++;
}
System.out.println("計數數組爲：");
PrintArray.print(counterArray);
System.out.println("============================================");
int index = 0;/*訪問原始數組時的下標計數器*/
int i = 0;/*訪問計數數組時的下標計數器*/
/*訪問計數數組，將計數數組中的元素轉換後，重新寫回原始數組*/
while (index < array.length) {
/*只要計數數組中當前下標元素的值不爲0，就將計數數組中的元素轉換後，重新寫回原始數組*/
if (counterArray[i] != 0) {
array[index] = i - bias;
counterArray[i]--;
index++;
} else
i++;
PrintArray.print(counterArray);
PrintArray.print(array);
System.out.println("--------------------");
}
return array;
}
final static int[] src = {5,4,5,0,3,6,2,0,2,4,3,3};
public static void main(String[] args) {
PrintArray.print(src);
System.out.println("============================================");
int[] dest = CountingSort.sort(src);
PrintArray.print(dest);
}
九、桶排序
簡介
桶排序 (Bucket sort)的工作的原理：假設輸入數據服從均勻分佈，利用某種函數的映射關係將數據分到有限數量的桶裏，每個桶再分別排序（有可能再使用別的排序算法或是以遞歸方式繼續使用桶排序）。
桶排序利用函數的映射關係，減少了幾乎所有的比較工作。實際上，桶排序的f(k)值的計算，其作用就相當於快排中劃分，已經把大量數據分割成了基本有序的數據塊(桶)。然後只需要對桶中的少量數據做排序即可。
原理圖如下
代碼如下
public class BucketSort {
/**
*
* @param array
* @param bucketSize BucketSize，作爲每個桶所能放置多少個不同數值
* （例如當BucketSize==5時，該桶可以存放｛1,2,3,4,5｝這幾種數字，
* 但是容量不限，即可以存放100個3）；
* @return
*/
public static ArrayList<Integer> sort(ArrayList<Integer> array, int bucketSize) {
if (array == null || array.size() < 2)
return array;
int max = array.get(0), min = array.get(0);
// 找到最大值最小值
for (int i = 0; i < array.size(); i++) {
if (array.get(i) > max)
max = array.get(i);
if (array.get(i) < min)
min = array.get(i);
}
/*獲得桶的數量*/
int bucketCount = (max - min) / bucketSize + 1;
/*構建桶*/
ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketCount);
ArrayList<Integer> resultArr = new ArrayList<>();
for (int i = 0; i < bucketCount; i++) {
bucketArr.add(new ArrayList<Integer>());
}
/*將原始數組中的數據分配到桶中*/
for (int i = 0; i < array.size(); i++) {
bucketArr.get((array.get(i) - min) / bucketSize).add(array.get(i));
}
/*看看桶中數據的分佈*/
for (int i = 0; i < bucketArr.size(); i++) {
System.out.print("第"+i+"個桶包含數據：");
PrintArray.printObject(bucketArr.get(i));
}
for (int i = 0; i < bucketCount; i++) {
if (bucketSize == 1) {
for (int j = 0; j < bucketArr.get(i).size(); j++)
resultArr.add(bucketArr.get(i).get(j));
} else {
if (bucketCount == 1)
bucketSize--;
/*對桶中的數據再次用桶進行排序*/
ArrayList<Integer> temp = sort(bucketArr.get(i), bucketSize);
for (int j = 0; j < temp.size(); j++)
resultArr.add(temp.get(j));
}
}
return resultArr;
}
public static void main(String[] args) {
ArrayList<Integer> array = new ArrayList<>();
array.add(86);
array.add(11);
array.add(77);
array.add(23);
array.add(32);
array.add(45);
array.add(58);
array.add(63);
array.add(93);
array.add(4);
array.add(37);
array.add(22);
PrintArray.printObject(array);
System.out.println("============================================");
ArrayList<Integer> dest = BucketSort.sort(array,2);
PrintArray.printObject(dest);
}
}
十、基數排序
原理
常見的數據元素一般是由若干位組成的，比如字符串由若干字符組成，整數由若干位0~9數字組成。基數排序按照從右往左的順序，依次將每一位都當做一次關鍵字，然後按照該關鍵字對數組排序，同時每一輪排序都基於上輪排序後的結果；當我們將所有的位排序後，整個數組就達到有序狀態。比如對於數字2985，從右往左就是先以個位爲關鍵字進行排序，然後是十位、百位、千位，總共需要四輪。
基數是什麼意思？對於十進制整數，每一位都只可能是0~9中的某一個，總共10種可能。那10就是它的基，同理二進制數字的基爲2；對於字符串，如果它使用的是8位的擴展ASCII字符集，那麼它的基就是256。
原理圖如下
基數排序 vs 計數排序 vs 桶排序
基數排序有兩種方法：
- MSD 從高位開始進行排序
- LSD 從低位開始進行排序
這三種排序算法都利用了桶的概念，但對桶的使用方法上有明顯差異：
- 基數排序：根據鍵值的每位數字來分配桶
- 計數排序：每個桶只存儲單一鍵值
- 桶排序：每個桶存儲一定範圍的數值
代碼如下
public static int[] sort(int[] array) {
if (array == null || array.length < 2)
return array;
/*找出最大數*/
int max = array[0];
for (int i = 1; i < array.length; i++) {
max = Math.max(max, array[i]);
}
/*先算出最大數的位數*/
int maxDigit = 0;
while (max != 0) {
max /= 10;
maxDigit++;
}
int mod = 10, div = 1;
/*構建桶*/
ArrayList<ArrayList<Integer>> bucketList = new ArrayList<ArrayList<Integer>>();
for (int i = 0; i < 10; i++)
bucketList.add(new ArrayList<Integer>());
/*按照從右往左的順序，依次將每一位都當做一次關鍵字，然後按照該關鍵字對數組排序，
每一輪排序都基於上輪排序後的結果*/
for (int i = 0; i < maxDigit; i++, mod *= 10, div *= 10) {
/*遍歷原始數組，投入桶中*/
for (int j = 0; j < array.length; j++) {
int num = (array[j] % mod) / div;
bucketList.get(num).add(array[j]);
}
/*桶中的數據寫回原始數組，清除桶，準備下一輪的排序*/
int index = 0;
for (int j = 0; j < bucketList.size(); j++) {
for (int k = 0; k < bucketList.get(j).size(); k++)
array[index++] = bucketList.get(j).get(k);
bucketList.get(j).clear();
}
}
return array;
}
十一、外部排序
原理
有時，待排序的文件很大，計算機內存不能容納整個文件，這時候對文件就不能使用內部排序了（我們一般的排序都是在內存中做的，所以稱之爲內部排序，而外部排序是指待排序的內容不能在內存中一下子完成，它需要做內外存的內容交換），外部排序常採用的排序方法也是歸併排序，這種歸併方法由兩個不同的階段組成：
- 採用適當的內部排序方法對輸入文件的每個片段進行排序，將排好序的片段（成爲歸併段）寫到外部存儲器中（通常由一個可用的磁盤作爲臨時緩衝區），這樣臨時緩衝區中的每個歸併段的內容是有序的。
- 利用歸併算法，歸併第一階段生成的歸併段，直到只剩下一個歸併段爲止。
1、將內存空間劃分爲三份，每份大小250個記錄，其中兩個用作輸入緩衝區，另外一個用作輸出緩衝區。首先對Segment_1和Segment_2進行歸併，先從每個歸併段中讀取250個記錄到輸入緩衝區，對其歸併，歸併結果放到輸出緩衝區，當輸出緩衝區滿後，將其寫到臨時緩衝區（由一個可用的磁盤充當）內，如果某個輸入緩衝區空了，則從相應的歸併段中再讀取250個記錄進行繼續歸併，反覆以上步驟，直至Segment_1和Segment_2全都排好序，形成一個大小爲1500的記錄，然後對Segment_3和Segment_4、Segment_5和Segment_6進行同樣的操作。
2、對歸併好的大小爲1500的記錄進行如同步驟1一樣的操作，進行繼續排序，直至最後形成大小爲4500的歸併段，至此，排序結束。
排序算法總結
算法的穩定性
- 穩定：如果a原本在b前面，而a=b，排序之後a仍然在b的前面
- 不穩定：如果a原本在b的前面，而a=b，排序之後a可能會出現在b的後面；
排序算法如果是穩定的，那麼從一個鍵上排序，然後再從另一個鍵上排序，前一個鍵排序的結果可以爲後一個鍵排序所用。
算法的複雜度
算法的複雜度往往取決於數據的規模大小和數據本身分佈性質。
- 時間複雜度： 一個算法執行所耗費的時間。
- 空間複雜度：對一個算法在運行過程中臨時佔用存儲空間大小的量度。
- 常見覆雜度由小到大：O(1) < O(logn) < O(n) < O(nlogn) < O(n^2) < O(n^3) < O(2^n)
在各種不同算法中，若算法中語句執行次數(佔用空間)爲一個常數，則複雜度爲O(1)；
當一個算法的複雜度與以2爲底的n的對數成正比時，可表示爲O(log n)；
當一個算法的複雜度與n成線性比例關係時，可表示爲O (n)，依次類推。
時間複雜度記憶
- 冒泡、選擇、插入排序需要兩個for循環，每次只關注一個元素，平均時間複雜度爲O(n的平方)（一遍找元素O(n)，一遍找位置O(n)）
- 快速、歸併、堆基於分治思想，log以2爲底，平均時間複雜度往往和O(nlogn)（一遍找元素O(n)，一遍找位置O(logn)）相關
- 而希爾排序依賴於所取增量序列的性質，但是到目前爲止還沒有一個最好的增量序列 。例如希爾增量序列時間複雜度爲O(n²)，而Hibbard增量序列的希爾排序的時間複雜度爲O(n3/2次方) ， 有人在大量的實驗後得出結論;當n在某個特定的範圍後希爾排序的最小時間複雜度大約爲n^1.3。
從平均時間來看，快速排序是效率最高的：
- 快速排序中平均時間複雜度O(nlog n)，這個公式中隱含的常數因子很小，比歸併排序的O(nlog n)中的要小很多，所以大多數情況下，快速排序總是優於合併排序的。
- 而堆排序的平均時間複雜度也是O(nlog n)，但是堆排序存在着重建堆的過程，它把根節點移除後，把最後的葉子結點拿上來後需要重建堆，但是，拿上的值是要比它的兩個葉子結點要差很多的，一般要比較很多次，才能回到合適的位置。堆排序就會有很多的時間耗在堆調整上。
- 雖然快速排序的最壞情況爲排序規模（n）的平方關係，但是這種最壞情況取決於每次選擇的基準， 對於這種情況，已經提出了很多優化的方法，比如三取樣劃分和Dual-Pivot快排。 同時，當排序規模較小時，劃分的平衡性容易被打破，而且頻繁的方法調用超過了O(nlog n)爲O(n的平方)省出的時間，所以一般排序規模較小時，會改用插入排序或者其他排序算法。