作者： C you again，從事軟體開發 努力在IT搬磚路上的技術小白
公眾號： 【C you again】，分享計算機類畢業設計原始碼、IT技術文章、遊戲原始碼、網頁模板、程式人生等等。公眾號回覆 【粉絲】進博主技術群，與大佬交流，領取乾貨學習資料
關於轉載：歡迎轉載博主文章，轉載時表明出處
求贊環節：創作不易，記得 點贊+評論+轉發 謝謝你一路支援
原文連結：面試官：手撕十大排序演算法，你會幾種？
在前面三期，介紹了動態規劃的兩個主要特性：交疊子問題和最優子結構，並用七種方式求解第n項斐波那契數，感受了演算法的強大，你是否也領略到它的精髓呢？
今天我們就來討論面試官最喜歡問到的排序演算法吧，從氣泡排序、選擇排序、插入排序等十大排序演算法的排序步驟、程式碼實現兩個方面入手，徹底搞清實現原理，保證面試道路一路暢通。
01 排序演算法的概述
所謂排序演算法，就是通過特定的演算法因式將一組或多組資料按照一定模式進行重新排序。
這種新序列遵循著一定的規則，體現出一定的規律，因此，經處理後的資料便於篩選和計算，大大提高了計算效率。
02 排序演算法的分類
03評價標準
（1）時間複雜度：即從序列的初始狀態到經過排序演算法的變換移位等操作變到最終排序好的結果狀態的過程所花費的時間度量。
（2）空間複雜度：就是從序列的初始狀態經過排序移位變換的過程一直到最終的狀態所花費的空間開銷。
（3）穩定性：穩定性是不管考慮時間和空間必須要考慮的問題，往往也是非常重要的影響選擇的因素。
04 實現步驟與程式碼
氣泡排序（Bubble Sort）
氣泡排序是一種簡單直觀的排序演算法。它重複地走訪過要排序的數列，一次比較兩個元素，如果他們的順序錯誤就把他們交換過來。走訪數列的工作是重複地進行直到沒有再需要交換的資料，也就是說該數列已經排序完成。這個演算法的名字由來是因為越小的元素會經由交換慢慢"浮"到數列的頂端。
（1）演算法步驟
步驟1：比較相鄰的元素。如果第一個比第二個大，就交換他們兩個；
步驟2：對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最後一對。這步做完後，最後的元素會是最大的數；
步驟3：針對所有的元素重複以上的步驟，除了最後一個；
步驟4：重複步驟1~3，直到排序完成；
（2）過程演示
（3）程式碼實現
public class BubbleSort implements IArraySort {
@Override
public int[] sort(int[] sourceArray) throws Exception {
// 對 arr 進行拷貝，不改變引數內容
int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
for (int i = 1; i < arr.length; i++) {
// 設定一個標記，若為true，則表示此次迴圈沒有進行交換，也就是待排序列已經有序，排序已經完成。
boolean flag = true;
for (int j = 0; j < arr.length - i; j++) {
if (arr[j] > arr[j + 1]) {
int tmp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = tmp;
flag = false;
}
}
if (flag) {
break;
}
}
return arr;
}
}
選擇排序（Selection Sort）
選擇排序是一種簡單直觀的排序演算法，無論什麼資料進去都是 O(n²) 的時間複雜度。所以用到它的時候，資料規模越小越好。
（1）演算法步驟
步驟1：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置；
步驟2：再從剩餘未排序元素中繼續尋找最小（大）元素，然後放到已排序序列的末尾；
步驟3：重複步驟2，直到所有元素均排序完畢；
（2）過程演示
（3）程式碼實現
public class SelectionSort implements IArraySort {
@Override
public int[] sort(int[] sourceArray) throws Exception {
int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
// 總共要經過 N-1 輪比較
for (int i = 0; i < arr.length - 1; i++) {
int min = i;
// 每輪需要比較的次數 N-i
for (int j = i + 1; j < arr.length; j++) {
if (arr[j] < arr[min]) {
// 記錄目前能找到的最小值元素的下標
min = j;
}
}
// 將找到的最小值和i位置所在的值進行交換
if (i != min) {
int tmp = arr[i];
arr[i] = arr[min];
arr[min] = tmp;
}
}
return arr;
}
}
插入排序（Insertion Sort）
插入排序的演算法描述是一種簡單直觀的排序演算法。它的工作原理是通過構建有序序列，對於未排序資料，在已排序序列中從後向前掃描，找到相應位置並插入。插入排序在實現上，通常採用in-place排序（即只需用到O(1)的額外空間的排序），因而在從後向前掃描過程中，需要反覆把已排序元素逐步向後挪位，為最新元素提供插入空間。
（1）演算法步驟
步驟1：從第一個元素開始，該元素可以認為已經被排序；
步驟2：取出下一個元素，在已經排序的元素序列中從後向前掃描；
步驟3：如果該元素（已排序）大於新元素，將該元素移到下一位置；
步驟4：重複步驟3，直到找到已排序的元素小於或者等於新元素的位置；
步驟5：將新元素插入到該位置後；
步驟6：重複步驟2~5；
（2）過程演示
（3）程式碼實現
public class InsertSort implements IArraySort {
@Override
public int[] sort(int[] sourceArray) throws Exception {
// 對 arr 進行拷貝，不改變引數內容
int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
// 從下標為1的元素開始選擇合適的位置插入，因為下標為0的只有一個元素，預設是有序的
for (int i = 1; i < arr.length; i++) {
// 記錄要插入的資料
int tmp = arr[i];
// 從已經排序的序列最右邊的開始比較，找到比其小的數
int j = i;
while (j > 0 && tmp < arr[j - 1]) {
arr[j] = arr[j - 1];
j--;
}
// 存在比其小的數，插入
if (j != i) {
arr[j] = tmp;
}
}
return arr;
}
}
希爾排序（Shell Sort）
希爾排序，也稱遞減增量排序演算法，是插入排序的一種更高效的改進版本。但希爾排序是非穩定排序演算法。
希爾排序是基於插入排序的以下兩點性質而提出改進方法的：
- 插入排序在對幾乎已經排好序的資料操作時，效率高，即可以達到線性排序的效率；
- 但插入排序一般來說是低效的，因為插入排序每次只能將資料移動一位；
希爾排序的基本思想是：先將整個待排序的記錄序列分割成為若干子序列分別進行直接插入排序，待整個序列中的記錄"基本有序"時，再對全體記錄進行依次直接插入排序。
（1）演算法步驟
步驟1：選擇一個增量序列 t1，t2，……，tk，其中 ti > tj, tk = 1；
步驟2：按增量序列個數 k，對序列進行 k趟排序；
步驟3：每趟排序，根據對應的增量 ti，將待排序列分割成若干長度為 m 的子序列，分別對各子表進行直接插入排序。僅增量因子為 1時，整個序列作為一個表來處理，表長度即為整個序列的長度；
（2）過程演示
（3）程式碼實現
public class ShellSort implements IArraySort {
@Override
public int[] sort(int[] sourceArray) throws Exception {
// 對 arr 進行拷貝，不改變引數內容
int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
int gap = 1;
while (gap < arr.length) {
gap = gap * 3 + 1;
}
while (gap > 0) {
for (int i = gap; i < arr.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 = (int) Math.floor(gap / 3);
}
return arr;
}
}
歸併排序（Merge Sort）
歸併排序是建立在歸併操作上的一種有效的排序演算法。該演算法是採用分治法（Divide and Conquer）的一個非常典型的應用。歸併排序是一種穩定的排序方法。將已有序的子序列合併，得到完全有序的序列；即先使每個子序列有序，再使子序列段間有序。若將兩個有序表合併成一個有序表，稱為2-路歸併。
和選擇排序一樣，歸併排序的效能不受輸入資料的影響，但表現比選擇排序好的多，因為始終都是O(n log n）的時間複雜度。代價是需要額外的記憶體空間。
（1）演算法步驟
步驟1：把長度為n的輸入序列分成兩個長度為n/2的子序列；
步驟2：對這兩個子序列分別採用歸併排序；
步驟3：將兩個排序好的子序列合併成一個最終的排序序列；
（2）過程演示
（3）程式碼實現
public class MergeSort implements IArraySort {
@Override
public int[] sort(int[] sourceArray) throws Exception {
// 對 arr 進行拷貝，不改變引數內容
int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
if (arr.length < 2) {
return arr;
}
int middle = (int) Math.floor(arr.length / 2);
int[] left = Arrays.copyOfRange(arr, 0, middle);
int[] right = Arrays.copyOfRange(arr, middle, arr.length);
return merge(sort(left), sort(right));
}
protected int[] merge(int[] left, int[] right) {
int[] result = new int[left.length + right.length];
int i = 0;
while (left.length > 0 && right.length > 0) {
if (left[0] <= right[0]) {
result[i++] = left[0];
left = Arrays.copyOfRange(left, 1, left.length);
} else {
result[i++] = right[0];
right = Arrays.copyOfRange(right, 1, right.length);
}
}
while (left.length > 0) {
result[i++] = left[0];
left = Arrays.copyOfRange(left, 1, left.length);
}
while (right.length > 0) {
result[i++] = right[0];
right = Arrays.copyOfRange(right, 1, right.length);
}
return result;
}
}
快速排序（Quick Sort）
快速排序是由東尼·霍爾所發展的一種排序演算法。在平均狀況下，排序n個專案要 Ο(n log n) 次比較。在最壞狀況下則需要 Ο(n^2) 次比較，但這種狀況並不常見。事實上，快速排序通常明顯比其他 Ο(nlogn) 演算法更快，因為它的內部迴圈（inner loop）可以在大部分的架構上很有效率地被實現出來。
快速排序使用分治法（Divide and conquer）策略來把一個序列（list）分為兩個子序列（sub-lists）。
（1）演算法步驟
步驟1：從數列中挑出一個元素，稱為 "基準"（pivot）；
步驟2：重新排序數列，所有元素比基準值小的擺放在基準前面，所有元素比基準值大的擺在基準的後面（相同的數可以到任一邊）。在這個分割槽退出之後，該基準就處於數列的中間位置。這個稱為分割槽（partition）操作；
步驟3：遞迴地（recursive）把小於基準值元素的子數列和大於基準值元素的子數列排序；
（2）過程演示
（3）程式碼實現
public class QuickSort implements IArraySort {
@Override
public int[] sort(int[] sourceArray) throws Exception {
// 對 arr 進行拷貝，不改變引數內容
int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
return quickSort(arr, 0, arr.length - 1);
}
private int[] quickSort(int[] arr, int left, int right) {
if (left < right) {
int partitionIndex = partition(arr, left, right);
quickSort(arr, left, partitionIndex - 1);
quickSort(arr, partitionIndex + 1, right);
}
return arr;
}
private int partition(int[] arr, int left, int right) {
// 設定基準值（pivot）
int pivot = left;
int index = pivot + 1;
for (int i = index; i <= right; i++) {
if (arr[i] < arr[pivot]) {
swap(arr, i, index);
index++;
}
}
swap(arr, pivot, index - 1);
return index - 1;
}
private void swap(int[] arr, int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
堆排序（Heap Sort）
堆排序是指利用堆這種資料結構所設計的一種排序演算法。堆積是一個近似完全二叉樹的結構，並同時滿足堆積的性質：即子結點的鍵值或索引總是小於（或者大於）它的父節點。堆排序可以說是一種利用堆的概念來排序的選擇排序。分為兩種方法：
- 大頂堆：每個節點的值都大於或等於其子節點的值，在堆排序演算法中用於升序排列；
- 小頂堆：每個節點的值都小於或等於其子節點的值，在堆排序演算法中用於降序排列；
堆排序的平均時間複雜度為 O(n log n)。
（1）演算法步驟
步驟1：將初始待排序關鍵字序列(R1,R2….Rn)構建成大頂堆，此堆為初始的無序區；
步驟2：將堆頂元素R[1]與最後一個元素R[n]交換，此時得到新的無序區(R1,R2,……Rn-1)和新的有序區(Rn),且滿足R[1,2…n-1]<=R[n]；
步驟3：由於交換後新的堆頂R[1]可能違反堆的性質，因此需要對當前無序區(R1,R2,……Rn-1)調整為新堆，然後再次將R[1]與無序區最後一個元素交換，得到新的無序區(R1,R2….Rn-2)和新的有序區(Rn-1,Rn)。不斷重複此過程直到有序區的元素個數為n-1，則整個排序過程完成；
（2）過程演示
（3）程式碼實現
public class HeapSort implements IArraySort {
@Override
public int[] sort(int[] sourceArray) throws Exception {
// 對 arr 進行拷貝，不改變引數內容
int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
int len = arr.length;
buildMaxHeap(arr, len);
for (int i = len - 1; i > 0; i--) {
swap(arr, 0, i);
len--;
heapify(arr, 0, len);
}
return arr;
}
private void buildMaxHeap(int[] arr, int len) {
for (int i = (int) Math.floor(len / 2); i >= 0; i--) {
heapify(arr, i, len);
}
}
private void heapify(int[] arr, int i, int len) {
int left = 2 * i + 1;
int right = 2 * i + 2;
int largest = i;
if (left < len && arr[left] > arr[largest]) {
largest = left;
}
if (right < len && arr[right] > arr[largest]) {
largest = right;
}
if (largest != i) {
swap(arr, i, largest);
heapify(arr, largest, len);
}
}
private void swap(int[] arr, int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
計數排序（Counting Sort）
計數排序 的核心在於將輸入的資料值轉化為鍵儲存在額外開闢的陣列空間中。作為一種線性時間複雜度的排序，計數排序要求輸入的資料必須是有確定範圍的整數。
計數排序是一種穩定的排序演算法。計數排序使用一個額外的陣列C，其中第i個元素是待排序陣列A中值等於i的元素的個數。然後根據陣列C來將A中的元素排到正確的位置。它只能對整數進行排序。
（1）演算法步驟
步驟1：找出待排序的陣列中最大和最小的元素；
步驟2：統計陣列中每個值為i的元素出現的次數，存入陣列C的第i項；
步驟3：對所有的計數累加（從C中的第一個元素開始，每一項和前一項相加）；
步驟4：反向填充目標陣列：將每個元素i放在新陣列的第C(i)項，每放一個元素就將C(i)減去1；
（2）過程演示
（3）程式碼實現
public class CountingSort implements IArraySort {
@Override
public int[] sort(int[] sourceArray) throws Exception {
// 對 arr 進行拷貝，不改變引數內容
int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
int maxValue = getMaxValue(arr);
return countingSort(arr, maxValue);
}
private int[] countingSort(int[] arr, int maxValue) {
int bucketLen = maxValue + 1;
int[] bucket = new int[bucketLen];
for (int value : arr) {
bucket[value]++;
}
int sortedIndex = 0;
for (int j = 0; j < bucketLen; j++) {
while (bucket[j] > 0) {
arr[sortedIndex++] = j;
bucket[j]--;
}
}
return arr;
}
private int getMaxValue(int[] arr) {
int maxValue = arr[0];
for (int value : arr) {
if (maxValue < value) {
maxValue = value;
}
}
return maxValue;
}
}
桶排序（Bucket Sort）
桶排序是計數排序的升級版。它利用了函式的對映關係，高效與否的關鍵就在於這個對映函式的確定。為了使桶排序更加高效，我們需要做到這兩點：
- 在額外空間充足的情況下，儘量增大桶的數量
- 使用的對映函式能夠將輸入的N個資料均勻的分配到K個桶中
同時，對於桶中元素的排序，選擇何種比較排序演算法對於效能的影響至關重要。
（1）演算法步驟
步驟1：人為設定一個BucketSize，作為每個桶所能放置多少個不同數值（例如當BucketSize==5時，該桶可以存放｛1,2,3,4,5｝這幾種數字，但是容量不限，即可以存放100個3）；
步驟2：遍歷輸入資料，並且把資料一個一個放到對應的桶裡去；
步驟3：對每個不是空的桶進行排序，可以使用其它排序方法，也可以遞迴使用桶排序；
步驟4：從不是空的桶裡把排好序的資料拼接起來；
注意，如果遞迴使用桶排序為各個桶排序，則當桶數量為1時要手動減小BucketSize增加下一迴圈桶的數量，否則會陷入死迴圈，導致記憶體溢位；
（2）過程演示
（3）程式碼實現
/**
* 桶排序
*
* @param array
* @param bucketSize
* @return
*/
public static ArrayList<Integer> BucketSort(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 < 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 = BucketSort(bucketArr.get(i), bucketSize);
for (int j = 0; j < temp.size(); j++)
resultArr.add(temp.get(j));
}
}
return resultArr;
}
基數排序（Radix Sort）
基數排序也是非比較的排序演算法，對每一位進行排序，從最低位開始排序，複雜度為O(kn),為陣列長度，k為陣列中的數的最大的位數；
基數排序是按照低位先排序，然後收集；再按照高位排序，然後再收集；依次類推，直到最高位。有時候有些屬性是有優先順序順序的，先按低優先順序排序，再按高優先順序排序。最後的次序就是高優先順序高的在前，高優先順序相同的低優先順序高的在前。基數排序基於分別排序，分別收集，所以是穩定的。
（1）演算法步驟
步驟1：取得陣列中的最大數，並取得位數；
步驟2：arr為原始陣列，從最低位開始取每個位組成radix陣列；
步驟3：對radix進行計數排序（利用計數排序適用於小範圍數的特點）；
（2）過程演示
（3）程式碼實現
/**
* 基數排序
*/
public class RadixSort implements IArraySort {
@Override
public int[] sort(int[] sourceArray) throws Exception {
// 對 arr 進行拷貝，不改變引數內容
int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
int maxDigit = getMaxDigit(arr);
return radixSort(arr, maxDigit);
}
/**
* 獲取最高位數
*/
private int getMaxDigit(int[] arr) {
int maxValue = getMaxValue(arr);
return getNumLenght(maxValue);
}
private int getMaxValue(int[] arr) {
int maxValue = arr[0];
for (int value : arr) {
if (maxValue < value) {
maxValue = value;
}
}
return maxValue;
}
protected int getNumLenght(long num) {
if (num == 0) {
return 1;
}
int lenght = 0;
for (long temp = num; temp != 0; temp /= 10) {
lenght++;
}
return lenght;
}
private int[] radixSort(int[] arr, int maxDigit) {
int mod = 10;
int dev = 1;
for (int i = 0; i < maxDigit; i++, dev *= 10, mod *= 10) {
// 考慮負數的情況，這裡擴充套件一倍佇列數，其中 [0-9]對應負數，[10-19]對應正數 (bucket + 10)
int[][] counter = new int[mod * 2][0];
for (int j = 0; j < arr.length; j++) {
int bucket = ((arr[j] % mod) / dev) + mod;
counter[bucket] = arrayAppend(counter[bucket], arr[j]);
}
int pos = 0;
for (int[] bucket : counter) {
for (int value : bucket) {
arr[pos++] = value;
}
}
}
return arr;
}
/**
* 自動擴容，並儲存資料
*
* @param arr
* @param value
*/
private int[] arrayAppend(int[] arr, int value) {
arr = Arrays.copyOf(arr, arr.length + 1);
arr[arr.length - 1] = value;
return arr;
}
}
05 總結
06 文章推薦
推薦一：計算機網路中這些高頻考題，你還在死記硬背嗎？（一），講述內容：IP地址及其分類，子網掩碼的概念，網路號、主機號、直接廣播地址計算方法等。
推薦二：計算機網路中這些高頻考題，你還在死記硬背嗎？（二），講述內容：區域網介面配置、路由器的靜態路由配置、OSPF動態路由協議配置和DHCP伺服器配置。
推薦三：用x種方式求第n項斐波那契數，99%的人只會第一種，講述內容：七種方式求解第N項斐波那契數。
以上就是本期的所有內容了，是否對你有幫助呢？瞭解更多演算法請關注公眾號“C you again”。