TimSort算法是一种起源于归并排序和插入排序的混合排序算法,设计初衷是为了在真实世界中的各种数据中可以有较好的性能。该算法最初是由Tim Peters于2002年在Python语言中提出的。
TimSort 是一个归并排序做了大量优化的版本。对归并排序排在已经反向排好序的输入时表现O(n2)的特点做了特别优化。对已经正向排好序的输入减少回溯。对两种情况混合(一会升序,一会降序)的输入处理比较好。
在jdk1.7之后,Arrays类中的sort方法有一个分支判断,当LegacyMergeSort.userRequested为true的情况下,采用legacyMergeSort,否则采用ComparableTimSort。并且在legacyMergeSort的注释上标明了该方法会在以后的jdk版本中废弃,因此以后Arrays类中的sort方法将采用ComparableTimSort类中的sort方法。
<span style="font-family:Microsoft YaHei;">public static void sort(Object[] a, int fromIndex, int toIndex) { if (LegacyMergeSort.userRequested) legacyMergeSort(a, fromIndex, toIndex); else ComparableTimSort.sort(a, fromIndex, toIndex); } </span>下面是ComparableTimSort的sort方法
<span style="font-family:Microsoft YaHei;">static void sort(Object[] a) { sort(a, 0, a.length); } static void sort(Object[] a, int lo, int hi) { rangeCheck(a.length, lo, hi); int nRemaining = hi - lo; if (nRemaining < 2) return; // Arrays of size 0 and 1 are always sorted // If array is small, do a "mini-TimSort" with no merges if (nRemaining < MIN_MERGE) { int initRunLen = countRunAndMakeAscending(a, lo, hi); binarySort(a, lo, hi, lo + initRunLen); return; } /** * March over the array once, left to right, finding natural runs, * extending short natural runs to minRun elements, and merging runs * to maintain stack invariant. */ ComparableTimSort ts = new ComparableTimSort(a); int minRun = minRunLength(nRemaining); do { // Identify next run int runLen = countRunAndMakeAscending(a, lo, hi); // If run is short, extend to min(minRun, nRemaining) if (runLen < minRun) { int force = nRemaining <= minRun ? nRemaining : minRun; binarySort(a, lo, lo + force, lo + runLen); runLen = force; } // Push run onto pending-run stack, and maybe merge ts.pushRun(lo, runLen); ts.mergeCollapse(); // Advance to find next run lo += runLen; nRemaining -= runLen; } while (nRemaining != 0); // Merge all remaining runs to complete sort assert lo == hi; ts.mergeForceCollapse(); assert ts.stackSize == 1; }</span>(1)传入的待排序数组若小于阈值MIN_MERGE(Java实现中为32,Python实现中为64),则调用
binarySort
,这是一个不包含合并操作的 mini-TimSort
。
a) 从数组开始处找到一组连接升序或严格降序(找到后翻转)的数
b) Binary Sort:使用二分查找的方法将后续的数插入之前的已排序数组,binarySort
对数组a[lo:hi]
进行排序,并且a[lo:start]
是已经排好序的。算法的思路是对a[start:hi]
中的元素,每次使用binarySearch
为它在a[lo:start]
中找到相应位置,并插入。
(2)开始真正的TimSort过程:
(2.1) 选取minRun大小,之后待排序数组将被分成以minRun大小为区块的一块块子数组
a) 如果数组大小为2的N次幂,则返回16(MIN_MERGE / 2)
b) 其他情况下,逐位向右位移(即除以2),直到找到介于16和32间的一个数
<span style="font-family:Microsoft YaHei;">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; }</span>这个函数根据 n 计算出对应的
natural run
的最小长度。MIN_MERGE
默认为32
,如果n小于此值,那么返回n
本身。否则会将 n
不断地右移,直到少于 MIN_MERGE
,同时记录一个 r
值,r 代表最后一次移位n时,n最低位是0还是1。 最后返回 n + r
,这也意味着只保留最高的 5 位,再加上第六位。
(2.2)do-while
(2.2.1)找到初始的一组升序数列,countRunAndMakeAscending
会找到一个run
,这个run
必须是已经排序的,并且函数会保证它为升序,也就是说,如果找到的是一个降序的,会对其进行翻转。
(2.2.2)若这组区块大小小于minRun,则将后续的数补足,利用binarySort
对 run
进行扩展,并且扩展后,run
仍然是有序的。
(2.2.3)当前的 run
位于 a[lo:runLen]
,将其入栈ts.pushRun(lo, runLen);//为后续merge各区块作准备:记录当前已排序的各区块的大小
(2.2.4)对当前的各区块进行merge,merge会满足以下原则(假设X,Y,Z为相邻的三个区块):
a) 只对相邻的区块merge
b) 若当前区块数仅为2,If X<=Y,将X和Y merge
b) 若当前区块数>=3,If X<=Y+Z,将X和Y merge,直到同时满足X>Y+Z和Y>Z
由于要合并的两个
run
是已经排序的,所以合并的时候,有会特别的技巧。假设两个run
是run1,run2
,先用gallopRight
在run1
里使用binarySearch
查找run2 首元素
的位置k
, 那么run1
中k
前面的元素就是合并后最小的那些元素。然后,在run2
中查找run1 尾元素
的位置len2
,那么run2
中len2
后面的那些元素就是合并后最大的那些元素。最后,根据len1
与len2
大小,调用mergeLo
或者mergeHi
将剩余元素合并。
(2.2.5) 重复2.2.1 ~ 2.2.4,直到将待排序数组排序完
(2.2.6) Final Merge:如果此时还有区块未merge,则合并它们
(3)示例
*注意*:为了演示方便,我将TimSort中的minRun直接设置为2,否则我不能用很小的数组演示。。。同时把MIN_MERGE也改成2(默认为32),这样避免直接进入binary sort。
初始数组为[7,5,1,2,6,8,10,12,4,3,9,11,13,15,16,14]
=> 寻找连续的降序或升序序列 (2.2.1),同时countRunAndMakeAscending
函数会保证它为升序
[1,5,7] [2,6,8,10,12,4,3,9,11,13,15,16,14]
=> 入栈 (2.2.3)
当前的栈区块为[3]
=> 进入merge循环 (2.2.4)
do not merge因为栈大小仅为1
=> 寻找连续的降序或升序序列 (2.2.1)
[1,5,7] [2,6,8,10,12] [4,3,9,11,13,15,16,14]
=> 入栈 (2.2.3)
当前的栈区块为[3, 5]
=> 进入merge循环 (2.2.4)
merge因为runLen[0]<=runLen[1]
1) gallopRight:寻找run1的第一个元素应当插入run0中哪个位置(”2”应当插入”1”之后),然后就可以忽略之前run0的元素(都比run1的第一个元素小)
2) gallopLeft:寻找run0的最后一个元素应当插入run1中哪个位置(”7”应当插入”8”之前),然后就可以忽略之后run1的元素(都比run0的最后一个元素大)
这样需要排序的元素就仅剩下[5,7] [2,6],然后进行mergeLow
完成之后的结果:
[1,2,5,6,7,8,10,12] [4,3,9,11,13,15,16,14]
=> 入栈 (2.2.3)
当前的栈区块为[8]
退出当前merge循环因为栈中的区块仅为1
=> 寻找连续的降序或升序序列 (2.2.1)
[1,2,5,6,7,8,10,12] [3,4] [9,11,13,15,16,14]
=> 入栈 (2.2.3)
当前的栈区块大小为[8,2]
=> 进入merge循环 (2.2.4)
do not merge因为runLen[0]>runLen[1]
=> 寻找连续的降序或升序序列 (2.2.1)
[1,2,5,6,7,8,10,12] [3,4] [9,11,13,15,16] [14]
=> 入栈 (2.2.3)
当前的栈区块为[8,2,5]
=>
do not merege run1与run2因为不满足runLen[0]<=runLen[1]+runLen[2]
merge run2与run3因为runLen[1]<=runLen[2]
1) gallopRight:发现run1和run2就已经排好序
完成之后的结果:
[1,2,5,6,7,8,10,12] [3,4,9,11,13,15,16] [14]
=> 入栈 (2.2.3)
当前入栈的区块大小为[8,7]
退出merge循环因为runLen[0]>runLen[1]
=> 寻找连续的降序或升序序列 (2.2.1)
最后只剩下[14]这个元素:[1,2,5,6,7,8,10,12] [3,4,9,11,13,15,16] [14]
=> 入栈 (2.2.3)
当前入栈的区块大小为[8,7,1]
=> 进入merge循环 (2.2.4)
merge因为runLen[0]<=runLen[1]+runLen[2]
因为runLen[0]>runLen[2],所以将run1和run2先合并。(否则将run0和run1先合并)
1) gallopRight & 2) gallopLeft
这样需要排序的元素剩下[13,15] [14],然后进行mergeHigh
完成之后的结果:
[1,2,5,6,7,8,10,12] [3,4,9,11,13,14,15,16] 当前入栈的区块为[8,8]
=>
继续merge因为runLen[0]<=runLen[1]
1) gallopRight & 2) gallopLeft
需要排序的元素剩下[5,6,7,8,10,12] [3,4,9,11],然后进行mergeHigh
完成之后的结果:
[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16] 当前入栈的区块大小为[16]
=>
不需要final merge因为当前栈大小为1
=>
结束
参考:
http://www.lifebackup.cn/timsort-java7.html
http://blog.csdn.net/on_1y/article/details/30109975
http://en.wikipedia.org/wiki/Timsort