快速排序之三门快排

快速排序之三门快排

/**
 * @author : fzz
 */
public class MergeData {
    private Integer[] arr;

    public MergeData(int n) {
        arr = new Integer[n];
        for (int i = 0; i < n; i++) {
            arr[i] = (int) (Math.random() * n + 1);
        }
    }

    public Integer getLength() {
        return arr.length;
    }

    private void swap(int i, int j) {
        int t = arr[i];
        arr[i] = arr[j];
        arr[j] = t;
    }

    /**
     * 普通快排
     * @param start
     * @param end
     */
    public void insertSort(int start, int end) {
        for (int i = (start + end) / 2 + 1; i <= end; i++) {
            for (int j = i; j >= start + 1; j--) {
                if (arr[j - 1] > arr[j]) {
                    swap(j - 1, j);
                } else {
                    break;
                }
            }
        }
    }

    /**
     * 分段
     * @param start
     * @param end
     */
    public void merge(int start, int end) {
        if (end <= start) {
            return;
        }
        int mid = (start + end) / 2;
        merge(start, mid);
        merge(mid + 1,end);
        //小于16，直接用快速排序，提升效率
        if (end - start <= 16) {
            insertSort(start, end);
        } else {
            sort(start, end, mid);
        }
    }

    /**
     * 快速排序核心算法
     * @param start
     * @param end
     * @param mid
     */
    public void sort(int start, int end, int mid) {
        Integer[] a = new Integer[end - start + 1];
        int length = a.length;
        for (int i = 0; i < length; i++) {
            a[i] = arr[start + i];
        }
        int j = 0;
        int k = mid - start +1;
        for (int i = start; i <= end; i++) {
            if (j > mid - start) {
                arr[i] = a[k];
                k++;
            }else if (k > length-1) {
                arr[i] = a[j];
                j++;
            }else if (a[j]>a[k]){
                arr[i] = a[k];
                k++;
            }else{
                arr[i] = a[j];
                j++;
            }
        }
    }

    /**
     * 判断排序是否成功
     * @return
     */
    public Boolean success() {
        for (int i = 1; i < getLength(); i++) {
            if (arr[i-1]>arr[i]){
                return false;
            }
        }
        return true;
    }
    
    public static void main(String[] args) {
        Integer N = 1000000;

        for (int i = 0; i < 10; i++) {
            MergeData mergeData = new MergeData(N);
            Long startTime = System.currentTimeMillis();
            mergeData.merge(0,N-1);
            Long endTime = System.currentTimeMillis() - startTime;
            System.out.println("merge优化："+mergeData.success()+"  耗时："+endTime+"ms");
        }

    }
}
输出：
merge优化：true  耗时：235ms
merge优化：true  耗时：246ms
merge优化：true  耗时：257ms
merge优化：true  耗时：233ms
merge优化：true  耗时：227ms
merge优化：true  耗时：191ms
merge优化：true  耗时：201ms
merge优化：true  耗时：210ms
merge优化：true  耗时：238ms
merge优化：true  耗时：217ms


百万数据量，毫秒级。