摘要
排序算法已經是面試中被問爛的題目了，可以說經常面試都會被問到排序算法。一般面試官的問題比較寬泛，比如:"說說排序算法？"。 拋出這樣的一個問題有的人可能就直接回答了排序算法有哪些，然后沒有深入分析。這種方式並不可取，原因如下：
- 直接說出8個面試題，這樣導致這道題的面試時間比較短，面試官就有機會問更多的問題，以下上升為壓力面試。狂轟亂炸的題目如果基礎不是特別扎實會死的比較慘。
- 給面試官的感覺是對排序算法的理解不是特別深刻，算法基礎不夠扎實。
個人覺得如果問到排序算法的題可以從以下排序算法的幾個特點進行:思想，時間復雜度(最壞、最好、平均), 空間復雜度，穩定性。每個算法題從這些方面入手可以使得回答很豐滿，讓面試官覺得自己對排序算法了解的比較深刻，覺得不過哦，算法基礎還挺扎實的嘛。另一方面，這樣回答下來估計需要20、30分鍾，可以拖延時間減少面試官問的更多問題。
插入排序
1.直接插入排序
思想：每次將一個待排序的數據按照其關鍵字的大小插入到前面已經排序好的數據中的適當位置，直到全部數據排序完成。
時間復雜度：O(n2) O(n) O(n2) （最壞 最好 平均）
空間復雜度：O(1)
穩定性： 穩定 每次都是在前面已排好序的序列中找到適當的位置，只有小的數字會往前插入，所以原來相同的兩個數字在排序后相對位置不變。
代碼：
/**
* 插入排序
* @param array
*/
public static void insertSort(int[] array) {
for (int i = 2; i < array.length; i++ ) {
int val = array[i];
int j = i -1;
while (j >= 0 && array[j] > val) { // array[j] > val
array[j+1] = array[j];
j--;
}
array[j+1] = val; // array[j+1] 不是array[j]
}
}
2.希爾排序
思想：希爾排序根據增量值對數據按下表進行分組，對每組使用直接插入排序算法排序；隨着增量逐漸減少，每組包含的關鍵詞越來越多，當增量減至1時，整體采用直接插入排序得到有序數組，算法終止。
時間復雜度：O(n2) O(n1.3) O(n) （最壞，最好，平均）
空間復雜度：O(1)
穩定性：不穩定 因為是分組進行直接插入排序，原來相同的兩個數字可能會被分到不同的組去，可能會使得后面的數字會排到前面，使得兩個相同的數字排序前后位置發生變化。
不穩定舉例: 4 3 3 2 按2為增量分組，則第二個3會跑到前面
代碼：
public static void shellSort(int[] array) {
int len;
len = array.length / 2; // 分成n/2組
while (len >= 1) {
for (int i = len; i < array.length; ++i) { //對每組進行直接插入排序
int temp = array[i];
int j = i - len;
while (j >= 0 && array[j] > temp) {
array[j + len] = array[j];
j -= len;
}
array[j + len] = temp;
}
len /= 2;
}
}
交換排序
3.冒泡排序
思想：對待排序元素的關鍵字從后往前進行多遍掃描，遇到相鄰兩個關鍵字次序與排序規則不符時，就將這兩個元素進行交換。這樣關鍵字較小的那個元素就像一個泡泡一樣，從最后面冒到最前面來。
時間復雜度：最壞：O(n2) 最好: O(n) 平均: O(n2)
空間復雜度：O(1)
穩定性：穩定，相鄰的關鍵字兩兩比較，如果相等則不交換。所以排序前后的相等數字相對位置不變。
代碼：
public static void bubbleSort(int[] array) {
boolean flag; // 用來判斷當前這一輪是否有交換數值,若沒有則表示已經排好許了
for (int i = 0; i < array.length; i++) {
flag = false;
/**
* 這邊要注意 for (int j = array.length -1; j >= i + 1; j--)。 不要寫成
* for (int j = i + 1; j < array.length ; j++)
*/
for (int j = array.length -1; j >= i + 1; j--) {
if (array[j -1 ] > array[j]) {
//數據交換
int temp = array[j - 1];
array[j - 1] = array[j];
array[j] = temp;
//設置標志位
flag = true;
}
}
if (!flag) {
break;
}
}
}
4.快速排序
思想：該算法是分治算法，首先選擇一個基准元素,根據基准元素將待排序列分成兩部分,一部分比基准元素小,一部分大於等於基准元素,此時基准元素在其排好序后的正確位置,然后再用同樣的方法遞歸地排序划分的兩部分。基准元素的選擇對快速排序的性能影響很大，所有一般會想打亂排序數組選擇第一個元素或則隨機地從后面選擇一個元素替換第一個元素作為基准元素。
時間復雜度：最壞:O(n2) 最好: O(nlogn) 平均: O(nlogn)
空間復雜度：O(nlogn)用於方法棧
穩定性：不穩定 快排會將大於等於基准元素的關鍵詞放在基准元素右邊，加入數組 1 2 2 3 4 5 選擇第二個2 作為基准元素，那么排序后 第一個2跑到了后面，相對位置發生變化。
代碼：
public static void quickSort(int[] array) {
partition(array, 0, array.length - 1);
}
private static void partition(int[] array, int low, int high) {
if (low < high) {
int p = quickSort(array, low, high);
partition(array, low, p - 1);
partition(array, p + 1, high);
}
}
private static int quickSort(int[] array, int left, int right) {
Random random = new Random(System.currentTimeMillis());
int idx = random.nextInt(right - left + 1) + left; // 這邊需要注意right - left + 1 （要加1）
exch(array, idx, left);
int val = array[left];
while (left < right) {
while (left < right && array[right] > val) {
right--;
}
if (left < right) {
array[left++] = array[right];
}
while (left < right && array[left] < val) {
left++;
}
if (left < right) {
array[right--] = array[left];
}
}
array[left] = val;
return left;
}
三向快速排序算法
/**
* 三向切分快速排序, 適用於存在大量重復元素的數組
*
* @param array
*/
public static void quick2waySort(int[] array) {
quick2waySort(array, 0, array.length - 1);
}
private static void quick2waySort(int[] array, int lo, int hi) {
if (hi <= lo) {
return;
}
int lt = lo, gt = hi, i = lo + 1;
int val = array[lo];
while (i <= gt) {
if (array[i] < val) {
exch(array, i++, lt++);
} else if (array[i] > val) {
exch(array, i, gt--);
} else {
i++;
}
}
// lt 到 gt 之間的都是等於val 的. 如果存在大量重復元素的數組使用該算法可以極大提升算法效率,
quick2waySort(array, lo, lt - 1);
quick2waySort(array, gt + 1, hi);
}
選擇排序
5.直接選擇排序
思想：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后每次從剩余未排序元素中繼續尋找最小（大）元素放到已排序序列的末尾。以此類推，直到所有元素均排序完畢
時間復雜度：最壞:O(n2) 最好: O(n2) 平均: O(n2)
空間復雜度：O(1)
穩定性：不穩定 例如數組 2 2 1 3 第一次選擇的時候把第一個2與1交換使得兩個2的相對次序發生了改變。
代碼：
public static void selectSort(int[] array) {
for (int i = 0; i < array.length; i++) {
int minIdx = i;
for (int j = i + 1; j < array.length; j++) {
if (array[j] < array[minIdx]) {
minIdx = j;
}
}
exch(array, i, minIdx);
}
}
6.堆排序
思想：堆排序是利用堆的性質進行的一種選擇排序，先將排序元素構建一個最大堆,每次堆中取出最大的元素並調整堆。將該取出的最大元素放到已排好序的序列前面。這種方法相對選擇排序，時間復雜度更低，效率更高。
時間復雜度：最壞:O(nlog2n) 最好: O(nlog2n) 平均: O(nlog2n)
空間復雜度：O(1)
穩定性：不穩定 例如 5 10 15 10。 如果堆頂5先輸出，則第三層的10(最后一個10)的跑到堆頂，然后堆穩定，繼續輸出堆頂，則剛才那個10跑到前面了，所以兩個10排序前后的次序發生改變。
代碼：
public static void heapSort(int[] array) {
int N = array.length -1;
for (int k = N / 2; k >= 1; k--) {
sink(array, k, N);
}
while (N > 1) {
// 最大堆, 選擇最大值放在最后
exch(array, 1, N --);
sink(array, 1, N);
}
}
private static void sink(int[] array, int k, int N) {
while (2 * k <= N) {
int j = 2 * k;
if (j < N && array[j] < array[j+1]) { // <
j++;
}
if (array[j] < array[k]) break; // <
exch(array, k, j);
k = j;
}
}
7.歸並排序
思想：歸並排序采用了分治算法，首先遞歸將原始數組划分為若干子數組，對每個子數組進行排序。然后將排好序的子數組遞歸合並成一個有序的數組。
時間復雜度：最壞:O(nlog2n) 最好: O(nlog2n) 平均: O(nlog2n)
空間復雜度：O(n)
穩定性：穩定
代碼：
public static void mergeSort(int[] array) {
sort(array, 0, array.length - 1);
}
private static void sort(int[] array, int left, int right) {
if (left < right) {
int middle = (left + right) >> 1;
//遞歸處理相關的合並事項
sort(array, left, middle);
sort(array, middle + 1, right);
merge(array, left, middle, right);
}
}
private static void merge(int[] array, int lo, int mid, int hi) {
//創建一個臨時數組用來存儲合並后的數據
int[] temp = new int[array.length];
int left = lo;
int right = mid + 1;
int k = lo;
while (left <= mid && right <= hi) {
if (array[left] < array[right])
temp[k++] = array[left++];
else
temp[k++] = array[right++];
}
//處理剩余未合並的部分
while (left <= mid) temp[k++] = array[left++];
while (right <= hi) temp[k++] = array[right++];
//將臨時數組中的內容存儲到原數組中
while (lo <= hi) array[lo] = temp[lo++];
}
8.基數排序算法
思想：基數排序是通過“分配”和“收集”過程來實現排序，首先根據數字的個位的數將數字放入0-9號桶中，然后將所有桶中所盛數據按照桶號由小到大，桶中由頂至底依次重新收集串起來，得到新的元素序列。然后遞歸對十位、百位這些高位采用同樣的方式分配收集，直到沒各位都完成分配收集得到一個有序的元素序列。
時間復雜度：最壞:O(d(r+n)) 最好:O(d(r+n)) 平均: O(d(r+n))
空間復雜度：O(dr+n) n個記錄，d個關鍵碼，關鍵碼的取值范圍為r
穩定性：穩定 基數排序基於分別排序，分別收集，所以其是穩定的排序算法。
代碼：