Arrays.sort的粗略讲解

排序算法，基本的高级语言都有一些提供。C语言有qsort()函数，C++有sort()函数，java语言有Arrays类(不是Array)。用这些排序时，都可以写自己的排序规则。

　　Java API对Arrays类的说明是：此类包含用来操作数组（比如排序和搜索）的各种方法。

1.对基本数据类型的数组的排序

　　　说明：(1)Arrays类中的sort()使用的是“经过调优的快速排序法”;

　　　　　　(2)比如int[]，double[]，char[]等基数据类型的数组，Arrays类之只是提供了默认的升序排列，没有提供相应的降序排列方法。

　　　　　　(3)要对基础类型的数组进行降序排序，需要将这些数组转化为对应的封装类数组，如Integer[]，Double[]，Character[]等，对这些类数组进行排序。(其实还不如先进行升序排序，自己在转为将序)。

　　  用默认的升序对数组排序

　　 函数原型：static void sort(int[] a)   对指定的 int 型数组按数字升序进行排序。

　　　　　　　static void sort(int[] a, int fromIndex, int toIndex)  对指定 int 型数组的指定范围按数字升序进行排序。　

源代码解释：

/**
     * Sorts the specified array into ascending numerical order.
     *
     * <p>Implementation note: The sorting algorithm is a Dual-Pivot Quicksort
     * by Vladimir Yaroslavskiy, Jon Bentley, and Joshua Bloch. This algorithm
     * offers O(n log(n)) performance on many data sets that cause other
     * quicksorts to degrade to quadratic performance, and is typically
     * faster than traditional (one-pivot) Quicksort implementations.
     *
     * @param a the array to be sorted
     */

第一部分：

首先介绍排序里面会调用的插入排序，什么时候会调用这段代码，在代码的最后面有解释

下面我来具体讲解这段代码，INSERTION_SORT_THRESHOLD是是否采用插入排序的阈值

代码中设置为47，当小于排序长度小于47时，调用下面这块代码

leftmost是boolean类型，如果是true表示是从第一个位置开始往后排序，如果不是，说明是从中间任意位置开始排序

如果leftmost是true的时候，采用最原始的插入排序方法，

如果是false的时候，采用优化的插入排序方法，pair insertion sort,每次对两个数据进行插入，提高了效率

/**
     * Sorts the specified range of the array by Dual-Pivot Quicksort.
     *
     * @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 leftmost indicates if this part is the leftmost in the range
     */

private static void sort(int[] a, int left, int right, boolean leftmost) {
        int length = right - left + 1;

// Use insertion sort on tiny arrays
        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.

* 具体执行过程：上面的do-while循环已经排好的最前面的数据

                *（1）将要插入的数据，第一个值赋值a1,第二个值赋值a2,

                *(2)然后判断a1与a2的大小，使a1要大于a2

                *(3)接下来，首先是插入大的数值a1，将a1与k之前的数字一一比较，直到数值小于a1为止，把a1插入到合适的位置，注意：这里的相隔距离为2

                *(4)接下来，插入小的数值a2,将a2与此时k之前的数字一一比较，直到数值小于a2为止，将a2插入到合适的位置，注意：这里的相隔距离为1

                *(5)最后把最后一个没有遍历到的数据插入到合适位置

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

。。。。。。//这里只截取了长度小于INSERTION_SORT_THRESHOLD的时候，大于的时候比较难，没具体分析

/**下面是INSERTION_SORT_THRESHOLD的解释

* If the length of an array to be sorted is less than this
     * constant, insertion sort is used in preference to Quicksort.
     */

private static final int INSERTION_SORT_THRESHOLD = 47;

}

第二部分：

当要排队列长度小于QUICKSORT_THRESHOLD并且大于INSERTION_SORT_THRESHOLD时，用双基准快速排序方法，

这部分的代码就是上面。。。。没有显示的部分，具体的原理同双基准快速排序

第三部分：

如果要排序的队列长读大于INSERTION_SORT_THRESHOLD，采用合并排序方法

/**
     * If the length of an array to be sorted is less than this
     * constant, Quicksort is used in preference to merge sort.
     */
    private static final int QUICKSORT_THRESHOLD = 286;

import java.util.Arrays;public class ArraysSort_11 {
    public static void main(String args[])
    {
        int[] a={1,4,-1,5,0};
        Arrays.sort(a);
        //数组a[]的内容变为{-1,0,1,4,5}
        for(int i=0;i<a.length;i++)
            System.out.print(a[i]+"  ");
    }
}

2.对复合数据类型的数据的排序

　　函数原型：  (1)public static<T> void sort(T[] a，Comparator c)  根据指定比较器产生的顺序对指定对象数组进行排序。

　　　　　　　　(2)public static<T> void sort(T[] a，int fromIndex，int toIndex，Comparator c)  根据指定比较器产生的顺序对指定对象数组的指定范围进行排序。　

　　说明：这个两个排序算法是“经过调优的合并排序”算法。

源码：

其中的两个API

public static <T> void sort(T[] a, Comparator<? super T> c) {
        if (LegacyMergeSort.userRequested)
            legacyMergeSort(a, c);
        else
            TimSort.sort(a, c);
    }

​public static <T> void sort(T[] a, int fromIndex, int toIndex,
                                Comparator<? super T> c) {
        if (LegacyMergeSort.userRequested)
            legacyMergeSort(a, fromIndex, toIndex, c);
        else
            TimSort.sort(a, fromIndex, toIndex, c);
    }

​

核心代码调用的是相同的代码

如果：LegacyMergeSort.userRequested为真时：

执行下面代码：

这里c可以为null，如果为null，则调用默认的比较器进行比较，否则调用用户指定的比较器进行比较。

下面是改进版的合并排序

执行步骤如下：

（1）如果比较的长度小于INSERTIONSORT_THRESHOLD插入排序的阈值，直接调用传统的插入排序进行比较

（2）当大于插入排序的阈值时，采用合并排序算法，这里有个改进的地方，加亮部分，如果已经排好序的，不再进行比较，而是直接复制过去，提高效率

private static void mergeSort(Object[] src,
                                  Object[] dest,
                                  int low, int high, int off,
                                  Comparator c) {
        int length = high - low;

// Insertion sort on smallest arrays
        if (length < INSERTIONSORT_THRESHOLD) {
            for (int i=low; i<high; i++)
                for (int j=i; j>low && c.compare(dest[j-1], dest[j])>0; j--)
                    swap(dest, j, j-1);
            return;
        }

// Recursively sort halves of dest into src
        int destLow  = low;
        int destHigh = high;
        low  += off;
        high += off;
        int mid = (low + high) >>> 1;
        mergeSort(dest, src, low, mid, -off, c);
        mergeSort(dest, src, mid, high, -off, c);

// 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 (c.compare(src[mid-1], src[mid]) <= 0) {
           System.arraycopy(src, low, dest, destLow, length);
           return;
        }

// Merge sorted halves (now in src) into dest
        for(int i = destLow, p = low, q = mid; i < destHigh; i++) {
            if (q >= high || p < mid && c.compare(src[p], src[q]) <= 0)
                dest[i] = src[p++];
            else
                dest[i] = src[q++];
        }
    }
如果LegacyMergeSort.userRequested为假时，

调用TimSort.sort方法，如果c为null，还是调用上面的方法，

否则调用比较器进行比较

　　代码实例：

package aa;import java.util.Arrays;import java.util.Comparator;public class Arraysort {
    Point[] arr;
    
    Arraysort(){
        arr=new Point[4];    //定义对象数组arr，并分配存储的空间
        for(int i=0;i<4;i++)
            arr[i]=new Point();
    }
    
    public static void main(String[] args) {
        
        Arraysort sort=new Arraysort();
        sort.arr[0].x=2;sort.arr[0].y=1;    //初始化，对象数组中的数据
        sort.arr[1].x=2;sort.arr[1].y=2;
        sort.arr[2].x=1;sort.arr[2].y=2;
        sort.arr[3].x=0;sort.arr[3].y=1;
  
        Arrays.sort(sort.arr, new MyComprator());    //使用指定的排序器，进行排序
        for(int i=0;i<4;i++)    //输出排序结果
            System.out.println("("+sort.arr[i].x+","+sort.arr[i].y+")");
    }
}class Point{
    int x;
    int y;
}//比较器，x坐标从小到大排序；x相同时，按照y从小到大排序class MyComprator implements Comparator {
    public int compare(Object arg0, Object arg1) {
        Point t1=(Point)arg0;
        Point t2=(Point)arg1;
        if(t1.x != t2.x)
            return t1.x>t2.x? 1:-1;
        else
            return t1.y>t2.y? 1:-1;
    }
}

执行输出：