目錄
概念
快速排序算法是由C.A.R Hoare在1962年提出來的。快速排序是冒泡排序的改進算法。它也是通過不斷比較和移動交換來實現排序的，只不過它的實現增大了記錄的比較和移動的距離，將關鍵字較大的元素從前面直接放到後面，關鍵字較小的元素直接從後面放到前面，從而減小了比較次數和交換次數。
基本思想
通過一趟排序，將要排序的數據分割成爲獨立的兩個部分，其中一部分的所有數據都比另外一部分的所有數據都要小，然後再按照此方法對這兩部分數據分別進行快速排序，整個排序過程可以遞歸進行，以此達到整個數據變成有序序列。
快速排序詳細步驟圖
![]()
代碼實現
代碼實現 普通快速排序
NormalQuickSort.java
package com.liubin.algorithm.sort.quick;
import java.util.Arrays;
import java.util.Random;
/**
* 〈功能詳細描述〉
*
* @author 劉斌
* @date 2020/3/8
* @see [相關類/方法]（可選）
* @since [產品/模塊版本] （可選）
*/
public class NormalQuickSort {
public static void main(String[] args) {
int[] data1 = {3, 8, 5, 7, 10, 4, 15, 12, 20, 40, 24, 28};
System.out.println("data1排序前==>" + Arrays.toString(data1));
quickSort(data1);
System.out.println("data1排序後==>" + Arrays.toString(data1));
int[] data2 = generateRandomArray(30, 10, 1000);
System.out.println("\ndata2排序前==>" + Arrays.toString(data2));
quickSort(data2);
System.out.println("data2排序後==>" + Arrays.toString(data2));
int[] data3 = generateRandomArray(10000, 10, 20000);// 隨機生成一萬個整數，在10-20000區間
System.out.print("\n在10-20000區間，隨機生成一萬個整數，");
quickSort(data3);
}
public static void quickSort(int[] array) {// 快排
long start = System.nanoTime();
int n = array.length;
if (n <= 1) {// 判斷待排序數組是否爲空數組或只含有一個元素，若是則直接返回
return;
}
quickSortInternal(array, 0, n - 1);
long end = System.nanoTime();
System.out.println("普通(基礎)快排耗時：" + (end - start) + "納秒");// 測試程序耗時
}
// 快排遞歸
private static void quickSortInternal(int[] array, int low, int high) {
if (low >= high) {// 遞歸推出條件
return;
}
int q = partition(array, low, high);// 確定分區點最終位置
quickSortInternal(array, low, q - 1);// 左邊區間（小於區分點元素）遞歸排序
quickSortInternal(array, q + 1, high);// 右邊區間（大於等於區分點元素）遞歸排序
}
/**
* 對數組array[l...r]部分進行partition操作 返回p，使得array[l+1...p-1]<array[p],array[p+1...r]>=array[p]</array[p],array[p+1...r]>
*
* @param array 待排序數組
* @param l 數組開始點
* @param r 數組結束點
* @return 分區點下標
*/
private static int partition(int[] array, int l, int r) {
// 默認比較元素爲待排序數組的第一個元素
int v = array[l];
// [l+1...j]爲<v的元素區間（剛開始爲空區間，隨着<v元素的加入區間加長）
int j = l;
// [j+1...i-1]爲>=v的元素區間（剛開始爲空區間，隨着>=v元素的加入區間加長）
int i = l + 1;// i下標作用在於遍歷除比較元素外的其他元素，即從第二個元素開始到結尾
for (; i <= r; i++) {// 遍歷數組
if (array[i] < v) {// 當大於等於v時保持不動即可，<v時放置j下標區間
swap(array, i, j + 1);
j++;
}
}
// 此時<v元素在前面，>=v元素在後面區間，將<v元素區間的最後一個元素與比較元素交換即可以達到最終效果（區分點元素到達最終位置，<v的元素在區分點左邊區間，>=v的元素在區分點右邊區間）
swap(array, l, j);
return j;// 返回區分點下標
}
private static void swap(int[] array, int i, int j) {// 交換
int temp = array[i];
array[i] = array[j];
array[j] = temp;
}
// 隨機生成數字
public static int[] generateRandomArray(int n, int rangeL, int rangeR) {
if (rangeL > rangeR) {
throw new IndexOutOfBoundsException("越界異常");
}
int[] arr = new int[n];
for (int i = 0; i < n; i++) {
arr[i] = new Integer(new Random().nextInt(rangeR - rangeL + 1) + rangeL);
}
return arr;
}
}
普通快速排序-控制檯輸出
普通快速排序優化版本
上述普通快排存在的問題
NormalQuickSortOptimize.java
package com.liubin.algorithm.sort.quick;
import java.util.Arrays;
import java.util.Random;
/**
* 〈功能詳細描述〉
*
* @author 劉斌
* @date 2020/3/8
* @see [相關類/方法]（可選）
* @since [產品/模塊版本] （可選）
*/
public class NormalQuickSortOptimize {
public static void main(String[] args) {
//首先將10000個整數先排序好，模擬左右分區極度不均衡狀態，
// 比如極端情況下，數組已經升序有序時，每次選擇第一個元素爲區分點導致左右兩個區間極度不平衡，全部元素位於右邊區間，此時就需要大約n次分區操作，每次分區我們大約要掃描n/2個元素
int[] data1 = generateRandomArray(10000, 10, 20000);// 隨機生成一萬個整數，在10-20000區間
System.out.print("\n在10-20000區間，隨機生成一萬個整數，");
quickSort(data1);
int[] data2 = data1;
System.out.println("data2排序前==>" + Arrays.toString(data2));
quickSort(data2);
System.out.println("data2排序後==>" + Arrays.toString(data2));
int[] data3 = data1;
System.out.println("\ndata3排序前==>" + Arrays.toString(data3));
quickSortOptimize(data3);
System.out.println("data3排序後==>" + Arrays.toString(data3));
}
public static void quickSort(int[] array) {// 快排
long start = System.currentTimeMillis();
int n = array.length;
if (n <= 1) {// 判斷待排序數組是否爲空數組或只含有一個元素，若是則直接返回
return;
}
quickSortInternal(array, 0, n - 1);
long end = System.currentTimeMillis();
System.out.println("普通(基礎)快排耗時：" + (end - start) + "毫秒");// 測試程序耗時
}
// 快排遞歸
private static void quickSortInternal(int[] array, int low, int high) {
if (low >= high) {// 遞歸推出條件
return;
}
int q = partition(array, low, high);// 確定分區點最終位置
quickSortInternal(array, low, q - 1);// 左邊區間（小於區分點元素）遞歸排序
quickSortInternal(array, q + 1, high);// 右邊區間（大於等於區分點元素）遞歸排序
}
/**
* 對數組array[l...r]部分進行partition操作 返回p，使得array[l+1...p-1]<array[p],array[p+1...r]>=array[p]</array[p],array[p+1...r]>
*
* @param array 待排序數組
* @param l 數組開始點
* @param r 數組結束點
* @return 分區點下標
*/
private static int partition(int[] array, int l, int r) {
// 默認比較元素爲待排序數組的第一個元素
int v = array[l];
// [l+1...j]爲<v的元素區間（剛開始爲空區間，隨着<v元素的加入區間加長）
int j = l;
// [j+1...i-1]爲>=v的元素區間（剛開始爲空區間，隨着>=v元素的加入區間加長）
int i = l + 1;// i下標作用在於遍歷除比較元素外的其他元素，即從第二個元素開始到結尾
for (; i <= r; i++) {// 遍歷數組
if (array[i] < v) {// 當大於等於v時保持不動即可，<v時放置j下標區間
swap(array, i, j + 1);
j++;
}
}
// 此時<v元素在前面，>=v元素在後面區間，將<v元素區間的最後一個元素與比較元素交換即可以達到最終效果（區分點元素到達最終位置，<v的元素在區分點左邊區間，>=v的元素在區分點右邊區間）
swap(array, l, j);
return j;// 返回區分點下標
}
private static void swap(int[] array, int i, int j) {// 交換
int temp = array[i];
array[i] = array[j];
array[j] = temp;
}
// 隨機生成數字
public static int[] generateRandomArray(int n, int rangeL, int rangeR) {
if (rangeL > rangeR) {
throw new IndexOutOfBoundsException("越界異常");
}
int[] arr = new int[n];
for (int i = 0; i < n; i++) {
arr[i] = new Integer(new Random().nextInt(rangeR - rangeL + 1) + rangeL);
}
return arr;
}
//普通快排優化版本
public static void quickSortOptimize(int[] array) {// 快排
long start = System.currentTimeMillis();
int n = array.length;
if (n <= 1) {// 判斷待排序數組是否爲空數組或只含有一個元素，若是則直接返回
return;
}
quickSortInternalOptimize(array, 0, n - 1);
long end = System.currentTimeMillis();
System.out.println("普通快速排序優化版耗時：" + (end - start) + "毫秒");// 測試程序耗時
}
// 快排遞歸優化版本
private static void quickSortInternalOptimize(int[] array, int low, int high) {
if (low >= high) {// 遞歸推出條件
return;
}
int q = partition(array, low, high);// 確定分區點最終位置
partitionOptimize(array, low, q - 1);// 左邊區間（小於區分點元素）遞歸排序
partitionOptimize(array, q + 1, high);// 右邊區間（大於等於區分點元素）遞歸排序
}
private static int partitionOptimize(int[] array, int l, int r) {// 每次快排隨機生成分區點
// Math.random()爲產生一個[0,1)的隨機數（double）
int randomIndex = (int) (Math.random() * (r - l + 1) + l);// 隨機數*數組長度+左下標然後強轉確保區分點下標在數組合理下標範圍內
swap(array, randomIndex, l);// 將第一個元素與隨機區分點元素交換
int v = array[l];// 每次獲得隨機區分點元素
int j = l;
int i = l + 1;
for (; i <= r; i++) {
if (array[i] < v) {
swap(array, i, j + 1);
j++;
}
}
swap(array, j, l);
return j;
}
}
