共计 10081 个字符，预计需要花费 26 分钟才能阅读完成。
作者：京东物流 秦彪
1. 引言
排序是一个 Java 开发者，在日常开发过程中随处可见的开发内容，Java 中有丰盛的 API 能够调用应用。在 Java 语言中，作为汇合工具类的排序办法，必然要做到通用、高效、实用这几点特色。应用什么样排序算法会比拟适合，可能做到在尽量升高工夫、空间复杂度的状况下，又要兼顾保障稳定性，达到优良的性能。可能从性能角度登程首先会想到的是疾速排序，或者归并排序。作为 jdk 提供的通用排序功能，应用又如此频繁，必定有独特之处，一起来看学习下期中的神秘。
文中不会过多的介绍几大根本排序算法的形式、由来和思维，次要精力集中在一块探讨 java 中排序办法所应用的算法，以及那些是值得咱们学习和借鉴的内容。文中如有了解和介绍的谬误，一起学习，一起探讨，一起提高。
2. 案例
日常应用最为频繁的排序，莫过于如下代码案例，给定一个现有的序列进行肯定规定下的排序，配合 java8 的 stream 个性，能够很不便的对一个汇合进行排序操作（排序规定只是对排序对象及排序计划的限定，不在本文探讨范畴内）。
List<Integer> list = Arrays.asList(10, 50, 5, 14, 16, 80);
System.out.println(list.stream().sorted().collect(Collectors.toList()));
在代码执行的过程中 SortedOps.java 类中 Arrays.sort(array, 0, offset, comparator); 执行了 Array 汇合类型的 sort 排序算法。
@Override
public void end() {Arrays.sort(array, 0, offset, comparator);
downstream.begin(offset);
if (!cancellationWasRequested) {for (int i = 0; i < offset; i++)
downstream.accept(array[i]);
}
else {for (int i = 0; i < offset && !downstream.cancellationRequested(); i++)
downstream.accept(array[i]);
}
downstream.end();
array = null;
}
如果应用 Collections.sort() 办法如下打印 list1 和 list2 后果一样，且调用的都是 Arrays 汇合类中的 sort 办法。
List<Integer> list1 = Arrays.asList(10, 50, 5, 14, 16, 80);
System.out.println(list1.stream().sorted().collect(Collectors.toList()));
List<Integer> list2 = Lists.newArrayList();
list2.addAll(list1);
Collections.sort(list2);
System.out.println(list2);
// 输入：// [5, 10, 14, 16, 50, 80]
// [5, 10, 14, 16, 50, 80]
2. Collections.sort 办法介绍
Collections 类中对于 sort 办法定义如下：
public static <T extends Comparable<? super T>> void sort(List<T> list) {list.sort(null);
}
通过该办法正文，查看到有三项值得关注的信息，大略意思是该办法实现了稳固且默认升序排序的性能。
1. Sorts the specified list into ascending order, according to the Comparable natural ordering of its elements.
2. This sort is guaranteed to be stable equal elements will not be reordered as a result of the sort.
3. The specified list must be modifiable, but need not be resizable.
进入 sort，代码进入到 List 类的 sort 办法，发现办法将入参 list 先转为了数组 Object[]，之后利用 Arrays.sort 进行排序。
default void sort(Comparator<? super E> c) {Object[] a = this.toArray();
Arrays.sort(a, (Comparator) c);
ListIterator<E> i = this.listIterator();
for (Object e : a) {i.next();
i.set((E) e);
}
}
首先在这里思考一个问题为什么要转为数组，问题答案曾经在办法的英文正文中说明确了。
* The default implementation obtains an array containing all elements in
* this list, sorts the array, and iterates over this list resetting each
* element from the corresponding position in the array. (This avoids the
* n<sup>2</sup> log(n) performance that would result from attempting
* to sort a linked list in place.)
是为了防止间接对 List<T> 的链表进行排序，从而消耗 O(n2logn) 工夫复杂度。当然这里在 this.toArray()时，为了将 list 强行变为数组会损失一些性能和空间开销，源码中应用了 System.arraycopy 调用底层操作系统办法进行数据复制，具体内容能够查看相干实现。持续进入 Arrays 类的 sort 办法定义中，咱们没有应用比拟器，LegacyMergeSort.userRequested 示意进入老的归并排序算法，默认是敞开的，间接进入本文重点关注的 TimSort.sort(…)办法。
public static <T> void sort(T[] a, Comparator<? super T> c) {if (c == null) {sort(a);
} else {if (LegacyMergeSort.userRequested)
legacyMergeSort(a, c);
else
TimSort.sort(a, 0, a.length, c, null, 0, 0);
}
}
3. TimSort 算法介绍
Timsort 是一个 自适应 的、混合 的、稳固 的排序算法，是由 Tim Peter 于 2002 年创造的，最早利用在 Python 中，当初广泛应用于 Python、Java、Android 等语言与平台中，作为根底的排序算法应用。其中 Java 语言的 Collection.sort 在 JDK1.6 应用的是一般的归并排序，归并排序尽管工夫复杂度低，然而空间复杂度要求较高，所以从 JDK1.7 开始就更改为了 TimSort 算法。
Timsort 的工夫复杂度是 O(n log n)，与归并排序的工夫复杂度雷同，那它的劣势是啥呢，实际上能够认为 TimSort 排序算法是归并排序算法的优化版，从它的三个特色就能够看出，第二个特色“混合的”，没错，它不单纯是一种算法，而是交融了归并算法和二分插入排序算法的精华，因而可能在排序性能上体现优异。其它两个特色自适应和稳定性会在文章前面讲到。首先从算法性能统计上做个比照：
能够看出 TimSort 排序算法，均匀和最坏工夫复杂度是 O(nlogn)，最好工夫复杂度是 O(n)，空间复杂度是 O(n)，且稳固的一种排序算法。在稳固算法中，从性能成果上比照来看和二叉排序算法一样。
3.1 TimSort 的核心思想
那 TimSort 算法的核心思想是什么呢，首先原始的 TimSort 对于长度小于 64 的数据（java 中是 32），会间接抉择二分插入排序，效率很高。其次，TimSort 算法的初衷认为事实中的数据总是局部有序的。这句话很要害，怎么了解呢，比方列表[5, 2, 8, 5, 7,23, 45, 63]，外面的[5, 2] 和 [8, 5] 和 [7, 23, 45,63] 各子列表中就是有序的，要么升序要么降序，这就是 TimSort 的根本依据。
基于此会发现待排序列表曾经局部有序了，所以会在排序过程中尽量不要毁坏这种程序，就能够做到缩小排序工夫耗费。根本思维说完了，由此引出 TimSort 算法的几个概念：run 和 minrun。
run 是指间断升序或者间断降序的最长子序列（降序和升序能够互相转换），而 minrun 是一个设定值，实际上是每个 run 的长度最小值。所以 TimSort 会看待排序序列进行划分，找出间断有序的子序列，如果子序列长度不满足这点要求，就将后续数据插入到后面的子序列中。
举个例子，待排序序列[5, 2, 8, 5, 7,23, 45, 63]，如果 minRun = 3，那宰割后的 run 会有以下：[2, 5, 8]、[5,7,23,45,63] 两个子序列，最终通过合并这两个 run 失去[2,5,5,7,8,23,45,63]
是不是有个疑难：minrun 怎么抉择失去的？该值是通过大量的统计计算给出的 minrun 长度倡议是在 32 ~ 64 之间取值效率比拟高，具体在 java 代码中可能会有所不同。
接着来看，假如当初有序子序列曾经拆分好了，须要进入到合并过程中了，TimSort 是如何合并子序列的。对于归并排序咱们都晓得，序列先归后并，两两组合利用一个空数组间接进行比拟就合并了。然而在 TimSort 算法中，合并过程是实时的，每次算出一个 run 就可能做一次合并。这个过程利用了栈构造，且须要遵循相邻的 run 才能够合并，也就是只有相邻的栈元素能够进行合并。
规定如下：假如以后有三个 run 子序列顺次入栈，当初栈顶有三个元素从上至下顺次为 x3、x2、x1，它们的长度只有满足以下两个条件中的任何一个就进行合并：
（1）x1 <= x2 + x3
（2）x1 <= x2
满足这个条件的三个序列，像汉诺塔一样长度由下往上顺次减小。方才提到合并 run 的过程是实时的，也就是每产生一个 run 就进行一次合并操作。举例说明下，以后假如待排序序列[2,6,8,4,2,5,7,9,10,11,4,25,64,32,78,99]，其中再假如 minrun= 3 是正当的。合并过程是这样的，留神这里的压栈和弹栈不肯定须要对子序列自身进行操作，不是真的将子序列放入栈中，而只须要 run 标识以及长度即可，因为栈元素比拟的是 run 长度。
（1）首先第一个 run0 是[2,6,8]，而第二个 run1 是[2,4,5]，此时顺次将其放入栈中，发现满足第二个条件，这两个 run 进行合并，合并后将旧序列从栈中弹出，失去新的 run0 是[2,2,4,5,6,8]，再次压入栈中。
（2）持续从原序列中找到新的 run1 是[7,9,10,11]，压入栈中，此时 run0 和 run1 不满足条件不须要合并。持续从原序列中找到 run2 是[4,25,64]，压入栈中，此时满足第一个条件，这里的 run1 和 run2 须要进行合并，合并后将旧序列从栈中弹出，新 run1 是[4,7,9,10,11,25,64]，压入栈中。
（3）此时发现 run0 和 run1 满足第二个条件，持续合并弹出旧序列，失去新 run0 是[2,2,4,4,5,6,7,8,9,10,11,25,64]，压入栈中。
（4）持续从原序列中找到新的 run1 是[32,78,99]，压入栈中。此时发现没有更多元素，而条件是不满足的，仍然进行一次合并，弹出旧序列，压入合并后的新子序列 run0 是[2,2,4,4,5,6,7,8,9,10,11,25,32,64,78,99]
（5）此时将 run0 拷贝到原序列就实现了排序
为什么要设置这么两个合并 run 的严格条件，间接压栈合并岂不更好？目标是为了防止一个较长的有序片段和一个较小的有序片段进行归并，在合并长度上做到平衡效率才高。
在合并 run 的过程中会用到一种所谓的 gallop(飞奔)模式，可能缩小参加归并的数据长度，次要过程如下：假如有待归并的子序列 x 和 y，如果 x 的前 n 个元素都是比 y 首元素小的，那这 n 个元素实际上就不必参加归并了。起因就是这 n 个元素原本曾经有序了，归并后还是在原来的地位。同理而言，如果 y 的最初几个元素都比 x 最初一个元素小，那 y 的最初这 n 个元素也就不用参加归并操作了，这样就能够缩小归并长度，缩小来回复制多余数据的开销。
3.2 Java 源码
探讨完 TimSort 的核心思想及其排序过程，当初来看下 java 代码是如何实现的。Java1.8 中的 TimSort 类地位在 java.util.TimSort
static <T> void sort(T[] a, int lo, int hi, Comparator<? super T> c,
T[] work, int workBase, int workLen) {
assert c != null && a != null && lo >= 0 && lo <= hi && hi <= a.length;
int nRemaining = hi - lo;
if (nRemaining < 2)
return;
if (nRemaining < MIN_MERGE) {int initRunLen = countRunAndMakeAscending(a, lo, hi, c);
binarySort(a, lo, hi, lo + initRunLen, c);
return;
}
TimSort<T> ts = new TimSort<>(a, c, work, workBase, workLen);
int minRun = minRunLength(nRemaining);
do {int runLen = countRunAndMakeAscending(a, lo, hi, c);
if (runLen < minRun) {
int force = nRemaining <= minRun ? nRemaining : minRun;
binarySort(a, lo, lo + force, lo + runLen, c);
runLen = force;
}
ts.pushRun(lo, runLen);
ts.mergeCollapse();
lo += runLen;
nRemaining -= runLen;
} while (nRemaining != 0);
assert lo == hi;
ts.mergeForceCollapse();
assert ts.stackSize == 1;
}
变量 nRemaining 记录的是待排序列表中残余元素个数，MIN_MERGE 就是前文中提到的 java 中的 minrun 值是 32。如果 nRemaining<32，用 countRunAndMakeAscending(…)办法失去间断升序的最大个数，外面波及到升序降序调整。能够看到如果待排序列表小于 32 长度，就进行二分插入排序 binarySort(…)。
如果待排序列表长度大于 32，调用 TimSort 对象的 minRunLength(nRemaining) 计算 minRun，这里就体现了动静自适应，具体来看代码中是如何做的。r 为取出长度 n 的二进制每次右移的一个溢出位值，n 每次右移 1 位，直到长度 n 小于 32。n+ r 最终后果就是保留长度 n 的二进制的高 5 位再加上 1 个移除位。依据正文能够看出：
- 如果待排序数组长度为 2 的 n 次幂，比方 1024，则 minRun = 32/2 = 16
- 其它状况的时候，逐位右移，直到找到介于 16<=k<=32 的值。
如果待排序列表长度是 7680，二进制是 1111000000000，依照操作后是 11110 十进制是 30，再加上移除位 0 是 30，所以 minRun=30
private static int minRunLength(int n) {
assert n >= 0;
int r = 0; // Becomes 1 if any 1 bits are shifted off
while (n >= MIN_MERGE) {r |= (n & 1);
n >>= 1;
}
return n + r;
}
接下来在循环中进行解决：
（1）计算最小升序的 run 长度，如果小于 minRun，应用二分插入排序将 run 的长度补充到 minRun 要求的长度。
（2）ts.pushRun(lo, runLen)，通过栈记录每个 run 的长度，这里 lo 是 run 的第一个元素的索引用来标记操作的是哪个 run，runLen 是 run 的长度。
private void pushRun(int runBase, int runLen) {this.runBase[stackSize] = runBase;
this.runLen[stackSize] = runLen;
stackSize++;
}
（3）ts.mergeCollapse(); 通过计算后面提到的两个 run 合并的限定条件，别离是：
- runLen[n-1] <= runLen[n] + runLen[n+1]
- runLen[n] <= runLen[n + 1]
private void mergeCollapse() {while (stackSize > 1) {
int n = stackSize - 2;
if (n > 0 && runLen[n-1] <= runLen[n] + runLen[n+1]) {if (runLen[n - 1] < runLen[n + 1])
n--;
mergeAt(n);
} else if (runLen[n] <= runLen[n + 1]) {mergeAt(n);
} else {break; // Invariant is established}
}
}
（4）这里的 mergeAt(n) 归并排序过程，之前有提到是通过优化后所谓 gallop 模式的归并排序，具体表现在办法中的 gallopRight 和 gallopLeft 办法。
int k = gallopRight(a[base2], a, base1, len1, 0, c);
assert k >= 0;
base1 += k;
len1 -= k;
if (len1 == 0)
return;
len2 = gallopLeft(a[base1 + len1 - 1], a, base2, len2, len2 - 1, c);
assert len2 >= 0;
if (len2 == 0)
return;
假如有 X 序列 [4,9,21,23]，Y 序列[5,7,12,13,14,15,17]，因为 X 中 4 小于 Y 序列最小元素 5，所以合并后 4 必然是第一个元素；而 Y 序列中尾元素 17 比 X 中的[21,23] 小，所以 X 中的 [21,23] 必然是合并最初两元素。
4. DivalQuickSort 算法介绍
前文案例中提到 SortedOps.java 类，该类中对于根本类型的排序调用 Arrays.sort(ints); 或 Arrays.sort(longs); 再或 Arrays.sort(doubles); 应用了 DivalQuickSort 排序算法。
public static void sort(int[] a) {DualPivotQuicksort.sort(a, 0, a.length - 1, null, 0, 0);
}
4.1 DivalQuickSort 核心思想
疾速排序应用的是在排序序列中抉择一个数作为分区点 pivot，也就是所谓的轴，而后以此轴将数据分为左右两局部，大于该值的为一个区，小于该值的为一个区，利用分治和递归思维实现。如下假如抉择 19 为 pivot 值。
双轴快排，如其名字所示，就是会选取两个数作为 pivot，这样就会划分出三个区间，理论在执行中会有 4 个区间，别离是小于等于 pivot1 区间；pivot1 和 pivot2 之间区间，待处理区间；大于等于 pivot2 区间。如下假如抉择 10 和 19 为两个 pivot 值。
每次递归迭代时遍历待处理的区域数据，而后比拟它应该放的地位，并进行替换操作，逐步压缩待处理区域的数据长度，解决掉待处理区域的元素数据；执行结束一轮数据后替换 pivot 数值，而后各自区间再进行递归排序即可。
4.2 Java 源码
static void sort(int[] a, int left, int right,
int[] work, int workBase, int workLen) {if (right - left < QUICKSORT_THRESHOLD) {sort(a, left, right, true);
return;
}
int[] run = new int[MAX_RUN_COUNT + 1];
int count = 0; run[0] = left;
for (int k = left; k < right; run[count] = k) {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]);
for (int lo = run[count] - 1, hi = k; ++lo < --hi; ) {int t = a[lo]; a[lo] = a[hi]; a[hi] = t;
}
} else { // equal
for (int m = MAX_RUN_LENGTH; ++k <= right && a[k - 1] == a[k]; ) {if (--m == 0) {sort(a, left, right, true);
return;
}
}
}
if (++count == MAX_RUN_COUNT) {sort(a, left, right, true);
return;
}
}
if (run[count] == right++) {run[++count] = right;
} else if (count == 1) {return;}
byte odd = 0;
for (int n = 1; (n <<= 1) < count; odd ^= 1);
int[] b;
int ao, bo;
int blen = right - left;
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;
}
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;
}
}
通过看代码能够看出，java 中的双轴快排在片段数据长度及肯定条件的状况下，还应用了其它诸如归并、插入等排序算法。
因为 DivalQuickSort 算法实现内容比较复杂，文中重点解说了 TimSort 算法，待笔者钻研透彻后进行补充。
5. 雷同环境排序工夫比照
想要真正模仿截然不同运行环境，是艰难的。这里只是模仿雷同的数据集，在雷同机器上，其实就是平时办公的机器，统计不同排序算法排序过程中消耗的工夫，这里的后果仅供参考。
模仿数据：随机失去 1 亿个范畴在 0 到 100000000 内的整型元素形成数组，别离基于疾速排序、一般归并排序、TimSort 的排序算法失去耗时后果如下，单位 ms。
通过测试验证后果来看，在以后数据集规模下，双轴快排 DivalQuickSort 体现优异。注：Java 中 TimSort 次要使用援用类型的汇合排序中，本次数据验证并未退出比拟。
5. 总结与探讨
因为 Java 提供了很不便的排序 API，所以在平时的需要应用过程中个别都是短短几行代码调用应用残缺排序工作，这也是 Java 作为一门风行语言最根本的职责所在。当然也会导致咱们开发者容易漠视其原理，不可能学习到外面的精华。
文中一起理解学习了 TimSort 算法和 DivalQuickSort 的排序思维与 java 实现。作为根本排序实现被宽泛的利用，必定有其值得学习与借鉴的中央。能够得悉工业用排序算法，通常都不是一种算法，而是依据特定条件下的多种算法混合而成，实际上平时很多应用的经典数据结构都不是一种类型或者一种形式，比方 HashMap 中随着数据量大小有链表与红黑树的转化，再比方 Redis 中的各种数据结构不都是一种实现。这些经典优良的实现都用到了诸如此类的思维。
