1、快排的核心思想：

1、从无序的数组中找到一个枢轴元素M，将数组一分为二：如将数组的第一个元素设置为枢轴元素。
2、然后从数组的左右开始找元素：
满足的规则是

a、从右侧开始找比枢轴元素M小的元素，如果找到将该元素X（right）跟枢轴元素M交换位置，即更小的数字换到了数组前面。
b、再从左侧开始找比枢轴元素M大的元素，如果找到将该元素Y（left）跟枢轴元素M交换位置，即更大的数字换到了数组后面。
c、对a,b步骤交替进行。
d、最终的时候，right和left会重合 ，且该位置放置M元素。`

3、此时将数组，在M的前面都是比M小的元素，在M的后面都是比M大的元素。
4、然后分别对M前面元素组成的数组，M元素后的元素组成的数组递归调用2步骤封装的方法即可

java版本代码实现如下：

package com.example.demo.chapter06.controller;

import java.util.Arrays;

public class Solution {

    public static void main(String[] args) {
        quickSort(new int[] {39,28,55,87,66,3,17,40});
    }


    public static void quickSort(int[] arr) {
//      快排传入的内容： 数组，数组开始的位置，数组的末尾。
        quickSort(arr, 0, arr.length - 1);
        System.out.println(Arrays.toString(arr));
    }

    // arr 代表目标数组
    public static void quickSort(int[] arr, int left, int right) {
//      保存每次排序后，分界点的在数组中的位置
        int middle;
        if (left < right) {
//          返回每次排序后，分界点在数组中的位置。比如返回的3， 则是代表分界值在数组的第4个位置。
            middle = partition(arr, left, right);
            System.out.println(middle);
//          分别对于分界值两侧的数组，进行递归调用。
//          对于左侧数组：left 第一次是传入的初始位置， right则是分界值的位置-1。
//          对于右侧数组，left 是分界值的位置+1， right是最后的位置。
            quickSort(arr, left, middle-1);
            quickSort(arr, middle+1, right);
        }

    }

    /**
     *
     * @param arr
     * @param left
     * @param right
     * @return  最终分界值的索引位置。
     */
    public static int partition(int[] arr, int left, int right) {
        int pivot = arr[left];
        while (left < right) {
//          当右边的元素如果比标志位一直大的话，就不断执行该循环。
//          当从右侧找到了比其小的元素，就将该元素与标志位置交换位置。
            while (left < right && arr[right] >= pivot) {
                right--;
            }
//          将找到的数，放置到设置的目标值上。  此时arr[right]相当于置为空了
            arr[left] = arr[right];

            // 左边查找的方式.  当遍历元素小于标识位的时候，进行移动。
            while (left < right && arr[left] <= pivot) {
                left++;
            }
            //          将找到的数，放置到设置的目标值上。 此时arr[left]相当于置为空了
            arr[right] = arr[left];

        }
//      将最终的目标值（分界线值），放置到arr[left] 上
        arr[left] = pivot;
        return left;
    }


}

测试结果：

image.png

2、时间复杂度分析：

时间复杂度分析：
①、最好的情况，每次算的数据刚好将数组平均分成2个部分
说明：
根据代码分析，每次的递归操作，该次递归传入的元素个数，需要减去掉枢轴元素（1个元素并没有传递给下一次递归），当数据量足够大的时候，每次减去一个
元素对时间复杂度的影响不大，所以可暂时忽略。

image.png

第一轮操作，头尾指针加在一起会扫描整个数组. 共有n次操作 （忽略掉-1的轴枢元素）
第二轮操作，有2次递归操作，每次有n/2次（忽略掉-1的轴枢元素），共有n次操作。
第三轮操作，有4次递归操作，每次有n/4次， 共有n次操作。

第k轮操作， 有2^{k-1次递归草最，每次有n/(2}k-1)次操作，共n次操作。

递归结束的条件最后只有一个元素即 n/(2^l-1) = 1

解出 k= logn + 1, 及总共有k轮循环。

所以时间复杂度位 n * (logn + 1) 即为O（nlog2 n）

②、最坏时间复杂度
当待排序的序列为正序或逆序排列时，且每次划分只得到一个比上一次划分少一个记录的子序列，注意另一个为空。

如果递归树画出来，它就是一棵斜树。此时需要执行n‐1次递归调用，且第i次划分需要经过n‐i次关键字的比较才能找到第i个记录，也就是枢轴的位置，因此比较次数为

image.png

最终其时间复杂度为O(n^2)。

程序执行结果：

初始数组为{9,8,7,6,5,4,3,2,1}

image.png

递归调用了n-1次

第1次划分，需要8次排序才找到了轴枢元素9的位置：即将9月其他元素比较，得到9的位置，此时将数组分成{1, 8, 7, 6, 5, 4, 3, 2}和{}

第2次划分，需要7次找到了轴枢元素1的位置： 即1与除掉9这个最大的其他元素作比较，得到1的位置。此时将数组分成{} 和 {8, 7, 6, 5, 4, 3, 2, 9}

第3次划分，需要6次找到了轴枢元素8的位置：及8与其他元素作比较，得到8位位置，此时将数组分为{1, 2, 7, 6, 5, 4, 3} 和 {}

第i次划分，需要n-i次知道轴枢元素i的位置。

所以总的查找次数为： n-1 + n-2 + .... + 1 = n(n-1)/2

即时间复杂度为O(n^2)