java.util.DualPivotQuickSort的实现

时间 2019-12-07

标签 java.util.dualpivotquicksort java util dualpivotquicksort 实现栏目 Java 繁體版

原文原文链接

DualPivotQuickSort聚集了多种排序算法，称之为DualPivotQuickSort并不合适。不一样的排序算法有不一样的使用场景。看懂此文件，排序算法就算完全搞懂了。
本文只介绍有用的代码片断，DualPivotQuickSort.java能够用这些代码片断拼凑起来。
本文中的排序对数组a的[left,right]闭区间进行排序。java

常量

QUICKSORT_THRESHOLD = 286
小于此值使用快排，大于此值使用归并排序。
INSERTION_SORT_THRESHOLD = 47
小于此值使用插入排序，大于此值使用快速排序。
COUNTING_SORT_THRESHOLD_FOR_BYTE = 29， COUNTING_SORT_THRESHOLD_FOR_SHORT_OR_CHAR = 3200
byte数组排序时，若是元素数量较多，那么使用counting排序，即便用一个包含256个元素的桶进行排序。
short数组排序时，若是元素数量较多，那么使用counting排序，即便用65536的桶进行排序。
NUM_SHORT_VALUES、NUM_BYTE_VALUES、NUM_CHAR_VALUES
分别表示short、byte、char类型的数据的种数，用于counting排序。
MAX_RUN_COUNT = 67
归并排序中run的个数。

常量中除了QUICKSORT_THRESHOLD其他都是用来选择排序算法的，选择排序算法主要考虑元素个数。算法

当元素个数远远大于元素种数，使用counting排序
当元素个数较多且基本有序（递增片断较少），使用归并排序
当元素个数较多且较为无序，使用快速排序
当元素个数较少，使用插入排序

普通的插入排序

for (int i = left, j = i; i < right; j = ++i) {
    long ai = a[i + 1];
    while (ai < a[j]) {
        a[j + 1] = a[j];
        if (j-- == left) {
            break;
        }
    }
    a[j + 1] = ai;
}

改进插入排序：成对插入排序

成对插入排序是对插入排序的改进，每次将两个元素一块儿往前移动。
它须要进行一下预处理：跳过第一个有序片断，这个片断的长度必定大于等于1。
这个预处理的优点在于：能够避免左边的边界检测。在“普通插入排序”部分的代码中，须要进行边界检测。数组

do {
    if (left >= right) {
        return;
    }
} while (a[++left] >= a[left - 1]);

成对插入排序过程当中，left表示第二个元素，k表示第一个元素。app

for (int k = left; ++left <= right; k = ++left) {
    long a1 = a[k], a2 = a[left];

    if (a1 < a2) {//先让这两个待插入的元素排好序
        a2 = a1; a1 = a[left];
    }
    while (a1 < a[--k]) {//先让较大的元素往前走
        a[k + 2] = a[k];
    }
    a[++k + 1] = a1;

    while (a2 < a[--k]) {//再让较小的元素往前走
        a[k + 1] = a[k];
    }
    a[k + 1] = a2;
}
long last = a[right];//由于是成对排序，最后一个元素有可能落单

while (last < a[--right]) {
    a[right + 1] = a[right];
}
a[right + 1] = last;
}

普通的快排：单轴快排

单轴快排就是传统的快速排序，只选择一个pivot把数组分红左右两部分。快排中最重要的就是pivot的选取，它直接决定了排序算法的性能。
通常人写快排时，pivot取第一个元素的取值，或者先随机一个下标，将此下标对应的元素与第一个元素交换做为pivot。
DualPivotQuickSort中的单轴快排pivot的选取方式是这样的：首先从[left,right]区间找到5个点，对这五个点的值进行插入排序；而后选取e3做为pivot执行快排。less

int seventh = (length >> 3) + (length >> 6) + 1;//length的近似七分之一，这种写法太炫酷
int e3 = (left + right) >>> 1; // The midpoint
int e2 = e3 - seventh;
int e1 = e2 - seventh;
int e4 = e3 + seventh;
int e5 = e4 + seventh;

对这五个元素进行插入排序时，直接使用if-else实现插入排序。函数

// Sort these elements using insertion sort
if (a[e2] < a[e1]) { long t = a[e2]; a[e2] = a[e1]; a[e1] = t; }

if (a[e3] < a[e2]) { long t = a[e3]; a[e3] = a[e2]; a[e2] = t;
    if (t < a[e1]) { a[e2] = a[e1]; a[e1] = t; }
}
if (a[e4] < a[e3]) { long t = a[e4]; a[e4] = a[e3]; a[e3] = t;
    if (t < a[e2]) { a[e3] = a[e2]; a[e2] = t;
        if (t < a[e1]) { a[e2] = a[e1]; a[e1] = t; }
    }
}
if (a[e5] < a[e4]) { long t = a[e5]; a[e5] = a[e4]; a[e4] = t;
    if (t < a[e3]) { a[e4] = a[e3]; a[e3] = t;
        if (t < a[e2]) { a[e3] = a[e2]; a[e2] = t;
            if (t < a[e1]) { a[e2] = a[e1]; a[e1] = t; }
        }
    }
}

单轴快排代码：left、right表示待排序的区间，less、great表示左右两个指针，开始时分别等于left和right。这份快排代码就是传统的双指针快排，它有许多种写法。性能

for (int k = less; k <= great; ++k) {
    if (a[k] == pivot) {
        continue;
    }
    long ak = a[k];
    if (ak < pivot) { // Move a[k] to left part
        a[k] = a[less];
        a[less] = ak;
        ++less;
    } else { // a[k] > pivot - Move a[k] to right part
        while (a[great] > pivot) {
            --great;
        }
        if (a[great] < pivot) { // a[great] <= pivot
            a[k] = a[less];
            a[less] = a[great];
            ++less;
        } else { // a[great] == pivot
            /*
                * Even though a[great] equals to pivot, the
                * assignment a[k] = pivot may be incorrect,
                * if a[great] and pivot are floating-point
                * zeros of different signs. Therefore in float
                * and double sorting methods we have to use
                * more accurate assignment a[k] = a[great].
                */
            a[k] = pivot;
        }
        a[great] = ak;
        --great;
    }
}
sort(a, left, less - 1, leftmost);
sort(a, great + 1, right, false);

快速排序中，注意浮点数的相等并不是彻底相等，在写快排时这是一个容易忽略的点。若是直接使用pivot值覆盖某个数字，可能形成排序后的数组中的值发生变化。ui

改进的快排：双轴快排

双轴快排就是使用两个pivot划分数组，把数组分为（负无穷,pivot1）、[pivot1,pivot2]、（pivot2,正无穷）三部分。pivot1和pivot2取a[e2]和a[e4]。spa

//选择两个pivot
int pivot1 = a[e2];
int pivot2 = a[e4];
//把left和right放在e二、e4处，让它们参与排序过程，由于只有[left+1,right-1]区间上的数字才参与排序
a[e2] = a[left];
a[e4] = a[right];
//先贪心地快速移动一波
while (a[++less] < pivot1);
while (a[--great] > pivot2); 
//利用双轴把数组分红三部分，和快排类似
outer:
for (int k = less - 1; ++k <= great; ) {
    int ak = a[k];
    if (ak < pivot1) { // Move a[k] to left part
        a[k] = a[less]; 
        a[less] = ak;
        ++less;
    } else if (ak > pivot2) { // Move a[k] to right part
        while (a[great] > pivot2) {
            if (great-- == k) {
                break outer;
            }
        }
        if (a[great] < pivot1) { // a[great] <= pivot2
            a[k] = a[less];
            a[less] = a[great];
            ++less;
        } else { // pivot1 <= a[great] <= pivot2
            a[k] = a[great];
        } 
        a[great] = ak;
        --great;
    }
}

// 让开头和结尾的pivot1和pivot2回归到中间来
a[left]  = a[less  - 1]; a[less  - 1] = pivot1;
a[right] = a[great + 1]; a[great + 1] = pivot2;

// Sort left and right parts recursively, excluding known pivots
sort(a, left, less - 2, leftmost);
sort(a, great + 2, right, false);
sort(a, less, great, false);

在以上代码中，数组被分红了三个区，对三个区分别递归调用排序。
其中，在排序中间部分sort(a, less, great, false)时，有一个技巧：把[less,great]区间划分红（严格等于pivot1的区间）、（pivot1和pivot2之间的值）、（严格等于pivot2的区间）。指针

//老规矩，快速走一波
while (a[less] == pivot1) ++less;
while (a[great] == pivot2) --great;
//又是一个双轴划分过程
outer:
for (int k = less - 1; ++k <= great; ) {
    int ak = a[k];
    if (ak == pivot1) { // Move a[k] to left part
        a[k] = a[less];
        a[less] = ak;
        ++less;
    } else if (ak == pivot2) { // Move a[k] to right part
        while (a[great] == pivot2) {
            if (great-- == k) {
                break outer;
            }
        }
        if (a[great] == pivot1) { // a[great] < pivot2
            a[k] = a[less]; 
            a[less] = pivot1;
            ++less;
        } else { // pivot1 < a[great] < pivot2
            a[k] = a[great];
        }
        a[great] = ak;
        --great;
    }
}

通过这个处理，就可以使得[less,great]区间尽可能小，而后再对（pivot1，pivot2）之间的数字进行排序。

为何双轴快排比普通快排快？
理论上，分析排序算法的性能主要看元素比较次数。双轴快排不如普通快排比较次数少。
可是，元素比较次数实际上并不能真实反映排序算法的性能。理论跟实际状况不符合的时候，若是实际状况没有错，那么就是理论错了。
据统计在过去的25年里面，CPU的速度平均每一年增加46%, 而内存的带宽每一年只增加37%，那么通过25年的这种不均衡发展，它们之间的差距已经蛮大了。假如这种不均衡持续持续发展，有一天CPU速度再增加也不会让程序变得更快，由于CPU始终在等待内存传输数据，这就是传说中内存墙(Memory Wall)。排序过程的瓶颈在于内存而不在于CPU，这就像木桶理论：木桶的容量是由最短的那块板决定的。25年前Dual-Pivot快排可能真的比经典快排要慢，可是25年以后虽然算法仍是之前的那个算法，可是计算机已经不是之前的计算机了。在如今的计算机里面Dual-Pivot算法更快！

那么既然光比较元素比较次数这种计算排序算法复杂度的方法已经没法客观的反映算法优劣了，那么应该如何来评价一个算法呢？做者提出了一个叫作扫描元素个数的算法。
在这种新的算法里面，咱们把对于数组里面一个元素的访问: array[i] 称为一次扫描。可是对于同一个下标，而且对应的值也不变得话，即便访问屡次咱们也只算一次。并且咱们无论这个访问究竟是读仍是写。

其实这个所谓的扫描元素个数反应的是CPU与内存之间的数据流量的大小。

由于内存比较慢，统计CPU与内存之间的数据流量的大小也就把这个比较慢的内存的因素考虑进去了，所以也就比元素比较次数更能体现算法在当下计算机里面的性能指标。

改进的归并排序：TimSort

把数组划分为若干个递增片断

如下代码把数组划分红若干个递增片断，若是遇到递减片断会尝试翻转数组使之递增。
若是递增片断太多（超过MAX_RUN_COUNT），说明数组太乱了，利用归并排序效果不够好，这时应该使用快速排序。

int[] run = new int[MAX_RUN_COUNT + 1];
int count = 0; run[0] = left;

// Check if the array is nearly sorted
for (int k = left; k < right; run[count] = k) {
    // Equal items in the beginning of the sequence
    while (k < right && a[k] == a[k + 1])
        k++;
    if (k == right) break;  // Sequence finishes with equal items
    if (a[k] < a[k + 1]) { // ascending
        while (++k <= right && a[k - 1] <= a[k]);
    } else if (a[k] > a[k + 1]) { // descending
        while (++k <= right && a[k - 1] >= a[k]);
        // Transform into an ascending sequence
        for (int lo = run[count] - 1, hi = k; ++lo < --hi; ) {
            int t = a[lo]; a[lo] = a[hi]; a[hi] = t;
        }
    }

    // Merge a transformed descending sequence followed by an
    // ascending sequence
    if (run[count] > left && a[run[count]] >= a[run[count] - 1]) {
        count--;
    }

    /*
        * The array is not highly structured,
        * use Quicksort instead of merge sort.
        */
    if (++count == MAX_RUN_COUNT) {
        sort(a, left, right, true);
        return;
    }
}

肯定了递增片断以后，若是发现只有一个递增片断，那么结果已是有序的了，直接返回。

if (count == 0) {
    // A single equal run
    return;
} else if (count == 1 && run[count] > right) {
    // Either a single ascending or a transformed descending run.
    // Always check that a final run is a proper terminator, otherwise
    // we have an unterminated trailing run, to handle downstream.
    return;
}
right++;
if (run[count] < right) {
    // Corner case: the final run is not a terminator. This may happen
    // if a final run is an equals run, or there is a single-element run
    // at the end. Fix up by adding a proper terminator at the end.
    // Note that we terminate with (right + 1), incremented earlier.
    run[++count] = right;
}

非递归方式实现归并排序

归并排序空间复杂度为O(n)，n为元素个数。此函数签名为static void sort(int[] a, int left, int right,int[] work, int workBase, int workLen)，表示对数组a在[left,right]区间上排序，排序过程当中可用的额外空间为work中的[workBase,workBase+workLen]。若是work给定的空间不够用，就会新开辟足够的空间。

// Use or create temporary array b for merging
int[] b;                 // temp array; alternates with a
int ao, bo;              // array offsets from 'left'
int blen = right - left; // space needed for b
if (work == null || workLen < blen || workBase + blen > work.length) {
    work = new int[blen];
    workBase = 0;
}
if (odd == 0) {
    System.arraycopy(a, left, work, workBase, blen);
    b = a;
    bo = 0;
    a = work;
    ao = workBase - left;
} else {
    b = work;
    ao = 0;
    bo = workBase - left;
}

// Merging
for (int last; count > 1; count = last) {
    for (int k = (last = 0) + 2; k <= count; k += 2) {
        int hi = run[k], mi = run[k - 1];
        for (int i = run[k - 2], p = i, q = mi; i < hi; ++i) {
            if (q >= hi || p < mi && a[p + ao] <= a[q + ao]) {
                b[i + bo] = a[p++ + ao];
            } else {
                b[i + bo] = a[q++ + ao];
            }
        }
        run[++last] = hi;
    }
    if ((count & 1) != 0) {
        for (int i = right, lo = run[count - 1]; --i >= lo;
            b[i + bo] = a[i + ao]
        );
        run[++last] = right;
    }
    int[] t = a; a = b; b = t;
    int o = ao; ao = bo; bo = o;
}

统计排序

统计排序适用于元素个数远大于元素种数的状况，适用于Short、Byte、Char等元素种数较少的类型。以下代码以Short为例执行统计排序。

int[] count = new int[NUM_SHORT_VALUES];

for (int i = left - 1; ++i <= right;
    count[a[i] - Short.MIN_VALUE]++
);
for (int i = NUM_SHORT_VALUES, k = right + 1; k > left; ) {
    while (count[--i] == 0);
    short value = (short) (i + Short.MIN_VALUE);
    int s = count[i];

    do {
        a[--k] = value;
    } while (--s > 0);
}

总结

Array.sort()函数很难说使用了哪一种排序算法，由于它用了好几种排序算法。根本缘由在于不一样的排序算法有不一样的使用场景。Array.sort()函数定义了一系列经验得出的常量实现了算法路由，这是值得借鉴的地方。

参考资料

https://baike.baidu.com/item/TimSort/10279720?fr=aladdin
https://www.jianshu.com/p/2c6f79e8ce6e
https://www.jianshu.com/p/2c6f79e8ce6e