java 集合类源码分析--arrays

本文介绍一下java集合相关类arryas类的内容

、Arrays.sort()数组排序

Java Arrays中提供了对所有类型的排序。其中主要分为Primitive(8种基本类型)和Object两大类。

　　基本类型：采用调优的快速排序；

　　对象类型：采用改进的归并排序。

 

1、对于基本类型源码分析如下（以int[]为例）：

 

public static void sort(int[] a, int fromIndex, int toIndex) {

//进行数组的界限检查

        rangeCheck(a.length, fromIndex, toIndex);

//然后调用DualPivotQuicksort的sort方法

        DualPivotQuicksort.sort(a, fromIndex, toIndex - 1);

}

跟进DualPivotQuicksort的源码中可以发现

/*

      * The maximum number of runs in merge sort.

      *排序的过程中判断数组是否是基本有序的67为临界值 具体可以参考源码

      *否则用快速排序代替归并排序

     */

    private static final int MAX_RUN_COUNT = 67;

 

    /**

     * The maximum length of run in merge sort.

     */

    private static final int MAX_RUN_LENGTH = 33;

 

//当数组的长度小于286的时候，快速排序优于归并排序

    private static final int QUICKSORT_THRESHOLD = 286;

 

//当数组的长度小于47的时候，插入排序优于快速排序

 

    private static final int INSERTION_SORT_THRESHOLD = 47;

//当字节数组的长度大于29的时候，计数排序优于插入排序

    private static final int COUNTING_SORT_THRESHOLD_FOR_BYTE = 29;

 

//当short类型数组或者char类型数组的长度大于3200的时候，计数优于快速排序

 

    private static final int COUNTING_SORT_THRESHOLD_FOR_SHORT_OR_CHAR = 3200;

下面介绍一下程序用到的排序算法

1.归并排序

归并排序具体工作原理如下（假设序列共有n个元素）：

将序列每相邻两个数字进行归并操作（merge)，形成floor(n/2)个序列，排序后每个序列包含两个元素

将上述序列再次归并，形成floor(n/4)个序列，每个序列包含四个元素

重复步骤2，直到所有元素排序完毕

public　class　MergeSort　{

    //　private　static　long　sum　=　0;

    /**

    　*　<pre>

    　*　二路归并

    　*　原理：将两个有序表合并和一个有序表

    　*　</pre>

    　*　

    　*　@param　a

    　*　@param　s

    　*　第一个有序表的起始下标

    　*　@param　m

    　*　第二个有序表的起始下标

    　*　@param　t

    　*　第二个有序表的结束小标

    　*　

    　*/

    private　static　void　merge(int[]　a,　int　s,　int　m,　int　t)　{

        int[]　tmp　=　new　int[t　-　s　+　1];

        int　i　=　s,　j　=　m,　k　=　0;

        while　(i　<　m　&&　j　<=　t)　{

            if　(a[i]　<=　a[j])　{

                tmp[k]　=　a[i];

                k++;

                i++;

            }　else　{

                tmp[k]　=　a[j];

                j++;

                k++;

            }

        }

        while　(i　<　m)　{

            tmp[k]　=　a[i];

            i++;

            k++;

        }

        while　(j　<=　t)　{

            tmp[k]　=　a[j];

            j++;

            k++;

        }

        System.arraycopy(tmp,　0,　a,　s,　tmp.length);

    }

    /**

    　*　

    　*　@param　a

    　*　@param　s

    　*　@param　len

    　*　每次归并的有序集合的长度

    　*/

    public　static　void　mergeSort(int[]　a,　int　s,　int　len)　{

        int　size　=　a.length;

        int　mid　=　size　/　(len　<<　1);

        int　c　=　size　&　((len　<<　1)　-　1);

        //　-------归并到只剩一个有序集合的时候结束算法-------//

        if　(mid　==　0)

            return;

        //　------进行一趟归并排序-------//

        for　(int　i　=　0;　i　<　mid;　++i)　{

            s　=　i　*　2　*　len;

            merge(a,　s,　s　+　len,　(len　<<　1)　+　s　-　1);

        }

        //　-------将剩下的数和倒数一个有序集合归并-------//

        if　(c　!=　0)

            merge(a,　size　-　c　-　2　*　len,　size　-　c,　size　-　1);

        //　-------递归执行下一趟归并排序------//

        mergeSort(a,　0,　2　*　len);

    }

    public　static　void　main(String[]　args)　{

        int[]　a　=　new　int[]　{　4,　3,　6,　1,　2,　5　};

        mergeSort(a,　0,　1);

        for　(int　i　=　0;　i　<　a.length;　++i)　{

            System.out.print(a[i]　+　"　");

        }

    }

}

 

2.快速排序

设要排序的数组是A[0]……A[N-1]，首先任意选取一个数据（通常选用数组的第一个数）作为关键数据，然后将所有比它小的数都放到它前面，所有比它大的数都放到它后面，这个过程称为一趟快速排序。值得注意的是，快速排序不是一种稳定的排序算法，也就是说，多个相同的值的相对位置也许会在算法结束时产生变动。

一趟快速排序的算法是：

1）设置两个变量i、j，排序开始的时候：i=0，j=N-1；

2）以第一个数组元素作为关键数据，赋值给key，即key=A[0]；

3）从j开始向前搜索，即由后开始向前搜索(j--)，找到第一个小于key的值A[j]，将A[j]和A[i]互换；

4）从i开始向后搜索，即由前开始向后搜索(i++)，找到第一个大于key的A[i]，将A[i]和A[j]互换；

5）重复第3、4步，直到i=j； (3,4步中，没找到符合条件的值，即3中A[j]不小于key,4中A[i]不大于key的时候改变j、i的值，使得j=j-1，i=i+1，直至找到为止。找到符合条件的值，进行交换的时候i， j指针位置不变。另外，i==j这一过程一定正好是i+或j-完成的时候，此时令循环结束）。

 

3.插入排序

包括：直接插入排序，二分插入排序（又称折半插入排序），链表插入排序，希尔排序（又称缩小增量排序）。属于稳定排序的一种（通俗地讲，就是两个相等的数不会交换位置） 。

直接插入排序

直接插入排序是一种简单的插入排序法，其基本思想是：把待排序的纪录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的纪录插入完为止，得到一个新的有序序列。[1] 

例如,已知待排序的一组纪录是：

60,71,49,11,24,3,66

假设在排序过程中，前3个纪录已按关键码值递增的次序重新排列，构成一个有序序列：

49,60,71

将待排序纪录中的第4个纪录（即11）插入上述有序序列，以得到一个新的含4个纪录的有序序列。首先，应找到11的插入位置，再进行插入。可以讲11放入数组的第一个单元r[0]中，这个单元称为监视哨，然后从71起从右到左查找，11小于71，将71右移一个位置，11小于60，又将60右移一个位置，11小于49，又再将49右移一个位置，这时再将11与r[0]的值比较，11≥r[0]，它的插入位置就是r[1]。假设11大于第一个值r[1]。它的插入位置应该在r[1]和r[2]之间，由于60已经右移了，留出来的位置正好留给11.后面的纪录依照同样的方法逐个插入到该有序序列中。若纪录数n,续进行n-1趟排序，才能完成。

直接插入排序的算法思路：

（1） 设置监视哨r[0]，将待插入纪录的值赋值给r[0]；

（2） 设置开始查找的位置j；

（3） 在数组中进行搜索，搜索中将第j个纪录后移，直至r[0].key≥r[j].key为止；

（4） 将r[0]插入r[j+1]的位置上。

 

折半插入排序（二分插入排序）

将直接插入排序中寻找A[i]的插入位置的方法改为采用折半比较，即可得到折半插入排序算法。在处理A[i]时，A[0]……A[i-1]已经按关键码值排好序。所谓折半比较，就是在插入A[i]时，取A[i-1/2]的关键码值与A[i]的关键码值进行比较，如果A[i]的关键码值小于A[i-1/2]的关键码值，则说明A[i]只能插入A[0]到A[i-1/2]之间，故可以在A[0]到A[i-1/2-1]之间继续使用折半比较；否则只能插入A[i-1/2]到A[i-1]之间，故可以在A[i-1/2+1]到A[i-1]之间继续使用折半比较。如此担负，直到最后能够确定插入的位置为止。一般在A[k]和A[r]之间采用折半，其中间结点为A[k+r/2]，经过一次比较即可排除一半纪录，把可能插入的区间减小了一半，故称为折半。执行折半插入排序的前提是文件纪录必须按顺序存储。[2] 

折半插入排序的算法思想：

算法的基本过程：

（1）计算 0 ~ i-1 的中间点，用 i 索引处的元素与中间值进行比较，如果 i 索引处的元素大，说明要插入的这个元素应该在中间值和刚加入i索引之间，反之，就是在刚开始的位置 到中间值的位置，这样很简单的完成了折半；

（2）在相应的半个范围里面找插入的位置时，不断的用（1）步骤缩小范围，不停的折半，范围依次缩小为 1/2 1/4 1/8 .......快速的确定出第 i 个元素要插在什么地方；

（3）确定位置之后，将整个序列后移，并将元素插入到相应位置。

3 希尔排序法

希尔排序法又称缩小增量法。希尔排序法的基本思想是：先选定一个整数，把待排序文件中所有记录分成个组，所有距离为的记录分在同一组内，并对每一组内的记录进行排序。然后，取，重复上述分组和排序的工作。当到达=1时，所有记录在统一组内排好序。

各组内的排序通常采用直接插入法。由于开始时s的取值较大，每组内记录数较少，所以排序比较快。随着不断增大，每组内的记录数逐步增多，但由于已经按排好序，因此排序速度也比较快。

 

4.计数排序

计数排序：

计数排序，貌似计数排序的复杂度为o(n)。很强大。他的基本思路为：

1)我们希望能线性的时间复杂度排序，如果一个一个比较，显然是不实际的，书上也在决策树模型中论证了，比较排序的情况为nlogn的复杂度。

2)既然不能一个一个比较，我们想到一个办法，就是如果我在排序的时候就知道他的位置，那不就是扫描一遍，把他放入他应该的位置不就可以了嘛。

3)知道他的位置，我们只需要知道有多少不大于他不就可以了吗？

4)以此为出发点，我们怎么确定不大于他的个数呢？我们先来个约定，如果数组中的元素都比较集中，都在[0, max]范围内。我们开一个max的空间b数组，把b数组下标对应的元素和要排序的A数组下标对应起来。这样不就可以知道不比他大的有多少个了吗？我们只要把比他小的位置元素个数求和，就是不比他大的。例如：A={3,5,7};我们开一个大小为8的数组b，把a[0] = 3 放入b[3]中，使b[3] = 0; 同理 b[5] = 1; b[7] = 2;其他我们都设置为-1，哈哈我们只需要遍历一下b数组，如果他有数据，就来出来，铁定是当前最小的。如果要知道比a[2]小的数字有多少个，值只需要求出b[0] – b[6]的有数据的和就可以了。这个0(n)的速度不是盖得。

5)思路就是这样咯。但是要注意两个数相同的情况A = {1,2,3,3,4}，这种情况就不可以咯，所以还是有点小技巧的。

6)处理小技巧：我们不把A的元素大小与B的下标一一对应，而是在B数组对应处记录该元素大小的个数。这不久解决了吗。哈哈。例如A = {1,2,3,3,4}我们开大小为5的数组b;记录数组A中元素值为0的个数为b[0] = 0, 记录数组A中元素个数为1的b[1] = 1,同理b[2] = 1, b[3] = 2, b[4] = 1;好了，这样我们就知道比A[4](4)小的元素个数是多少了：count = b[0] + b[1] + b[2] + b[3] = 4;他就把A[4]的元素放在第4个位置。

注：

因此它只能用于知道数的范围的内进行排序，在我们的DualPivotQuicksort中是char 还有byte类型是有该算法，也不至于浪费太大的空间。

5.桶排序

桶排序的基本思想

假设有一组长度为N的待排关键字序列K[1....n]。首先将这个序列划分成M个的子区间(桶) 。然后基于某种映射函数 ，将待排序列的关键字k映射到第i个桶中(即桶数组B的下标 i) ，那么该关键字k就作为B[i]中的元素(每个桶B[i]都是一组大小为N/M的序列)。接着对每个桶B[i]中的所有元素进行比较排序(可以使用快排)。然后依次枚举输出B[0]....B[M]中的全部内容即是一个有序序列。

假如待排序列K= {49、 38 、 35、 97 、 76、 73 、 27、 49 }。这些数据全部在1—100之间。因此我们定制10个桶，然后确定映射函数f(k)=k/10。则第一个关键字49将定位到第4个桶中(49/10=4)。依次将所有关键字全部堆入桶中，并在每个非空的桶中进行快速排序。

桶排序代价分析

桶排序利用函数的映射关系，减少了几乎所有的比较工作。实际上，桶排序的f(k)值的计算，其作用就相当于快排中划分，已经把大量数据分割成了基本有序的数据块(桶)。然后只需要对桶中的少量数据做先进的比较排序即可。

 

对N个关键字进行桶排序的时间复杂度分为两个部分：

(1) 循环计算每个关键字的桶映射函数，这个时间复杂度是O(N)。

(2) 利用先进的比较排序算法对每个桶内的所有数据进行排序，其时间复杂度为 ∑ O(Ni*logNi) 。其中Ni 为第i个桶的数据量。

 

很显然，第(2)部分是桶排序性能好坏的决定因素。尽量减少桶内数据的数量是提高效率的唯一办法(因为基于比较排序的最好平均时间复杂度只能达到O(N*logN)了)。因此，我们需要尽量做到下面两点：

(1) 映射函数f(k)能够将N个数据平均的分配到M个桶中，这样每个桶就有[N/M]个数据量。

(2) 尽量的增大桶的数量。极限情况下每个桶只能得到一个数据，这样就完全避开了桶内数据的“比较”排序操作。 当然，做到这一点很不容易，数据量巨大的情况下，f(k)函数会使得桶集合的数量巨大，空间浪费严重。这就是一个时间代价和空间代价的权衡问题了。

 

对于N个待排数据，M个桶，平均每个桶[N/M]个数据的桶排序平均时间复杂度为：

O(N)+O(M*(N/M)*log(N/M))=O(N+N*(logN-logM))=O(N+N*logN-N*logM)

当N=M时，即极限情况下每个桶只有一个数据时。桶排序的最好效率能够达到O(N)。

 

总结： 桶排序的平均时间复杂度为线性的O(N+C)，其中C=N*(logN-logM)。如果相对于同样的N，桶数量M越大，其效率越高，最好的时间复杂度达到O(N)。 当然桶排序的空间复杂度 为O(N+M)，如果输入数据非常庞大，而桶的数量也非常多，则空间代价无疑是昂贵的。此外，桶排序是稳定的。