java源码分析:Arrays.sort

Posted 2020-08-24 Faron

  1   2 
  3 仔细分析java的Arrays.sort(version 1.71, 04/21/06)后发现，java对primitive（int，float等原型数据）数组采用快速排序，对Object对象数组采用归并排序。
  4 　　对这一区别，sun在<<The Java Tutorial>>中做出的解释是：
  5 　　The sort operation uses a slightly optimized merge sort algorithm that is fast and stable:
  6 　 　* Fast: It is guaranteed to run in n log(n) time and runs substantially faster on nearly sorted lists. Empirical tests showed it to be as fast as a highly optimized quicksort. A quicksort is generally considered to be faster than a merge sort but isn‘t stable and doesn‘t guarantee n log(n) performance.
  7 　　* Stable: It doesn‘t reorder equal elements. This is important if you sort the same list repeatedly on different attributes. If a user of a mail program sorts the inbox by mailing date and then sorts it by sender, the user naturally expects that the now-contiguous list of messages from a given sender will (still) be sorted by mailing date. This is guaranteed only if the second sort was stable.
  8 　　也就是说，优化的归并排序既快速（nlog(n)）又稳定。
  9 　　对于对象的排序，稳定性很重要。比如成绩单,一开始可能是按人员的学号顺序排好了的,现在让我们用成绩排,那么你应该保证,本来张三在李四前面,即使他们成绩相同,张三不能跑到李四的后面去。
 10 　　而快速排序是不稳定的，而且最坏情况下的时间复杂度是O(n^2)。
 11 　　另外，对象数组中保存的只是对象的引用，这样多次移位并不会造成额外的开销，但是，对象数组对比较次数一般比较敏感，有可能对象的比较比单纯数的比较开销大很多。归并排序在这方面比快速排序做得更好，这也是选择它作为对象排序的一个重要原因之一。
 12 　　排序优化：实现中快排和归并都采用递归方式，而在递归的底层，也就是待排序的数组长度小于7时, 直接使用冒泡排序，而不再递归下去。
 13 　　分析：长度为6的数组冒泡排序总比较次数最多也就1+2+3+4+5+6=21次，最好情况下只有6次比较。而快排或归并涉及到递归调用等的开销，其时间效率在n较小时劣势就凸显了，因此这里采用了冒泡排序，这也是对快速排序极重要的优化。
 14 　　/*快速排序*/
 15 　　private static void sort1(int x[], int off, int len) {
 16 　　// Insertion sort on smallest arrays
 17 　　　　if (len < 7) {
 18 　　　　　　for (int i=off; i<len+off; i++)
 19 　　　　　　for (int j=i; j>off && x[j-1]>x[j]; j--)
 20 　　　　　　　　　　swap(x, j, j-1);
 21 　　　　　　　　　　return;
 22 　　　　}
 23 　　// Choose a partition element, v
 24 　　int m = off + (len >> 1); // Small arrays, middle element
 25 　　if (len > 7) {
 26 　　int l = off;
 27 　　int n = off + len - 1;
 28 　　if (len > 40) { // Big arrays, pseudomedian of 9
 29 　　int s = len/8;
 30 　　l = med3(x, l, l+s, l+2*s);//取后三个参数中的中间值
 31 　　m = med3(x, m-s, m, m+s);
 32 　　n = med3(x, n-2*s, n-s, n);
 33 　　}
 34 　　m = med3(x, l, m, n); // Mid-size, med of 3
 35 　　}
 36 　　int v = x[m];
 37 　　// Establish Invariant: v* (<v)* (>v)* v*
 38 　　int a = off, b = a, c = off + len - 1, d = c;
 39 　　while(true) {
 40 　　while (b <= c && x[b] <= v) {
 41 　　if (x[b] == v)
 42 　　swap(x, a++, b);
 43 　　b++;
 44 　　}
 45 　　while (c >= b && x[c] >= v) {
 46 　　if (x[c] == v)
 47 　　swap(x, c, d--);
 48 　　c--;
 49 　　}
 50 　　if (b > c)
 51 　　break;
 52 　　swap(x, b++, c--);
 53 　　}
 54 　　// Swap partition elements back to middle
 55 　　int s, n = off + len;
 56 　　s = Math.min(a-off, b-a ); vecswap(x, off, b-s, s);
 57 　　s = Math.min(d-c, n-d-1); vecswap(x, b, n-s, s);
 58 　　// Recursively sort non-partition-elements
 59 　　if ((s = b-a) > 1)
 60 　　sort1(x, off, s);
 61 　　if ((s = d-c) > 1)
 62 　　sort1(x, n-s, s);
 63 　　}
 64 　　/*归并排序*/
 65 　　private static void mergeSort(Object[] src,
 66 　　Object[] dest,
 67 　　int low,
 68 　　int high,
 69 　　int off) {
 70 　　int length = high - low;
 71 　　// Insertion sort on smallest arrays
 72 　　if (length < INSERTIONSORT_THRESHOLD) {
 73 　　for (int i=low; i<high; i++)
 74 　　for (int j=i; j>low &&
 75 　　((Comparable) dest[j-1]).compareTo(dest[j])>0; j--)
 76 　　swap(dest, j, j-1);
 77 　　return;
 78 　　}
 79 　　// Recursively sort halves of dest into src
 80 　　int destLow = low;
 81 　　int destHigh = high;
 82 　　low += off;
 83 　　high += off;
 84 　　int mid = (low + high) >>> 1;
 85 　　mergeSort(dest, src, low, mid, -off);
 86 　　mergeSort(dest, src, mid, high, -off);
 87 　　// If list is already sorted, just copy from src to dest. This is an
 88 　　// optimization that results in faster sorts for nearly ordered lists.
 89 　　if (((Comparable)src[mid-1]).compareTo(src[mid]) <= 0) {
 90 　　System.arraycopy(src, low, dest, destLow, length);
 91 　　return;
 92 　　}
 93 　　// Merge sorted halves (now in src) into dest
 94 　　for(int i = destLow, p = low, q = mid; i < destHigh; i++) {
 95 　　if (q >= high || p < mid && ((Comparable)src[p]).compareTo(src[q])<=0)
 96 　　dest[i] = src[p++];
 97 　　else
 98 　　dest[i] = src[q++];
 99 　　}
100 　　}