Java双路快速排序算法

双路快速排序算法基本原理

-针对序列中重复元素出现频率非常高，随机化快速排序算法退化成O（n^2）的问题
-双向开始遍历

-当arr[i]>=arr[l],arr[j]<=arr[l]时暂停

-进行归并

-arr[i]与arr[j]交换元素

-当i=j时遍历完毕

代码实现

// 双路快速排序算法,对解决重复性高的元素集合效率高
    public static <T extends Comparable<? super T>> void quickSort2(T[] arr, int n) {
        sonOfQuickSort2(arr, 0, n - 1);
    }

    // 对arr[l...r]部分进行双路快速排序
    private static <T extends Comparable<? super T>> void sonOfQuickSort2(T[] arr, int l, int r) {
        // 当n小到一定程度时，插入排序比归并排序快
        if (r - l <= 15) {
            // 当分块中元素为15+1时，换成插入排序
            SelectionSort.insertionSort(arr, r, l);
            return;
        }
        int index = partition2(arr, l, r);
        sonOfQuickSort2(arr, l, index - 1);
        sonOfQuickSort2(arr, index + 1, r);
    }

    // 对arr[l...r]部分进行partition分治操作，返回值是作为双路分界点
    private static <T extends Comparable<? super T>> int partition2(T[] arr, int l, int r) {
        // 随机生成位置
        int s = (int) (Math.random() * (r - l + 1)) + l;
        T temp1;
        temp1 = arr[s];
        arr[s] = arr[l];
        arr[l] = temp1;
        T v = arr[l];
        // arr[l+1,i)<=v; arr(j,r]>=v;i,j分别从两端向中间逼近
        int i = l + 1, j = r;
        while (true) {
            while (i <= r && arr[i].compareTo(v) < 0)
                i++;
            while (arr[j].compareTo(v) > 0 && j >= l + 1)
                j--;
            if (i > j)
                break;
            // swap(arr[i],arr[j])
            swap(arr[i], arr[j]);
            i++;
            j--;
        }
        swap(arr[l], arr[j]);
        return j;
    }

    public static <T> void swap(T a, T b) {
        T temp;
        temp = a;
        a = b;
        b = temp;
    }

快速排序算法消耗时间316ms
双路快速排序算法消耗时间199ms