快速隨機排序的思路是從一個數組中隨機選擇一個主元,然後將這個主元放到陣列的最後.迴圈陣列時,先定義一個指標,發現了比主元小的元素,如果指標和迴圈下標相同

則只是把指標自增,如果發現迴圈下標不同則將迴圈下標與指標位置交換,這樣做的目的是始終保證指標左邊的元素小於主元,最後迴圈結束將主元與指標位置交換.這樣

就將陣列分成了left pivot right.然後再遞迴left,right.　　

private static void quickInternal(int[] a, int l, int r) {
        // 終止條件
        if (l >= r) {
            
 
return;
        }
        // 查詢分割槽點
        int q = partition(a, l, r);
        quickInternal(a, l, q - 1);
        quickInternal(a, q + 1, r);
    }

    // 排序
    private static int partition(int[] a, int l, int r) {
        if (a.length == 1) {
            return 0;
        }
        int random;
        
 
if (l == 0) {
            random = new Random().nextInt(r + 1);
        } else {
            // 不為0  則
            random = new Random().nextInt(r - l) + l;
        }
        if (random != r) {
            int tmp = a[random];
            a[random] = a[r];
            a[r] = tmp;
        }
        int pivot = a[r];
        
 
int m = l;
        for (int j = l; j < r; j++) {
            if (a[j] < pivot) {
                // 如果相等，不交換，同時後移一位
                if (m == j) {
                    m++;
                } else {
                    int temp = a[m];
                    a[m++] = a[j];
                    a[j] = temp;
                }
            }
        }
        int temp = a[m];
        a[m] = a[r];
        a[r] = temp;
        return m;
    }

以下提供一個測試方法.

public static void main(String[] args) {
        Random random = new Random();
        while (true) {
            int length = random.nextInt(10);
            int[] arr = new int[length];
            int[] arr2 = new int[length];
            for (int x = 0; x < length; x++) {
                int i = random.nextInt(10);
                arr[x] = i;
                arr2[x] = i;
            }
            quickInternal(arr, 0, arr.length - 1);
            Arrays.sort(arr2);
            boolean equals = Arrays.equals(arr2, arr);
            System.out.println(equals);
            if (!equals) {
                break;
            }
        }
    }