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 }