算法数据结构：快速排序

1、介绍

快速排序算法（Quick Sort）利用的也是分治思想。其基本思想：如果要排序数组中小标从[L, R]之间的一组数据，我们选择[L, R]之间任意一个数据作为 pivot（分区点）。

2、分析

2.1、快排 v1.0

在arr[L, R]范围上，进行快速排序的过程：

1. 选择arr[R]记为pivot
2. 用pivot对该范围做partition
   • 小于等于arr[R]的数在左部分（[L, M - 1]）
   • arr[R]在左部分的最后（[M]）；
   • 大于arr[R]的数在右部分（[M + 1, R]）
3. 对arr[L, M - 1]进行快速排序（递归）
4. 对arr[M + 1, R]进行快速排序（递归） 因为每一次partition都会搞定一个数的位置且不会再变动，所以排序能完成

2.2、快排 v2.0

在arr[L, R]范围上，进行快速排序的过程：

1. 选择arr[R]记为pivot
2. 用pivot对该范围做partition
   • 小于pivot的数在左部分（[L, a - 1]）
   • 等于pivot的数在中间（[a, b]）
   • 大于pivot的数在右部分（[b + 1, R]）
3. 对arr[L, a - 1]进行快速排序（递归）
4. 对arr[b + 1, R]进行快速排序（递归） 因为每一次partition都会搞定一批数的位置且不会再变动，所以排序能完成

2.3、快排 v3.0

在arr[L, R]范围上，进行快速排序的过程：

1. 在这个范围上，随机选一个数记为pivot
2. 用pivot对该范围做partition
   • 小于pivot的数在左部分（[L, a - 1]）
   • 等于pivot的数在中间（[a, b]）
   • 大于pivot的数在右部分（[b + 1, R]）
3. 对arr[L, a - 1]进行快速排序（递归）
4. 对arr[b + 1, R]进行快速排序（递归） 因为每一次partition都会搞定一批数的位置且不会再变动，所以排序能完成

3、实现

3.1、快排 v1.0

import class01.ArraySortUtils;

/**
 * @description: 快速排序
 * @author: erlang
 * @since: 2020-11-01 21:03
 */
public class QuickSort {

    private static void process(int[] arr, int left, int right) {
        if (left >= right) {
            return;
        }
        int pivot = QuickSortUtils.partition(arr, left, right);
        process(arr, left, pivot - 1);
        process(arr, pivot + 1, right);
    }

    private static void quickSort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }
        process(arr, 0, arr.length - 1);
    }

    public static void main(String[] args) {
        ArraySortUtils.testSort(QuickSort::quickSort, 100, 100);
    }
}

3.2、快排 v2.0

import class01.ArraySortUtils;

/**
 * @description: 快速排序
 * @author: erlang
 * @since: 2020-11-01 21:36
 */
public class QuickSort {

    public static void process(int[] arr, int left, int right) {
        if (left >= right) {
            return;
        }

        int[] pivotArea = QuickSortUtils.netherlandsFlag(arr, left, right);
        process(arr, left, pivotArea[0] - 1);
        process(arr, pivotArea[1] + 1, right);
    }

    public static void quickSort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }

        process(arr, 0, arr.length - 1);
    }

    public static void main(String[] args) {
        ArraySortUtils.testSort(QuickSort::quickSort, 100, 100);
    }
}

3.3、快排 v3.0

import class01.ArraySortUtils;

/**
 * @description: 快速排序
 * @author: erlang
 * @since: 2020-11-01 23:36
 */
public class QuickSort {

    private static void process(int[] arr, int left, int right) {
        if (left >= right) {
            return;
        }
        // 随机抽取一个数作为分区点
        ArraySortUtils.swap(arr, left + (int) Math.random() * (right - left + 1), right);
        int[] pivotArea = QuickSortUtils.netherlandsFlag(arr, left, right);
        process(arr, left, pivotArea[0] - 1);
        process(arr, pivotArea[1] + 1, right);
    }

    public static void quickSort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }
        process(arr, 0, arr.length - 1);
    }

    public static void main(String[] args) {
        ArraySortUtils.testSort(QuickSort::quickSort, 100, 100);
    }

}

4.1、工具类

QuickSortUtils

import class01.ArraySortUtils;

/**
 * @description: 快速排序
 * @author: erlang
 * @since: 2020-11-01 23:48
 */
public class QuickSortUtils {

    /**
     * - 小于等于`arr[R]`的数在左部分（`[L, M - 1]`）
     * - `arr[R]`在左部分的最后（`[M]`）；
     * - 大于`arr[R]`的数在右部分（`[M + 1, R]`）
     *
     * @param arr   待分区数组
     * @param left  左边界
     * @param right 右边界
     * @return 分区点索引
     */
    public static int partition(int[] arr, int left, int right) {
        if (left > right) {
            return -1;
        }

        if (left == right) {
            return left;
        }
        // 小于等于区的右边界
        int pivotLeft = left - 1;
        int index = left;
        // 分区点
        int pivot = arr[right];
        // index 和右边界碰上时，终止
        while (index < right) {
            if (arr[index] <= pivot) {
                // 当前数小于等于分区点，当前数和小于等于区下一个交换，小于等于区右扩
                ArraySortUtils.swap(arr, index, ++pivotLeft);
            }
            // index 右移
            index++;
        }
        ArraySortUtils.swap(arr, ++pivotLeft, right);
        return pivotLeft;
    }


    /**
     * 选择`arr[R]`记为`pivot`
     * 用`pivot`对该范围做`partition`
     * - 小于`pivot`的数在左部分（`[L, a - 1]`）
     * - 等于`pivot`的数在中间（`[a, b]`）
     * - 大于`pivot`的数在右部分（`[b + 1, R]`）
     *
     * @param arr   待分区数组
     * @param left  左边界
     * @param right 有边界
     * @return 分区点
     */
    public static int[] netherlandsFlag(int[] arr, int left, int right) {
        if (left > right) {
            return new int[]{-1, -1};
        }

        if (left == right) {
            return new int[]{left, right};
        }
        // 小于区，右边界
        int pivotLeft = left - 1;
        // 大于区，左边界
        int pivotRight = right;
        // 分区点
        int pivot = arr[right];
        while (left < pivotRight) {
            if (arr[left] == pivot) {
                // 当前数等于分区点时，当前索引右移
                left++;
            } else if (arr[left] < pivot) {
                // 当前数小于分区点，当前索引右移，
                // 当前数和小于区右一个交换
                // 小于区右移
                ArraySortUtils.swap(arr, left++, ++pivotLeft);
            } else {
                // 当前数大于分区点，当前索引不动
                // 大于区左移
                ArraySortUtils.swap(arr, left, --pivotRight);
            }
        }
        ArraySortUtils.swap(arr, pivotRight, right);
        return new int[]{pivotLeft + 1, pivotRight};
    }

}

ArraySortUtils

import java.util.Arrays;
import java.util.function.Consumer;

/**
 * @description: 数组排序工具
 * @author: erlang
 * @since: 2020-08-29 10:49
 */
public class ArraySortUtils {

    public static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

    /**
     * 随机生成待测试的数组
     *
     * @param maxSize  数组最大长度
     * @param maxValue 数组中最大的值
     * @return 返回生成的数组
     */
    public static int[] generateRandomArray(int maxSize, int maxValue) {
        int[] arr = new int[(int) ((maxSize + 1) * Math.random())];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int) ((maxValue + 1) * Math.random()) - (int) (maxValue * Math.random());
        }
        return arr;
    }

    /**
     * 输出数组的元素
     *
     * @param arr 数组
     */
    public static void printArray(int[] arr) {
        System.out.println("");
        System.out.println("+++++++++++++++++++++++++++++++++++++++++++++++++++START");
        for (int value : arr) {
            System.out.print(value + " ");
        }
        System.out.println("");
        System.out.println("+++++++++++++++++++++++++++++++++++++++++++++++++++END");
    }

    public static void comparator(int[] arr) {
        Arrays.sort(arr);
    }

    /**
     * 重新复制一个新数组
     *
     * @param arr 待复制的数组
     * @return 返回复制的新数组
     */
    public static int[] copyArray(int[] arr) {
        if (arr == null) {
            return null;
        }
        int[] res = new int[arr.length];
        System.arraycopy(arr, 0, res, 0, arr.length);
        return res;
    }

    /**
     * 比较两个数组的元素是否相等
     *
     * @param arr1 待比较的数组 1
     * @param arr2 待比较的数组 2
     * @return 返回校验结果 true/false
     */
    public static boolean isEqual(int[] arr1, int[] arr2) {
        if (arr1 == null && arr2 == null) {
            return true;
        }
        if (arr1 == null || arr2 == null) {
            return false;
        }
        if (arr1.length != arr2.length) {
            return false;
        }
        for (int i = 0; i < arr1.length; i++) {
            if (arr1[i] != arr2[i]) {
                return false;
            }
        }
        return true;
    }

    /**
     * 测试排序方法的排序结果是否正确
     *
     * @param consumer 回调用户自定义的排序方法
     * @param maxSize  数组最大长度
     * @param maxValue 数组中最大的数，即 0 - maxValue
     */
    public static void testSort(Consumer<int[]> consumer, int maxSize, int maxValue) {
        int testTime = 5000;
        boolean succeed = true;
        for (int i = 0; i < testTime; i++) {
            // 生成新数组
            int[] arr1 = ArraySortUtils.generateRandomArray(maxSize, maxValue);
            // 复制新数组
            int[] arr2 = copyArray(arr1);
            // 回调用户自定义的排序方法，对 arri1 排序
            consumer.accept(arr1);
            // 使用系统自带的排序方法，对 arr2 排序
            comparator(arr2);
            // 比较两种处理结果是否一致
            if (!isEqual(arr1, arr2)) {
                succeed = false;
                printArray(arr1);
                printArray(arr2);
                break;
            }
        }
        // 输出测试结果
        System.out.println(succeed ? "Nice!" : "Fail!");
    }
}