时间复杂度：O(Nlog(N))
额外空间复杂度：O(log(N))
是否可实现稳定性：否

思路：

快排思路：把整个区域划分为三个区域，小于区，等于区，大于区
划分标准：从整个数组中随机选一个数，作为等于区的数值
然后比较，设置小于区的最大初始下标为less=l-1，大于区的初始最小下标为more=r， 如果l比r小，就加入小于区 ++less和l++位置的数交换位置； 大于，就把l和--more的数换；等于就l++。然后执行下去，最后返回一个数组，存储的两个数，分别是等于区的起始位置和最后的位置，然后把小于区和大于区分别递归partition过程，最后就拍出来了，在这里小于区是p[0]-1,大于区是p[1]+1，也就是p[p.length-1]

例子：

比如数组{2，4，9，1，4}，4就是随机选出来的等于区划分的标准，开始比较，2小于4，所以小于区+1，和l++交换，继续，4=4所以小于区不变，l++,然后9>4，--more和l换换完之后{2,4,1,9,4,}，然后1<4
小于区+1并且4和1，{2,1,4,9,4}最后把大于区的第一个和4换，结果是{2,1,4,4,9}，然后递归就可以得到结果，实际操作根据代码画图写比较明了，在小于区的下标，和大于区的下标变换中。

代码：

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

    public static void quickSort(int[] arr, int l, int r) {
        if (l < r) {
            //取[l,r]的任意一个数当作等于区的值
            swap(arr, l + (int) (Math.random() * (r - l + 1)), r);
            int[] p = partition(arr, l, r);
            quickSort(arr, l, p[0] - 1);
            quickSort(arr, p[1] + 1, r);
        }
    }


    public static int[] partition(int[] arr,int l,int r){
        //初始的小于区的最大下标
        int less = l-1;
        //大于区的最小下标
        int more = r;
        while (l<more){
            if (arr[l]<arr[r]){
                swap(arr,++less,l++);
            }else if (arr[l]>arr[r]){
                swap(arr,--more,l);
            }else {
                l++;
            }
        }
        //交换大于区的第一个数和r的位置，交换后more的位置就是等于区的最后一个数的位置
        swap(arr,more,r);
        //返回的是等于区的第一个位置和等于区的最后一个位置
        return new int[]{less+1,more};
    }

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

在这里以及之前的i++,++i的区别提醒一下，比如arr[i++] = arr [++j],实际上的执行顺序如下

j = j+1;
arr[i] = arr[j];
i = i +1;