什么是快速排序？
摘自漫畫算法：
同冒泡排序一樣，快速排序也屬于交換排序，通過元素之間的比較和交換位置來達(dá)到排序的目的。
不同的是，冒泡排序在每一輪中只把1個(gè)元素冒泡到數(shù)列的一端，而快速排序則在每一輪挑選一個(gè)基準(zhǔn)元素，并讓其他比它大的元素移動(dòng)到數(shù)列的一端，比它小的元素移動(dòng)到數(shù)列的另一端，從而把數(shù)列拆解成兩個(gè)部分。
這種思路就叫做分治法。
每次把數(shù)列分成兩部分，究竟有什么好處呢？
假如給出一個(gè)8個(gè)元素的數(shù)列，一般情況下，使用冒泡排序需要比較7輪，每一輪把1個(gè)元素移動(dòng)到數(shù)列的一端，時(shí)間復(fù)雜度為O(n2)。
而快速排序的流程是什么樣子呢？
如上圖所示，在分治法的思想下，原數(shù)列的每一輪都被拆分成兩部分，每一部分在下一輪又分別被拆分成兩部分，知道不可再分為止。
每一輪的比較和交換，需要把數(shù)組全部元素都遍歷一遍，時(shí)間復(fù)雜度為O(n)。這樣的遍歷一共需要多少輪呢？假如元素個(gè)數(shù)是n，那么平均情況下需要logn輪，因此快速排序算法總體的平均時(shí)間復(fù)雜度為O(nlogn)。
基準(zhǔn)元素的選擇
基準(zhǔn)元素，英文是pivot，在分治過程中，以基準(zhǔn)元素為中心，把其他元素移動(dòng)到它的左右兩邊。
那么如何選擇基準(zhǔn)元素呢？
最簡單的方式是選擇數(shù)列的第一個(gè)元素。
這種選擇在絕大多數(shù)情況下是沒有問題的。但是假如有一個(gè)原本逆序的數(shù)列，期望排序成順序數(shù)列，那么會(huì)出現(xiàn)什么情況呢？
如上圖所示，整個(gè)數(shù)列并沒有被分成兩個(gè)部分，每一輪都只確定了基準(zhǔn)元素的位置。在這種情況下，數(shù)列的第1個(gè)元素；要么是最小值，要么是最大值，根本無法發(fā)揮分治法的優(yōu)勢。在這種極端的情況下，快速排序需要進(jìn)行n輪，時(shí)間復(fù)雜度退化成了O(n2)。
那么，該怎么避免這種情況發(fā)生呢？
其實(shí)很簡單，我們可以隨機(jī)選擇一個(gè)元素作為基準(zhǔn)元素，并且讓基準(zhǔn)元素和數(shù)列首元素交換位置。
這樣一來，即使在數(shù)列完全逆序的情況下，也可以有效地將數(shù)列分成兩部分。
當(dāng)然，即使是隨機(jī)選擇基準(zhǔn)元素，也會(huì)有極小的幾率選到數(shù)列的最大值或最小值，同樣會(huì)影響分治的效果。
所以，雖然快速排序的平均時(shí)間復(fù)雜度是O(nlogn)，但最壞情況下的時(shí)間復(fù)雜度是O(n2)。
在后文中，為了簡化步驟，省去了隨機(jī)選擇基準(zhǔn)元素的過程，直接把首元素作為基準(zhǔn)元素。
快速排序的實(shí)現(xiàn)
遞歸實(shí)現(xiàn)
選定了基準(zhǔn)元素以后，我們要做的就是把其他元素中小于基準(zhǔn)元素的都交換到基準(zhǔn)元素一邊，大于基準(zhǔn)元素的都交換到基準(zhǔn)元素的另一邊。
具體如何實(shí)現(xiàn)呢？有兩種方法。
-
雙邊循環(huán)法
何謂雙邊循環(huán)法？下面來看一看詳細(xì)過程。
給出原始數(shù)列如下，要求對其從小到大進(jìn)行排序。
元素的交換—雙邊循環(huán)法1.png首先，選定基準(zhǔn)元素pivot，并且設(shè)置兩個(gè)指針left和right，指向數(shù)列的最左和最右兩個(gè)元素。
元素的交換—雙邊循環(huán)法2.png接下來進(jìn)行第1次循環(huán)，從right指針開始，讓指針?biāo)赶虻脑睾突鶞?zhǔn)元素做比較。如果大于或等于pivot，則指針向左移動(dòng)，如果小于pivot，則right指針停止移動(dòng)，切換到left指針。
在當(dāng)前數(shù)列中，1小于4，所以right直接停止移動(dòng)，換到left指針，進(jìn)行下一步行動(dòng)。
輪到left指針行動(dòng)，讓指針?biāo)赶虻脑睾突鶞?zhǔn)元素進(jìn)行比較。如果小于或等于pivot，則指針向右移動(dòng)，如果大于pivot，則left指針停止移動(dòng)。
由于left開始指向的是基準(zhǔn)元素，判斷肯定相等，所以left右移1位。
元素的交換—雙邊循環(huán)法3.png由于7大于4，left指針在元素7的位置停下。這時(shí)，讓left和right指針?biāo)赶虻脑剡M(jìn)行交換。
元素的交換—雙邊循環(huán)法4.png接下來，進(jìn)入第2次循環(huán)，重新切換到right指針，向左移動(dòng)。right指針先移動(dòng)到8，8大于4，繼續(xù)左移。由于2小于4，停止在2的位置。
按照這個(gè)思路，后續(xù)步驟如圖所示：
元素的交換—雙邊循環(huán)法5.png整體代碼如下（使用遞歸的方式）：
import java.util.Arrays; /** * Create By ZhangBiao * 2020/5/22 */ public class Sort { /** * 快速排序 * * @param arr * @param startIndex * @param endIndex */ public static void quickSort(int[] arr, int startIndex, int endIndex) { // 遞歸結(jié)束條件：startIndex大于或等于endIndex時(shí) if (startIndex >= endIndex) { return; } // 得到基準(zhǔn)元素位置 int pivotIndex = partition(arr, startIndex, endIndex); // 根據(jù)基準(zhǔn)元素，分成兩部分進(jìn)行遞歸排序 quickSort(arr, startIndex, pivotIndex - 1); quickSort(arr, startIndex + 1, endIndex); } /** * 分治法（雙邊循環(huán)法） * * @param arr 待交換的數(shù)組 * @param startIndex 起始下標(biāo) * @param endIndex 結(jié)束下標(biāo) * @return */ private static int partition(int[] arr, int startIndex, int endIndex) { // 取第1個(gè)位置（也可以選擇隨機(jī)位置）的元素作為基準(zhǔn)元素 int pivot = arr[startIndex]; int left = startIndex; int right = endIndex; while (left != right) { // 控制right指針比較并左移 while (left < right && arr[right] > pivot) { right--; } // 控制left指針比較并右移 while (left < right && arr[left] <= pivot) { left++; } // 交換left和right指針?biāo)赶虻脑? if (left < right) { int p = arr[left]; arr[left] = arr[right]; arr[right] = p; } } // pivot和指針重合點(diǎn)交換 arr[startIndex] = arr[left]; arr[left] = pivot; return left; } public static void main(String[] args) { int[] arr = new int[]{4, 7, 6, 5, 3, 2, 8, 1}; quickSort(arr, 0, arr.length - 1); System.out.println(Arrays.toString(arr)); } }在上述代碼中，quickSort方法通過遞歸的方式，實(shí)現(xiàn)了分而治之的思想。
partition方法則實(shí)現(xiàn)了元素的交換，讓數(shù)列中的元素依據(jù)自身大小，分別交換到基準(zhǔn)元素的左右兩邊。在這里，我們使用的交換方式是雙邊循環(huán)法。
-
單邊循環(huán)法
雙邊循環(huán)法從數(shù)組的兩邊交替遍歷元素，雖然更加直觀，但是代碼實(shí)現(xiàn)相對繁瑣。而單邊循環(huán)法則簡單的多，只從數(shù)組的一邊對元素進(jìn)行遍歷和交換。我們來看一看詳細(xì)過程。
給出原始數(shù)列如下，要求對其從小到大進(jìn)行排序。
元素的交換—單邊循環(huán)法1.png開始和雙邊循環(huán)法相似，首先選定基準(zhǔn)元素pivot。同時(shí)，設(shè)置一個(gè)mark指針指向數(shù)列起始位置，這個(gè)mark指針代表小于基準(zhǔn)元素的區(qū)域邊界。
元素的交換—單邊循環(huán)法2.png接下來，從基準(zhǔn)元素的下一個(gè)位置開始遍歷數(shù)組。
如果遍歷到的元素大于基準(zhǔn)元素，就繼續(xù)往后遍歷。
如果遍歷到的元素小于基準(zhǔn)元素，則需要做兩件事：第一，把mark指針右移1位，因?yàn)樾∮趐ivot的區(qū)域邊界增大了1；第二，讓最新遍歷到的元素和mark指針?biāo)谖恢玫脑亟粨Q位置，因?yàn)樽钚卤闅v的元素歸屬于小于pivot的區(qū)域。
首先遍歷到元素7，由于7大于4，所以繼續(xù)遍歷。
元素的交換—單邊循環(huán)法3.png接下來遍歷到的元素是3，由于3小于4，所以mark指針右移1位。
元素的交換—單邊循環(huán)法4.png隨后，讓元素3和mark指針?biāo)谖恢玫脑剡M(jìn)行交換，因?yàn)樵?歸屬于小于pivot的區(qū)域。
元素的交換—單邊循環(huán)法5.png按照這個(gè)思路，繼續(xù)遍歷，后續(xù)步驟如圖所示：
元素的交換—單邊循環(huán)法6.png整體代碼如下：
import java.util.Arrays; /** * Create By ZhangBiao * 2020/5/22 */ public class Sort { /** * 快速排序 * * @param arr * @param startIndex * @param endIndex */ public static void quickSort(int[] arr, int startIndex, int endIndex) { // 遞歸結(jié)束的條件：startIndex >= endIndex if (startIndex >= endIndex) { return; } // 得到基準(zhǔn)元素位置 int pivotIndex = partition(arr, startIndex, endIndex); // 根據(jù)基準(zhǔn)元素，分成兩部分進(jìn)行遞歸排序 quickSort(arr, startIndex, pivotIndex - 1); quickSort(arr, pivotIndex + 1, endIndex); } /** * 分治法（單邊循環(huán)法） * * @param arr 待交換的數(shù)組 * @param startIndex 起始下標(biāo) * @param endIndex 結(jié)束下標(biāo) * @return */ private static int partition(int[] arr, int startIndex, int endIndex) { // 取第1個(gè)位置（也可以選擇隨機(jī)位置）的元素作為基準(zhǔn)元素 int pivot = arr[startIndex]; int mark = startIndex; for (int i = startIndex + 1; i <= endIndex; i++) { if (arr[i] < pivot) { mark++; int p = arr[mark]; arr[mark] = arr[i]; arr[i] = p; } } arr[startIndex] = arr[mark]; arr[mark] = pivot; return mark; } public static void main(String[] args) { int[] arr = new int[]{4, 7, 3, 5, 6, 2, 8, 1}; quickSort(arr, 0, arr.length - 1); System.out.println(Arrays.toString(arr)); } }可以很明顯的看出，partition方法只要一個(gè)大循環(huán)就搞定了，的確比雙邊循環(huán)法簡單多了。
非遞歸實(shí)現(xiàn)
注意：絕大多數(shù)的遞歸邏輯，都可以用棧的方式來代替。
為什么這樣說呢？
在方法中一層一層的調(diào)用方法，本身就使用了一個(gè)方法調(diào)用棧。每次進(jìn)入一個(gè)新方法，就相當(dāng)于入棧；每次有方法返回，將相當(dāng)于出棧，所以，可以把原本的遞歸實(shí)現(xiàn)轉(zhuǎn)化成一個(gè)棧的實(shí)現(xiàn)，在棧中存儲(chǔ)每一次方法調(diào)用的參數(shù)。
整體代碼如下：
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.Stack;
/**
* Create By ZhangBiao
* 2020/5/22
*/
public class Sort {
/**
* 快速排序
*
* @param arr
* @param startIndex
* @param endIndex
*/
public static void quickSort(int[] arr, int startIndex, int endIndex) {
// 用一個(gè)集合棧來代替遞歸的函數(shù)棧
Stack<Map<String, Integer>> quickSortStack = new Stack<>();
// 整個(gè)數(shù)列的起止下標(biāo)，以哈希的形式入棧
HashMap<String, Integer> rootParam = new HashMap<>();
rootParam.put("startIndex", startIndex);
rootParam.put("endIndex", endIndex);
quickSortStack.push(rootParam);
// 循環(huán)結(jié)束條件：棧為空時(shí)
while (!quickSortStack.isEmpty()) {
// 棧頂元素出棧，得到起止下標(biāo)
Map<String, Integer> param = quickSortStack.pop();
// 得到基準(zhǔn)元素位置
int pivotIndex = partition(arr, param.get("startIndex"), param.get("endIndex"));
//根據(jù)基準(zhǔn)元素分成兩部分，把每一部分的起止下標(biāo)入棧
if (param.get("startIndex") < pivotIndex - 1) {
HashMap<String, Integer> leftParam = new HashMap<>();
leftParam.put("startIndex", param.get("startIndex"));
leftParam.put("endIndex", pivotIndex - 1);
quickSortStack.push(leftParam);
}
if (pivotIndex + 1 < param.get("endIndex")) {
HashMap<String, Integer> rightParam = new HashMap<>();
rightParam.put("startIndex", pivotIndex + 1);
rightParam.put("endIndex", param.get("endIndex"));
quickSortStack.push(rightParam);
}
}
}
/**
* 分治法（單邊循環(huán)法）
*
* @param arr 待交換的數(shù)組
* @param startIndex 起始下標(biāo)
* @param endIndex 結(jié)束下標(biāo)
* @return
*/
private static int partition(int[] arr, int startIndex, int endIndex) {
// 取第1個(gè)位置（也可以選擇隨機(jī)位置）的元素作為基準(zhǔn)元素
int pivot = arr[startIndex];
int mark = startIndex;
for (int i = startIndex + 1; i <= endIndex; i++) {
if (arr[i] < pivot) {
mark++;
int p = arr[mark];
arr[mark] = arr[i];
arr[i] = p;
}
}
arr[startIndex] = arr[mark];
arr[mark] = pivot;
return mark;
}
public static void main(String[] args) {
int[] arr = new int[]{4, 7, 3, 5, 6, 2, 8, 1};
quickSort(arr, 0, arr.length - 1);
System.out.println(Arrays.toString(arr));
}
}
和遞歸實(shí)現(xiàn)相比，非遞歸方式代碼的變動(dòng)只發(fā)生在quickSort方法中。該方法引入了一個(gè)存儲(chǔ)Map類型元素的棧，用于存儲(chǔ)每一次交換時(shí)的起始下標(biāo)和結(jié)束下標(biāo)。
每一次循環(huán)，都會(huì)讓棧頂元素出棧，通過partition方法進(jìn)行分治，并且按照基準(zhǔn)元素的位置分成左右兩部分，左右兩部分再分別入棧。當(dāng)棧為空時(shí)，說明排序已經(jīng)完畢，退出循環(huán)。
