JAVA中sort()排序解析

前言

我们经常使用java中的sort排序，确实好用，但是其中原理大多数人都是不了解的。

面试中也经常会问到各种排序算法，但是java中用的到底是哪种排序呢？

本文就带你通过源码解析，了解其中的原理，如果只想知道结果，可以直接跳转到第四章-总结。

PS：Collections.sort调用的其实也是Arrays.sort()方法，所以本文只针对Arrays.sort()方法进行解读，且基于JDK1.8进行。

第一章：根据数组长度分类

我们查看源码，可以看到sort最终调用的是DualPivotQuicksort类的sort方法

 /**
     * Sorts the specified range of the array using the given
     * workspace array slice if possible for merging
     *
     * @param a the array to be sorted
     * @param left the index of the first element, inclusive, to be sorted
     * @param right the index of the last element, inclusive, to be sorted
     * @param work a workspace array (slice)
     * @param workBase origin of usable space in work array
     * @param workLen usable size of work array
     */
    static void sort(int[] a, int left, int right,
                     int[] work, int workBase, int workLen) {
     ...
    }

几个参数

a：待排序的数组本身

left:待排序的数组从第几位开始排序。

right:待排序的数组排序截止到第几位。如果对整个数组的话，那left=0，right=a.length-1

正常sort排序中并不会使用下面三个参数，但是大数据量的排序时，可以使用Arrays.paralleSort()方法，这个方法里面会调用sort方法，使用下面的参数。由于本文的重点是sort方法，所以姑且认为下面三个参数都为null或者0，不参与运算。

work:

workBase:

workLen:

第二章：数组数量大于等于286时。

sort排序方法的第一行我们就可以看到下面这个判断条件，

    // Use Quicksort on small arrays
        if (right - left < QUICKSORT_THRESHOLD) {
            sort(a, left, right, true);
            return;
        }

1.数组长度小于286时，使用另外一种排序逻辑，具体第三章会介绍。本章先只看大于等于286时的情况。

首先会对数组进行一遍遍历，统计升序，逆序，以及相等的数量。

2.相邻的逆序的数量大于等于67，或者相邻的相等的数量大于等于33，则也会触发第三章的逻辑。

3.如果上述两个条件都没有触发，则判断相邻非顺序数量是否等于1，如果等于1说明是已经排好序了，就不用进行下面的排序了。

这里为什么是1呢？那是因为count一定会被执行一次，所以count至少为1。

4.如果上面的逻辑都没有触发，则会进入到归并排序的逻辑。

/*
         * Index run[i] is the start of i-th run
         * (ascending or descending sequence).
         */
        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) {
            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;
                    }
                }
            }

            /*
             * The array is not highly structured,
             * use Quicksort instead of merge sort.
             */
            if (++count == MAX_RUN_COUNT) {
                sort(a, left, right, true);
                return;
            }
        }

        // Check special cases
        // Implementation note: variable "right" is increased by 1.
        if (run[count] == right++) { // The last run contains one element
            run[++count] = right;
        } else if (count == 1) { // The array is already sorted
            return;
        }

        ...

        // 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;
        }

第三章：数组数量小于47时

sort(int[] a, int left, int right, boolean leftmost) 方法中，会在此对排序的长度进行判断，如果小于47时，代码如下，会进行如下的逻辑。

if (length < INSERTION_SORT_THRESHOLD) {
            if (leftmost) {
                /*
                 * Traditional (without sentinel) insertion sort,
                 * optimized for server VM, is used in case of
                 * the leftmost part.
                 */
                for (int i = left, j = i; i < right; j = ++i) {
                    int ai = a[i + 1];
                    while (ai < a[j]) {
                        a[j + 1] = a[j];
                        if (j-- == left) {
                            break;
                        }
                    }
                    a[j + 1] = ai;
                }
            } else {
                /*
                 * Skip the longest ascending sequence.
                 */
                do {
                    if (left >= right) {
                        return;
                    }
                } while (a[++left] >= a[left - 1]);

                /*
                 * Every element from adjoining part plays the role
                 * of sentinel, therefore this allows us to avoid the
                 * left range check on each iteration. Moreover, we use
                 * the more optimized algorithm, so called pair insertion
                 * sort, which is faster (in the context of Quicksort)
                 * than traditional implementation of insertion sort.
                 */
                for (int k = left; ++left <= right; k = ++left) {
                    int 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;
                }
                int last = a[right];

                while (last < a[--right]) {
                    a[right + 1] = a[right];
                }
                a[right + 1] = last;
            }
            return;
        }

这里我们会发现一个参数leftmost，leftmost代表的意思是，数组中的树，是否都大于最左侧的那个数字。false的时候代表数组中的数字都大于等于最左侧的，true的时候代表不是。这个参数主要是为了快速排序而准备的。只有快速排序的时候，才会有leftmost=false的场景。

1.如果leftmost=true，从第二章进入到此的逻辑，leftmost都为true，这时候，直接进行插入排序。

2.如果leftmost=false，说明数组中最左侧的数是数组选择范围中最小的。这时候采用插入排序的优化版去排序。PS：毕竟第一数最小不需要排序了嘛。

为什么数量小于47时使用插入排序呢？原因是CPU的运算速度是很快的，小于47时，运算数量并不会很大，所以这时候O(nlogn)复杂度的优势并不明显，插入排序不需要归并排序那样额外的空间，也不需要双轴快排那样去计算标杆位。因此反而会更有优势。

第四章：数组数量大于等于47时

这时候使用的是双轴快速排序优化版。

请注意，这里的用词是双轴快排，而不是快速排序。双轴快排相对于快速排序，多了一条比较轴，交换的次数更多，但是访问的次数会下降。

当然，JDK用的并不完完全全是双轴快排，而是基于双轴快排，先排序依次，把数组分成三段，然后基于这三段各自选择其适合的排序方式去进行排序。

如何选择适合的方式？分成三小段后，重新走sort排序方法。

第四章：总结

所以，java中的sort方法并不是选择了某一种排序算法，而是一种综合体，根据待排序的数组的长度，以及数组中正序和逆序的数量来决定使用什么样的排序。

总结一下就是下面这三条。

1.数组数量大于等于286，并且数组中相邻的逆序数量小于67，并且相邻的相等数量小于33，使用归并排序。否则进入条件2；

2.数组数量小于47，使用插入排序。否则进入条件3；

3.使用双轴快排。