隨機在陣列範圍中找一個“基準值”，並將其與陣列最右元素交換作為基準。

與此“基準值”進行比較就可以得到三個區域：小於，等於，大於。遞迴此過程就可以將陣列排好序。

時間複雜度：由於隨機選取一個數，那麼每個數的概率就是 1/N ，拿到的這個數有可能構成最好情況，有可能構成不好不壞的情況，有可能構成最差情況。所以時間複雜度並不穩定。

那麼通過前人的計算可以得到快速排序的時間複雜度：bigO(N*logN)

圖解過程：

程式碼：

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 left,int right){
        if (left < right){      //不越界

            //以陣列最後一個數為“基準”，隨機在陣列取一個數，與最後一個數做交換。
            swap(arr,left + (int)(Math.random()*(right - left + 1)),right);

            
 
//分層 <區 =區 >區
            int[] p = partition(arr,left,right);

            //遞迴，小於區遞迴，大於區遞迴
            quickSort(arr,left,p[0]-1);     //p[0]是分層後的陣列 等於區的左邊界 p[0]-1是 小於區的最後一個元素
            quickSort(arr,p[1]+1,right);     //p[1]是分層後的陣列 等於區的右邊界 p[1]+1是 大於區的第一個元素
        }
    }

    //荷蘭國旗是以target目標值 作為劃分
    
 
//快速排序是以陣列最右位置上的元素arr[R] 作為劃分
    public static int[] partition(int[] arr,int left,int right){
        int less = left - 1;    //小於區的右邊界
        int more = right;       //大於區的左邊界
        int when = left;        //when代表當前值
        while (when < more){
            if (arr[when] < arr[right]){    //當前值 ＜ 基準值
                swap(arr,++less,when++);
            }else if (arr[when] > arr[right]){
                swap(arr,--more,when);
            }else
                when++;
        }
        //此時已經分好區，把最後一個元素與＞區第一個元素交換，得到左邊：＜基準值的區域，中間=基準值的區域，右邊：＞基準值的區域
        swap(arr,more,right);

        int[] res = {less + 1,more};
        return res;
    }