java.util.DualPivotQuickSort的实现

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

常量

• 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表示第一个元素。

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执行快排。

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值覆盖某个数字，可能造成排序后的数组中的值发生变化。

改进的快排：双轴快排

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

//选择两个pivot
int pivot1 = a[e2];
int pivot2 = a[e4];
//把left和right放在e2、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