array.sort源码解释

* fast: it is guaranteed to run in n log(n) time andruns substantially faster on nearly sorted lists. empirical tests showed it tobe as fast as a highly optimized quicksort. a quicksort is generally consideredto be faster than a merge sort but isn't stable and doesn't guarantee n log(n)performance.


    * stable: it doesn't reorder equal elements. this isimportant if you sort the same list repeatedly on different attributes. if auser of a mail program sorts the inbox by mailing date and then sorts it bysender, the user naturally expects that the now-contiguous list of messagesfrom a given sender will (still) be sorted by mailing date. this is guaranteedonly if the second sort was stable.



     也就是说，优化的归并排序既快速（nlog(n)）又稳定。


     对于对象的排序，稳定性很重要。比如成绩单,一开始可能是按人员的学号顺序排好了的,现在让我们用成绩排,那么你应该保证,本来张三在李四前面,即使他们成绩相同,张三不能跑到李四的后面去。


     而快速排序是不稳定的，而且最坏情况下的时间复杂度是o(n^2)。


     另外，对象数组中保存的只是对象的引用，这样多次移位并不会造成额外的开销，但是，对象数组对比较次数一般比较敏感，有可能对象的比较比单纯数的比较开销大很多。归并排序在这方面比快速排序做得更好，这也是选择它作为对象排序的一个重要原因之一。



    排序优化：实现中快排和归并都采用递归方式，而在递归的底层，也就是待排序的数组长度小于7时, 直接使用冒泡排序，而不再递归下去。


   分析：长度为6的数组冒泡排序总比较次数最多也就1+2+3+4+5+6=21次，最好情况下只有6次比较。而快排或归并涉及到递归调用等的开销，其时间效率在n较小时劣势就凸显了，因此这里采用了冒泡排序，这也是对快速排序极重要的优化。



/*快速排序*/
private static void sort1(int x[], int off, int len) {
    // insertion sort on smallest arrays
    if (len < 7) {
  for (int i=off; i<len+off; i++)
  for (int j=i; j>off && x[j-1]>x[j]; j--)
swap(x, j, j-1);
  return;
    }
    // choose a partition element, v
    int m = off + (len >> 1); // small arrays, middle element
    if (len > 7) {
  int l = off;
  int n = off + len - 1;
  if (len > 40) {  // big arrays, pseudomedian of 9
  int s = len/8;
  l = med3(x, l,     l+s, l+2*s);//取后三个参数中的中间值
  m = med3(x, m-s,   m,   m+s);
  n = med3(x, n-2*s, n-s, n);
  }
  m = med3(x, l, m, n); // mid-size, med of 3
    }
    int v = x[m];
    // establish invariant: v* (<v)* (>v)* v*
    int a = off, b = a, c = off + len - 1, d = c;
    while(true) {
  while (b <= c && x[b] <= v) {
  if (x[b] == v)
swap(x, a++, b);
  b++;
  }
  while (c >= b && x[c] >= v) {
  if (x[c] == v)
swap(x, c, d--);
  c--;
  }
  if (b > c)
  break;
  swap(x, b++, c--);
    }
    // swap partition elements back to middle
    int s, n = off + len;
    s = math.min(a-off, b-a  );  vecswap(x, off, b-s, s);
    s = math.min(d-c,   n-d-1);  vecswap(x, b,   n-s, s);
    // recursively sort non-partition-elements
    if ((s = b-a) > 1)
  sort1(x, off, s);
    if ((s = d-c) > 1)
  sort1(x, n-s, s);
    }
/*归并排序*/
private static void mergesort(object[] src,
object[] dest,
int low,
int high,
int off) {
    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 &&
((comparable) dest[j-1]).compareto(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);
  mergesort(dest, src, mid, high, -off);
  // 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;
  }
  // 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)
    dest[i] = src[p++];
else
    dest[i] = src[q++];
  }
    }