歸併排序
歸併排序遵循分治的思想：將原問題分解為幾個規模較小但類似於原問題的子問題，遞迴地求解這些子問題，然後合併這些子問題的解來建立原問題的解，歸併排序的步驟如下：
-
劃分：分解待排序的 n 個元素的序列成各具 n/2 個元素的兩個子序列，將長陣列的排序問題轉換為短陣列的排序問題，當待排序的序列長度為 1 時，遞迴劃分結束
-
合併：合併兩個已排序的子序列得出已排序的最終結果
歸併排序的程式碼實現如下：
private void sort(int[] nums, int left, int right) {
if (left >= right) {
return;
}
// 劃分
int mid = left + right >> 1;
sort(nums, left, mid);
sort(nums, mid + 1, right);
// 合併
merge(nums, left, mid, right);
}
private void merge(int[] nums, int left, int mid, int right) {
// 輔助陣列
int[] temp = Arrays.copyOfRange(nums, left, right + 1);
int leftBegin = 0, leftEnd = mid - left;
int rightBegin = leftEnd + 1, rightEnd = right - left;
for (int i = left; i <= right; i++) {
if (leftBegin > leftEnd) {
nums[i] = temp[rightBegin++];
} else if (rightBegin > rightEnd || temp[leftBegin] < temp[rightBegin]) {
nums[i] = temp[leftBegin++];
} else {
nums[i] = temp[rightBegin++];
}
}
}
歸併排序最吸引人的性質是它能保證將長度為 n 的陣列排序所需的時間和 nlogn 成正比；它的主要缺點是所需的額外空間和 n 成正比。
演算法特性：
-
空間複雜度：藉助輔助陣列實現合併，使用 O(n) 的額外空間；遞迴深度為 logn，使用 O(logn) 大小的棧幀空間。忽略低階部分，所以空間複雜度為 O(n)
-
非原地排序
-
穩定排序
-
非自適應排序
以上程式碼是歸併排序常見的實現，下面我們來一起看看歸併排序的最佳化策略：
將多次建立小陣列的開銷轉換為只建立一次大陣列
在上文實現中，我們在每次合併兩個有序陣列時，即使是很小的陣列，我們都會建立一個新的 temp[] 陣列，這部分耗時是歸併排序執行時間的主要部分。更好的解決方案是將 temp[] 陣列定義成 sort() 方法的區域性變數，並將它作為引數傳遞給 merge() 方法，實現如下：
private void sort(int[] nums, int left, int right, int[] temp) {
if (left >= right) {
return;
}
// 劃分
int mid = left + right >> 1;
sort(nums, left, mid, temp);
sort(nums, mid + 1, right, temp);
// 合併
merge(nums, left, mid, right, temp);
}
private void merge(int[] nums, int left, int mid, int right, int[] temp) {
System.arraycopy(nums, left, temp, left, right - left + 1);
int l = left, r = mid + 1;
for (int i = left; i <= right; i++) {
if (l > mid) {
nums[i] = temp[r++];
} else if (r > right || temp[l] < temp[r]) {
nums[i] = temp[l++];
} else {
nums[i] = temp[r++];
}
}
}
當陣列有序時，跳過 merge() 方法
我們可以在執行合併前新增判斷條件：如果nums[mid] <= nums[mid + 1]時我們認為陣列已經是有序的了，那麼我們就跳過 merge() 方法。它不影響排序的遞迴呼叫，但是對任意有序的子陣列演算法的執行時間就變成線性的了，程式碼實現如下：
private void sort(int[] nums, int left, int right, int[] temp) {
if (left >= right) {
return;
}
// 劃分
int mid = left + right >> 1;
sort(nums, left, mid, temp);
sort(nums, mid + 1, right, temp);
// 合併
if (nums[mid] > nums[mid + 1]) {
merge(nums, left, mid, right, temp);
}
}
private void merge(int[] nums, int left, int mid, int right, int[] temp) {
System.arraycopy(nums, left, temp, left, right - left + 1);
int l = left, r = mid + 1;
for (int i = left; i <= right; i++) {
if (l > mid) {
nums[i] = temp[r++];
} else if (r > right || temp[l] < temp[r]) {
nums[i] = temp[l++];
} else {
nums[i] = temp[r++];
}
}
}
對小規模子陣列使用插入排序
對小規模陣列進行排序會使遞迴呼叫過於頻繁，而使用插入排序處理小規模子陣列一般可以將歸併排序的執行時間縮短 10% ~ 15%，程式碼實現如下：
/**
* M 取值在 5 ~ 15 之間大多數情況下都能令人滿意
*/
private final int M = 9;
private void sort(int[] nums, int left, int right) {
if (left + M >= right) {
// 插入排序
insertSort(nums);
return;
}
// 劃分
int mid = left + right >> 1;
sort(nums, left, mid);
sort(nums, mid + 1, right);
// 合併
merge(nums, left, mid, right);
}
/**
* 插入排序
*/
private void insertSort(int[] nums) {
for (int i = 1; i < nums.length; i++) {
int base = nums[i];
int j = i - 1;
while (j >= 0 && nums[j] > base) {
nums[j + 1] = nums[j--];
}
nums[j + 1] = base;
}
}
private void merge(int[] nums, int left, int mid, int right) {
// 輔助陣列
int[] temp = Arrays.copyOfRange(nums, left, right + 1);
int leftBegin = 0, leftEnd = mid - left;
int rightBegin = leftEnd + 1, rightEnd = right - left;
for (int i = left; i <= right; i++) {
if (leftBegin > leftEnd) {
nums[i] = temp[rightBegin++];
} else if (rightBegin > rightEnd || temp[leftBegin] < temp[rightBegin]) {
nums[i] = temp[leftBegin++];
} else {
nums[i] = temp[rightBegin++];
}
}
}
快速排序
快速排序也遵循分治的思想，它與歸併排序不同的是，快速排序是原地排序，而且快速排序會先排序當前陣列，再對子陣列進行排序，它的演算法步驟如下：
-
哨兵劃分：選取陣列中最左端元素為基準數，將小於基準數的元素放在基準數左邊，將大於基準數的元素放在基準數右邊
-
排序子陣列：將哨兵劃分的索引作為劃分左右子陣列的分界，分別對左右子陣列進行哨兵劃分和排序
快速排序的程式碼實現如下：
private void sort(int[] nums, int left, int right) {
if (left >= right) {
return;
}
// 哨兵劃分
int partition = partition(nums, left, right);
// 分別排序兩個子陣列
sort(nums, left, partition - 1);
sort(nums, partition + 1, right);
}
/**
* 哨兵劃分
*/
private int partition(int[] nums, int left, int right) {
// 以 nums[left] 作為基準數，並記錄基準數索引
int originIndex = left;
int base = nums[left];
while (left < right) {
// 從右向左找小於基準數的元素
while (left < right && nums[right] >= base) {
right--;
}
// 從左向右找大於基準數的元素
while (left < right && nums[left] <= base) {
left++;
}
swap(nums, left, right);
}
// 將基準數交換到兩子陣列的分界線
swap(nums, originIndex, left);
return left;
}
private void swap(int[] nums, int left, int right) {
int temp = nums[left];
nums[left] = nums[right];
nums[right] = temp;
}
演算法特性：
-
時間複雜度：平均時間複雜度為 O(nlogn)，最差時間複雜度為 O(n2)
-
空間複雜度：最差情況下，遞迴深度為 n，所以空間複雜度為 O(n)
-
原地排序
-
非穩定排序
-
自適應排序
歸併排序的時間複雜度一直是 O(nlogn)，而快速排序在最壞的情況下時間複雜度為 O(n2)，為什麼歸併排序沒有快速排序應用廣泛呢？
答：因為歸併排序是非原地排序，在合併階段需要藉助非常量級的額外空間
快速排序有很多優點，但是在哨兵劃分不平衡的情況下，演算法的效率會比較低效。下面是對快速排序排序最佳化的一些方法：
切換到插入排序
對於小陣列，快速排序比插入排序慢，快速排序的 sort() 方法在長度為 1 的子陣列中也會呼叫一次，所以，在排序小陣列時切換到插入排序排序的效率會更高，如下：
/**
* M 取值在 5 ~ 15 之間大多數情況下都能令人滿意
*/
private final int M = 9;
public void sort(int[] nums, int left, int right) {
// 小陣列採用插入排序
if (left + M >= right) {
insertSort(nums);
return;
}
int partition = partition(nums, left, right);
sort(nums, left, partition - 1);
sort(nums, partition + 1, right);
}
/**
* 插入排序
*/
private void insertSort(int[] nums) {
for (int i = 1; i < nums.length; i++) {
int base = nums[i];
int j = i - 1;
while (j >= 0 && nums[j] > base) {
nums[j + 1] = nums[j--];
}
nums[j + 1] = base;
}
}
private int partition(int[] nums, int left, int right) {
int originIndex = left;
int base = nums[left];
while (left < right) {
while (left < right && nums[right] >= base) {
right--;
}
while (left < right && nums[left] <= base) {
left++;
}
swap(nums, left, right);
}
swap(nums, left, originIndex);
return left;
}
private void swap(int[] nums, int left, int right) {
int temp = nums[left];
nums[left] = nums[right];
nums[right] = temp;
}
基準數最佳化
如果陣列為倒序的情況下，選擇最左端元素為基準數，那麼每次哨兵劃分會導致右陣列長度為 0，進而使快速排序的時間複雜度為 O(n2)，為了儘可能避免這種情況，我們可以對基準數的選擇進行最佳化，採用三取樣切分的方法：選取陣列最左端、中間和最右端這三個值的中位數為基準數，這樣選擇的基準數大機率不是區間的極值，時間複雜度為 O(n2) 的機率大大降低，程式碼實現如下：
public void sort(int[] nums, int left, int right) {
if (left >= right) {
return;
}
// 基準數最佳化
betterBase(nums, left, right);
int partition = partition(nums, left, right);
sort(nums, left, partition - 1);
sort(nums, partition + 1, right);
}
/**
* 基準數最佳化，將 left, mid, right 這幾個值中的中位數換到 left 的位置
* 注意其中使用了異或運算進行條件判斷
*/
private void betterBase(int[] nums, int left, int right) {
int mid = left + right >> 1;
if ((nums[mid] < nums[right]) ^ (nums[mid] < nums[left])) {
swap(nums, left, mid);
} else if ((nums[right] < nums[left]) ^ (nums[right] < nums[mid])) {
swap(nums, left, right);
}
}
private int partition(int[] nums, int left, int right) {
int originIndex = left;
int base = nums[left];
while (left < right) {
while (left < right && nums[right] >= base) {
right--;
}
while (left < right && nums[left] <= base) {
left++;
}
swap(nums, left, right);
}
swap(nums, originIndex, left);
return left;
}
private void swap(int[] nums, int left, int right) {
int temp = nums[left];
nums[left] = nums[right];
nums[right] = temp;
}
三向切分
在陣列有大量重複元素的情況下，快速排序的遞迴性會使元素全部重複的子陣列經常出現，而對這些陣列進行快速排序是沒有必要的，我們可以對它進行最佳化。
一個簡單的想法是將陣列切分為三部分，分別對應小於、等於和大於基準數的陣列，每次將其中“小於”和“大於”的陣列進行排序，那麼最終也能得到排序的結果，這種策略下我們不會對等於基準數的子陣列進行排序，提高了排序演算法的效率，它的演算法流程如下：
從左到右遍歷陣列，維護指標 l 使得 [left, l - 1] 中的元素都小於基準數，維護指標 r 使得 [r + 1, right] 中的元素都大於基準數，維護指標 mid 使得 [l, mid - 1] 中的元素都等於基準數，其中 [mid, r] 區間中的元素還未確定大小關係，圖示如下：
它的程式碼實現如下：
public void sort(int[] nums, int left, int right) {
if (left >= right) {
return;
}
// 三向切分
int l = left, mid = left + 1, r = right;
int base = nums[l];
while (mid <= r) {
if (nums[mid] < base) {
swap(nums, l++, mid++);
} else if (nums[mid] > base) {
swap(nums, mid, r--);
} else {
mid++;
}
}
sort(nums, left, l - 1);
sort(nums, r + 1, right);
}
private void swap(int[] nums, int left, int right) {
int temp = nums[left];
nums[left] = nums[right];
nums[right] = temp;
}
這也是經典的荷蘭國旗問題，因為這就好像用三種可能的主鍵值將陣列排序一樣，這三種主鍵值對應著荷蘭國旗上的三種顏色
巨人的肩膀
-
《演算法 第四版》：2.3 節 快速排序
-
《演算法導論 第三版》：第 2.2、2.3、7 章
作者：京東物流 王奕龍
來源：京東雲開發者社群 自猿其說 Tech 轉載請註明來源