【算法】快速排序

1、 快速排序

快速排序（QuickSort）是一种基于分治思想的高效的排序算法，由英国计算机科学家 Tony Hoare 在 1961 年发明。它的基本思想是通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分关键字小，然后再对这两部分记录分别进行快速排序，以达到整个序列有序的目的。

时间复杂度：

• 最优情况：O(nlogn)
• 最坏情况：O(n^2)
• 平均情况：O(nlogn)

空间复杂度：快速排序是一种原地排序算法，不需要额外的内存空间，因此空间复杂度为 O(1)。

1.1 代码实现：

标准快排

    public static void quickSort(int[] arr, int left, int right) {
        if (left < right) {
            int p = partition1(arr, left, right); // 获取分区节点
            quickSort(arr, left, p - 1); // 对左子数组进行排序
            quickSort(arr, p + 1, right); // 对右子数组进行排序
        }
    }
    
    /**
     * 标准快排
     */
    public static int partition1(int[] arr, int left, int right) {
        for (int j = left; j < right; j++) {
            if (arr[j] < arr[right]) {
                SortUtils.swap(arr, left++, j);
            }
        }
        SortUtils.swap(arr, left, right);
        return left;
    }

快排2.0

每次排序筛选掉等于分区节点的部分，减少后续递归的数量

public static void quickSort2(int[] arr, int left, int right) {
        if (left < right) {
            int[] p = partition2(arr, left, right); // 获取分区节点
            quickSort2(arr, left, p[0] - 1); // 对左子数组进行排序
            quickSort2(arr, p[1] + 1, right); // 对右子数组进行排序
        }
    }
    
    public static int[] partition2(int[] arr, int left, int right) {
        int less = left - 1; // 小于分区点的左边界
        int more = right; // 小于分区点的右边界
        while (left < more) {
            if (arr[left] < arr[right]) {
                SortUtils.swap(arr, left++, ++less);
            } else if (arr[left] > arr[right]) {
                SortUtils.swap(arr, left, --more);
            } else {
                left++;
            }
        }
        SortUtils.swap(arr, more, right);
        return new int[]{less + 1, more};
    }

快排3.0

因为分区点的选取会导致快排的不稳定，原始版本中每次从分组的右边界选择分区点，如果数组已经有序，分区点会导致分区不均衡，从而不能发挥快排的优势。随机选取分区点可以有效避免这种情况。在随机选取的情况下，分区点的位置是随机的，使得快速排序的每次划分都有一定的随机性，在最坏情况下的时间复杂度和空间复杂度都得到了保证

    public static void quickSort3(int[] arr, int left, int right) {
        if (left < right) {
            SortUtils.swap(arr, left + (int) (Math.random() * (right - left + 1)), right);
            int[] p = partition2(arr, left, right); // 获取分区节点
            quickSort2(arr, left, p[0] - 1); // 对左子数组进行排序
            quickSort2(arr, p[1] + 1, right); // 对右子数组进行排序
        }
    }
    
    public static int[] partition3(int[] arr, int left, int right) {
        int less = left - 1; // 小于分区点的左边界
        int more = right; // 小于分区点的右边界
        while (left < more) {
            if (arr[left] < arr[right]) {
                SortUtils.swap(arr, left++, ++less);
            } else if (arr[left] > arr[right]) {
                SortUtils.swap(arr, left, --more);
            } else {
                left++;
            }
        }
        SortUtils.swap(arr, more, right);
        return new int[]{less + 1, more};
    }