快排的复杂度

快排逻辑

快速排序算法通过多次比较和交换来实现排序，其排序流程如下：

1. 首先设定一个分界值(基准值)，通过该分界值将数组分成左右两部分。
2. 将大于或等于分界值的数据集中到数组右边，小于分界值的数据集中到数组的左边。此时，左边部分中各元素都小于分界值，而右边部分中各元素都大于或等于分界值。
3. 然后，左边和右边的数据可以独立排序。对于左侧的数组数据，又可以取一个分界值，将该部分数据分成左右两部分，同样在左边放置较小值，右边放置较大值。右侧的数组数据也可以做类似处理。
4. 重复上述过程，可以看出，这是一个递归定义。通过递归将左侧部分排好序后，再递归排好右侧部分的顺序。当左、右两个部分各数据排序完成后，整个数组的排序也就完成了。

代码实现

    public int[] quickSort(int[] arr, int left, int right) {
        // left 左边界
        // right 右边界
        if (left < right) {
            int partitionIndex = partition(arr, left, right);
            quickSort(arr, left, partitionIndex - 1);
            quickSort(arr, partitionIndex + 1, right);
        }
        return arr;
    }

    private int partition(int[] arr, int left, int right) {
        // 设定基准值（pivot）
        int pivot = left;
        int index = pivot + 1;
        // index 记录数组中比基准数小的数的 最大数组下标
        for (int i = index; i <= right; i++) {
            // 小于目标值基准值 交换位置
            if (arr[i] < arr[pivot]) {
                swap(arr, i, index);
                index++;
            }
        }
        swap(arr, pivot, index - 1);
        return index - 1;
    }

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

排序演示

假设一开始序列{xi}是：5，3，7，6，4，1，0，2，9，10，8。

1. 选择5(下标为0)为基准值，index下标从1开始，i为1，第一次循环 则为 5，3，7，6，4，1，0，2，9，10，8。
2. index下标为2，i为2，第2次循环(7 > 5) 则不进行交换排序为 5，3，7，6，4，1，0，2，9，10，8。
3. index = 2,i = 3, 3次 (6 > 5) 不交换 5，3，7，6，4，1，0，2，9，10，8。
4. index = 2,i = 4, 4次 (4 < 5) 交换 5，3，4，6，7，1，0，2，9，10，8。
5. index = 3,i = 5, 5次 (1 < 5) 交换 5，3，4，1，7，6，0，2，9，10，8。
6. index = 4,i = 6, 6次 (0 < 5) 交换 5，3，4，1，0，6，7，2，9，10，8。
7. index = 5,i = 7, 7次 (2 < 5) 交换 5，3，4，1，0，2，7，6，9，10，8。
8. index = 6,i = 8, 8次 (9 > 5) 不交换 5，3，4，1，0，2，7，6，9，10，8。
9. index = 6,i = 9, 9次 (10 > 5) 不交换 5，3，4，1，0，2，7，6，9，10，8。
10. index = 6,i = 10, 10次 (8 > 5) 不交换 5，3，4，1，0，2，7，6，9，10，8。
    for 循环结束
    最后一次交换
11. index = 6,pivot = 0, 10次 (2 > 5) 交换 2，3，4，1，0，5，7，6，9，10，8。