Java库中的排序方法

最新推荐文章于 2024-11-11 00:03:55 发布

212121221212121

最新推荐文章于 2024-11-11 00:03:55 发布

阅读量681

点赞数

文章标签： java arrays algorithm primitive object sorting

本文链接：https://blog.csdn.net/xinglongbing/article/details/2947149

版权

Java中的java.util.Arrays.sort方法，对于primitive data type采用的是插入排序(元素书目小于7)和快速排序。

对于对象数组的排序采用的是归并排序。

/**
 * Sorts the specified sub-array of integers into ascending order.
 */
 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);
    }

    /**
     * Swaps x[a] with x[b].
     */
    private static void swap(int x[], int a, int b) {
int t = x[a];
x[a] = x[b];
x[b] = t;
    }

/**
 * Swaps x[a .. (a+n-1)] with x[b .. (b+n-1)].
 */
 private static void vecswap(int x[], int a, int b, int n) {
for (int i=0; i<n; i++, a++, b++)
 swap(x, a, b);
 }

/**
 * Returns the index of the median of the three indexed integers.
 */
 private static int med3(int x[], int a, int b, int c) {
return (x[a] < x[b] ?
 (x[b] < x[c] ? b : x[a] < x[c] ? c : a) :
 (x[b] > x[c] ? b : x[a] > x[c] ? c : a));
 }

* This sort is guaranteed to be stable: equal elements will
 * not be reordered as a result of the sort.
 *
 * The sorting algorithm is a modified mergesort (in which the merge is
 * omitted if the highest element in the low sublist is less than the
 * lowest element in the high sublist). This algorithm offers guaranteed
 * n*log(n) performance.
 *
 * @param a the array to be sorted
 * @throws ClassCastException if the array contains elements that are not
 * mutually comparable (for example, strings and integers).
 */
 public static void sort(Object[] a) {
 Object[] aux = (Object[])a.clone();
 mergeSort(aux, a, 0, a.length, 0);
 }