源码解析Java数组如何选择排序的算法

杨利霞

源码解析Java数组如何选择排序的算法
3 l% q7 e3 F4 Z- G* ^+ Q" Y
1 缘起
源于对排序算法的学习，
, `# u4 h, C7 }8 T算法的学习，绕不过理论学习，同时，学者会自己实现算法，以加深理解，
  e$ j9 D+ G* J4 x- d5 r: h" d1 ?这是一个阶段，我们所学习的知识，最终是要应用的，
比如，学习了各种排序算法后，大部分学者，要么应对考试，要么应对面试，
6 l- h* l- s# e2 \: h" g+ G. K在实际的工作中，可能用不到自己实现的算法，或者很少用到，
为什么？
% f" l, v& a9 A# H9 n因为，我们的科学巨人，已经将其工程化，久经考验，成为工业级应用工具了，
所以，我们需要进一步看看科学巨匠们是如何应用这些算法的，
5 x# J1 s  s' T& _  }6 [1 \这不，从Java的数组排序开始，学习前人的优秀实践，
# ?. ?8 E$ [$ d! ?2 `) C2 j帮助读者，进一步了解不同的排序算法在软件工业中的应用，提高设计和应对知识考核及交流的能力。
7 s3 Q3 a4 V7 F# S
4 ?9 F1 Q+ l6 b  w0 ?- B# Q2 前置知识
5 W; _3 \7 P8 Z1 z首先，需要了解时间复杂度、排序算法以及对应的时间复杂度。
其次，分析Java源码中的排序算法，了解不同情况下的排序算法选择。
1 f; B$ o1 \$ d/ n8 ~/ L; P8 z! z6 x最后，为自己设计排序算法或者测试时提供参考。

2.1 时间复杂度
# \" r5 K$ ~' O9 R! Q- s5 r时间复杂度用于度量某个程序随输入数据量级的变化运行所消耗时间的变化趋势。
不同时间复杂度的定量趋势（平均时间复杂度），
  c1 m4 y. x  g时间复杂度函数图像如下图所示，
3 H' P3 F8 I; A$ g* R" _' _4 f: q这里横轴表示输入的数据量（如个数），纵轴没有单位（不过，可以使毫秒，秒等），
不同的时间复杂度曲线间对比，纵轴可以不设单位，
* Z6 h+ j2 K: [8 Y2 X* \" u只做趋势分析。
% T7 u  I5 p: S& D由图可知，在数据量不是很多的情况下，
平均时间负载趋势差别不大，
/ d# }9 V9 y* H) p但是，数据量增长到一定数量级后，差距尽现，
大家在使用过程中用，可以实际测试一下。


2.2 排序算法的时间复杂度
序号        排序算法        平均时间复杂度        稳定性
0 w# ^5 M3 Y4 J6 \) A) z1        冒泡排序       
O ( n 2 ) O(n^2)
O(n
5 {: p/ n4 Y. L/ u0 G2
! c! K1 H+ ~4 U, u )
! W0 W. p% l" `# w* w稳定
2        快速排序       
O ( n l o g n ) O(nlogn)
1 M' ]. `6 d& y4 I1 b  C+ dO(nlogn)
不稳定
3        直接插入排序       
O ( n 2 ) O(n^2)
" ?6 E- B! c+ GO(n
2
3 r; V8 S6 X0 Q& K1 a )
- `+ `# |& X/ \! b$ c6 ]稳定
3 p8 U( v  _) j$ c' Q% i9 z+ N/ r4        希尔排序       
O ( n 1.3 ) O(n^{1.3})
O(n
1.3
)
/ p7 E7 @' l- I. T不稳定
& l; v% u. o# P% T5        选择排序       
% Y2 a' J; h  TO ( n 2 ) O(n^2)
O(n
6 S8 {" T9 D1 j2
+ h+ u9 \: a, e5 x( M0 b6 D )
不稳定
6        堆排序       
O ( n l o g n ) O(nlogn)
O(nlogn)
% X: m1 j' {8 S7 J不稳定
( J$ N7 C. Y/ Q1 A- `7        快速排序       
+ M$ b9 j+ Y5 Z9 zO ( n l o g n ) O(nlogn)
O(nlogn)
不稳定
# D6 S# U# r! f, P+ \8        归并排序       
O ( n l o g n ) O(nlogn)
/ x) p0 |' c6 \- dO(nlogn)
稳定
( D6 j# k" y  T& W- l9        计数排序       
- ?) b+ s9 z7 E) {9 w5 {1 yO ( n + k ) O(n+k)
O(n+k)
稳定
10        桶排序       
& r+ \" b* b. ~& Q) g, i# aO ( n + k ) O(n+k)
1 N6 a5 x1 K" B/ d1 uO(n+k)
) ]/ Q) H) t8 b4 n8 |( J稳定
6 m$ r1 ~* z7 v/ n8 b5 b( f& X8 b11        基数排序       
O ( n ∗ k ) O(n*k)
! b. L$ q+ k. ?% [' Q! RO(n∗k)
  |2 X; C: q7 r  C/ ]. F& |# V6 f稳定
, b! U! m5 P% X9 H3 数组排序
) Q0 j+ F& H% lJava源码中的数组排序分两大类：
0 v  m# q2 i2 j5 d& G$ |% \（1）基础数据类型数组排序；
, s1 i$ v$ r" C( Z6 `  J7 y（2）包装数据类型数组排序；
这两类数组排序方法，
都依据排序的数量量级选择不同的排序算法，
以达到较优的计算性能。
1 \7 F; V# v" Z! F0 @, e' P2 j注意：这里仅分析不同情况使用的排序算法，并没有深究是如何实现的，我打算在后续的文章中一一分析。

8 S% F$ ^" {5 H( u! m1 @3.1 基础数据类型数组排序
基础数据类型数组排序算法：
依据不同的数据量选择结果如下表所示，从源码中提炼而来，
6 Q; V" N( `  L" u5 z. m  t* z通过上面的基础知识可知，数据量较少时采用插入排序，平均时间复杂度为O ( n 2 ) O(n^2)O(n
2
  l! Z% v$ v+ E- |1 m8 z& _ )，数据量较多时采用双端快速排序，平均时间复杂度为O ( n l o g n ) O(nlogn)O(nlogn)，但是不稳定，当数据量再多时，采用稳定的归并排序，平均时间复杂度为O ( n l o g n ) O(nlogn)O(nlogn)，至于，阈值，是设计者按照实践得出的较优方案。
4 Z0 l+ {% j$ K
序号        数据量        排序算法
1        [2, 47)        插入排序
2        [47, 286)        双端快速排序
3        [286, 无穷)        归并排序
) q" g( f0 u  s4 K接下来，看看Java的数组排序源码，
首先进入数组排序入口：sort，
位置：java.util.Arrays#sort(int[])
源码如下图所示，
9 B& W) u% ?) l1 ?. Z0 q由源码可知，入口方法调用双轴快速类的排序算法：DualPivotQuickSort.sort，
通过名称可知，该方法使用快速排序，
但是，进入该方法后，可知，不单单使用快速排序，且看下面的介绍。


好了。进入DualPivotQuickSort类的sort方法，
位置：java.util.DualPivotQuicksort#sort(int[], int, int, int[], int, int)
由源码可知，当排序的数据量小于286时，
使用快速排序：sort，但是，这里同样嵌入了其他排序算法，
数据量大于286时使用 归并排序。
先进入这里的快速排序看看。


下面进入满足286以内数据的快速排序算法：sort，
2 q+ X, r' B: d; D. d1 V8 m- f8 O位置：java.util.DualPivotQuicksort#sort(int[], int, int, boolean)
0 m# _. W) Y" X: H+ ~2 l. V% J源码如下图所示，
由源码可知，这里的快速排序方法同样分分了两层，
当数据量小于47条时，使用插入排序，
大于等于47，小于286时，采用双轴快速排序。



3.2 包装类型数组排序
  F8 l  Z/ H* J% Z# O) t和上一节一样，先上结论，如下表所示，
新排序算法：

0 O! k( Q$ ^8 ]8 D序号        数据量        排序算法
) s+ |% L0 X" V8 S: q0 K1        [2, 32)        二分法插入排序
2        [32, 286)        归并排序
旧排序算法：

序号        数据量        排序算法
2 g* ^1 o9 B# ?/ ]! E1        [2, 7)        插入排序
2        [7, …)        归并排序
包装类型数组排序使用的排序方法入口与基础数据类型数组使用不同的方法，
+ S/ V: D0 S5 {位置：java.util.Arrays#sort(java.lang.Object[])
% n. r& M: ~; K) E( g: i( U源码如下图图示，
由源码可知，这里有两个分支，
一个是旧的归并排序，
一个是新的归并排序，默认情况使用ComparableTimSort.sort，类ComparableTimSort复刻TimSort排序思路，
/ P0 D1 {& M. Y# ?1 Y接下来进入该排序方法一探。
0 i& [) u1 G; X7 e

/ n( u9 p7 l3 G& A$ W3.2.1 新版归并排序
位置：java.util.ComparableTimSort#sort
源码如下图所示，
由源码可知，
当排序数据量不足两个时，不排序，直接返回，
排序数据量32个以内时，使用二分插入排序，平均时间复杂度O ( n 2 ) O(n^2)O(n
2
)，稳定，
排序数据量大于等于32时，使用归并排序，平均时间复杂度O ( n l o g n ) O(nlogn)O(nlogn)，稳定。

4 `# t& Z, d, N2 [- H9 J: h, a* x
! l/ @$ B7 ]2 z0 u3.2.2 旧版归并排序
4 d1 D# K* J' k! j" z讲完新版排序后，顺便讲一下旧版的归并排序吧。
由名称可知，这是归并排序，
: ?  u( R1 |4 I/ Q1 ?4 I6 X. M可是，按照聪明的设计者思考，
, _& V7 t0 m$ E$ \肯定嵌入了其他的逻辑，先上结果：
' G. O; |/ u" z2 F
序号        数据量        排序算法
/ [6 t8 }7 B5 _7 ~) f1        [2, 7)        插入排序
2        [7, …)        归并排序
" @$ g$ m" u, x, j插入排序，
位置：java.util.Arrays#mergeSort(java.lang.Object[], java.lang.Object[], int, int, int)
源码如下图所示，
由源码可知，
排序数据量不足7条使用插入排序算法，平均时间复杂度O ( n 2 ) O(n^2)O(n
( \8 `/ C2 e, m0 @2
( O8 E9 c5 u, }$ @& h3 U )，稳定。
其他情况使用归并排序，平均时间复杂度O ( n l o g n ) O(nlogn)O(nlogn)，稳定。
( Y4 [) F/ ^9 E$ s7 e; F- H

归并排序源码片段如下图所示。
1 o' T  a+ D% \7 R: _
% H" U3 @4 I5 U! V
3.3 设计参考的论文
TimSort论文：https://dl.acm.org/doi/pdf/10.5555/313559.313859

0 ^# \. K: d& @  v4 小结
: n& u3 [0 O3 e8 _1 h  J3 }$ {7 W% x5 U4.1 基础数据数组排序算法
  @0 e" Q/ C! t6 T9 H" F8 J$ p序号        数据量        排序算法
1        [2, 47)        插入排序
4 f: l8 o0 V* l7 H2        [47, 286)        双端快速排序
3 u) ?5 ~/ f4 p$ z# \/ u! b! B4 _3        [286, 无穷)        归并排序
4.2 包装类型数组排序算法
新排序算法：

# m0 A% L6 j- d" u: k" i4 z序号        数据量        排序算法
  I$ m; m6 ?& F! o1        [2, 32)        二分法插入排序
2        [32, 286)        归并排序
旧排序算法：
8 `9 ^0 r6 a+ r5 G: H2 d8 t
序号        数据量        排序算法
2 M- ^' l, h* j9 ?6 G7 X1        [2, 7)        插入排序
+ W2 J+ B, Q! y5 h& \) K' @# b2        [7, …)        归并排序
3 {4 E* ~- y9 g- h' \9 ~————————————————
版权声明：本文为CSDN博主「天然玩家」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
" k4 r* K+ d; A& b( `( ?原文链接：https://blog.csdn.net/Xin_101/article/details/126780295