3-7 双路快速排序法

在有很多重复元素的情况下，放在中间的那个 j 的位置也会使得递归的过程变得很不平衡，这个时候我们也可以采取一定的优化措施。

双路快速排序的思想有的时候又叫“指针碰撞”。双路快排的思想有点不好描述，还包括其中的一些细节，所以可以试着自己多写几遍，其实很好理解的。

双路快排使得在有很多键值重复的情况下，重复的键值能够比较“均匀地”分布在数组的前后。

Java 代码实现：

public class QuickSortTest02 {

    @Test
    public void test02() {
        int[] arr = ArrayUtil.generateRandomArray(100, 1, 100000000);
        int len = arr.length;
        quickSort(arr, 0, len - 1);
        System.out.println(Arrays.toString(arr));
        System.out.println(ArrayUtil.judgeArraySorted(arr));
    }

    private void quickSort(int[] arr, int left, int rihgt) {
        // 当数组的待排序区间只有一个元素的时候，就是递归到底的时候
        // 这里我们仍然可以像归并排序一样，在待排序区间里的元素为 16 个的时候，使用插入排序，进而递归到底
        if (left >= rihgt) {
            return;
        }
        int p = partition(arr, left, rihgt);
        quickSort(arr, left, p - 1);
        quickSort(arr, p + 1, rihgt);

    }

    private static Random random = new Random();

    private int partition(int[] arr, int left, int rihgt) {
        // 随机选取标定点，可以使得递归的过程更加“平衡”
        int randomIndex = left +  random.nextInt(rihgt-left+1);
        swap(arr,left,randomIndex);

        int v = arr[left];
        int i = left + 1;
        int j = rihgt;
        while (true) {
            while (i <= rihgt && arr[i] < v) {
                i++;
            }
            while (j > left && arr[j] > v) {
                j--;
            }
            if (i > j) {
                break;
            }
            swap(arr, i, j);
            i++;
            j--;
        }
        swap(arr, left, j);
        return j;
    }

    private static void swap(int[] arr, int index1, int index2) {
        int temp = arr[index1];
        arr[index1] = arr[index2];
        arr[index2] = temp;
    }
}