List的排序实现原理

List的排序使用Comparator.sort进行排序

public static void main(String[] args) {
    List<Integer> ljh1 = new ArrayList<Integer>();
    List<Integer> ljh2 = new LinkedList<Integer>();
    for(int i=0;i<10;i++){
        ljh1.add((int)(Math.random()*90+10));
        ljh2.add((int)(Math.random()*90+10));
    }

    Collections.sort(ljh1);
    Collections.sort(ljh2);
    System.out.println(ljh1.toString());
    System.out.println(ljh2.toString());
    System.out.println("------------------");
    Collections.shuffle(ljh1);
    Collections.shuffle(ljh2);
    System.out.println(ljh1.toString());
    System.out.println(ljh2.toString());
}

结果：

[16, 18, 18, 19, 24, 38, 58, 58, 77, 92]

[14, 32, 36, 44, 52, 61, 69, 80, 84, 97]
------------------

[18, 24, 38, 19, 16, 92, 18, 58, 77, 58]

[32, 44, 52, 14, 61, 36, 97, 69, 80, 84]

Process finished with exit code 0

看一下排序的源码，这是排序功能的主入口

一、入口

public static <T extends Comparablesuper T>> void sort(List<T> list) {
    list.sort(null);
}

首先搞清> 这乱七八糟的是什么

类型 T 必须是 Comparable 的子类，并且这个接口的类型是 T 或 T 的父类。

二、Collections.sort方法

default void sort(Comparatorsuper 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);
    }
}

下面会执行toArray方法，将这个list转换成数组，之后调用Array的sort方法对数组进行排序，排序完毕后再把数组的值写回该 List对象的list迭代器中。从而在该list对象中看到完成排序的结果。

下面重点分析一下Array.sort方法

三、Array.sort方法

public static <T> void sort(T[] a, Comparatorsuper 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);
    }
}

注意执行到这一步的时候回有两个分支，

首先会判断c是否为空，如果为空，则直接执行sort方法

否则会判断LegacyMergeSort.userRequested的布尔值。这个值为True时执行legacyMergeSort排序算法，否则执行TimSort排序算法。

首先LegacyMergeSort.userRequested是个什么呢？？？我们打开源码看一看

static final class LegacyMergeSort {
    private static final boolean userRequested =
        java.security.AccessController.doPrivileged(
            new sun.security.action.GetBooleanAction(
                "java.util.Arrays.useLegacyMergeSort")).booleanValue();
}

实际上在代码中定义了一个内部类， 这里面有个属性是userResuest ，这个属性的值是一个security包中的doPrivileged方法产生的，这个方法是一个native方法，其实就是根据系统的属性来选择 旧的合并排序实现 还是 新的tim排序实现

下面我们对sort方法、legacyMergeSort()方法和TimSort.sort()方法进行源码层面的探究

3.1 sort方法

public static void sort(Object[] a) {
    if (LegacyMergeSort.userRequested)
        legacyMergeSort(a);
    else
        ComparableTimSort.sort(a, 0, a.length, null, 0, 0);
}

这个sort跟上面的区别就是调用两种排序的参数不同，实际上是调用这两种排序的重载方法

3.2 legacyMergeSort(Object[] a) 

private static void legacyMergeSort(Object[] a) {
    Object[] aux = a.clone();
    mergeSort(aux, a, 0, a.length, 0);
}

aux 是 a的对象拷贝，a其实就是之前的list转好的数组。 mergeSort方法其实就是归并排序算法（）

private static void mergeSort(Object[] src, //拷贝后的数组
                              Object[] dest,//原始数组
                              int low,     // 0
                              int high,    // list的长度
                              int off) {   // 偏移量，如果用户希望对数组的某段进行排序，这个off就是偏移量。
    int length = high - low;

    // Insertion sort on smallest arrays
    if (length < INSERTIONSORT_THRESHOLD) {   // 当长度小于7的时候用插入排序方式
        for (int i=low; i<high; i++)
            for (int j=i; j>low &&
                     ((Comparable) dest[j-1]).compareTo(dest[j])>0; j--)
                swap(dest, j, j-1);
        return;
    }

    // Recursively sort halves of dest into src  //当长度大于等于7的时候
    int destLow  = low;
    int destHigh = high;
    low  += off;    //off = 0 ;low = 0
    high += off;    //off = 0 ;high = list的长度
    int mid = (low + high) >>> 1;   //list的长度的二进制数右移一位，如果是8则为4 如果是7则为3.相当于将数组进行分段，分成两段
    mergeSort(dest, src, low, mid, -off);    //对前半段进行排序，如果前半段小于7则插入排序，否则继续拆分成两段
    mergeSort(dest, src, mid, high, -off);   //对后半段进行排序，剩下的同上
    // 如果列表已经排序，只需从SRC复制到DEST。这是一个优化，导致更快的排序几乎有序的列表。
    // If list is already sorted, just copy from src to dest.  This is an
    // optimization that results in faster sorts for nearly ordered lists
    if (((Comparable)src[mid-1]).compareTo(src[mid]) <= 0) { //将前一段和后一段的结果合并 返回一个完整的数组
        System.arraycopy(src, low, dest, destLow, length);
        return;
    }
    // 将src的结果写入dest，也就是将原始数组的值覆盖为排序后的值 
    // Merge sorted halves (now in src) into dest
    for(int i = destLow, p = low, q = mid; i < destHigh; i++) { //指针在数组的起始位置
        if (q >= high || p < mid && ((Comparable)src[p]).compareTo(src[q])<=0) //mid比high大或等于 或 low小于mid并且 low的数小于mid
            dest[i] = src[p++]; //如果src的最小值小于src的分段的mid值，那么就把dest的值从头开始替换成src的排序后的值
        else
            dest[i] = src[q++]; //如果src的最小值小于src的分段的mid值，那么就把dest的值从头开始替换成src的排序后的值
    }
}

最后一段程序其实就是将两段值用循环进行一个合并

例如 5 7 6 9 2 8 7 5 6 0  这个list。

首先分段：  5 7 6 9 2   |   8 7 5 6 0 

其次分别排序： 2 5 6 7 9 | 0 5 6 7 8 

再其次判断每个分段是否小于7 小于的话 执行最后的循环

if (q >= high || p < mid && ((Comparable)src[p]).compareTo(src[q])<=0)

这步将返回true 于是将0放在第一位。

一次类推进行排序后的数据重组。

这就是归并排序算法

3.3 ComparableTimSort.sort(a, 0, a.length, null, 0, 0);

TimSort算法是一种起源于归并排序和插入排序的混合排序算法，设计初衷是为了在真实世界中的各种数据中可以有较好的性能。

static void sort(Object[] a, int lo, int hi, Object[] work, int workBase, int workLen) {
    assert a != null && lo >= 0 && lo <= hi && hi <= a.length; // 增加一个断言

    int nRemaining  = hi - lo;  //定义一个待排序的数组长度
    if (nRemaining < 2) //每个Remaining必须有两个及以上元素
        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) {   //如果数组小于32,执行binarySort(二叉排序算法)
        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, work, workBase, workLen);
    int minRun = minRunLength(nRemaining);  // 选取minRun大小,数组长度/2，之后待排序数组将被分成以minRun大小为区块的一块块子数组
    do {
        // Identify next run
        int runLen = countRunAndMakeAscending(a, lo, hi); //找到一个已经是升序的数组，如果是降序则会进行翻转，并返回这个数组的偏移量

        // If run is short, extend to min(minRun, nRemaining)
        if (runLen < minRun) { //如果切分后的数组长度小于32 则执行二叉树排序
            int force = nRemaining <= minRun ? nRemaining : minRun; //偏移量
            binarySort(a, lo, lo + force, lo + runLen);
            runLen = force;
        }
        //对当前的各区块进行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
        // 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;
}

 TimSort 算法为了减少对升序部分的回溯和对降序部分的性能倒退，将输入按其升序和降序特点进行了分区。排序的输入的单位不是一个个单独的数字，而是一个个的块-分区。其中每一个分区叫一个run。针对这些 run 序列，每次拿一个 run 出来按规则进行合并。每次合并会将两个 run合并成一个 run。合并的结果保存到栈中。合并直到消耗掉所有的 run，这时将栈上剩余的 run合并到只剩一个 run 为止。这时这个仅剩的 run 便是排好序的结果。

在这里分享一篇专门讲这个排序的例子：

出处：https://blog.csdn.net/bruce_6/article/details/38299199

示例

*注意*：为了演示方便，我将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

=> 
结束