時間復雜度：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;