Java sort 源码解析 primitive part

    Java Arrays中提供了对所有类型的排序。其中主要分为primitive和Object两大类，分别使用了快速排序与合并排序。本章以int[] 的排序，讲解Java对primitive排序。

    首先大家要了解什么是快速排序，它有什么优点，这些我就不累述了，给出地址。http://zh.wikipedia.org/zh/%E5%BF%AB%E9%80%9F%E6%8E%92%E5%BA%8F

在了解了基本原理之后，上图可以动态的展示快速排序的基本思路。很经典~

 

接下来，我们展示源码，并仔细讲解！

 

public static void sort(int[] a) { sort1(a, 0, a.length); }

这个方法是对外暴露的调用接口。 sort1 是排序方法的主体，传入参数分别为：待排序数组，排序起始位置，待排序元素长度。

sort1中使用到另外3个方法，首先介绍。

 

1. swap：简单的使用中间变量来交换数组内元素。

private static void swap(int x[], int a, int b) {int t = x[a];x[a] = x[b];x[b] = t; }

 

2.med3：计算中值。

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)); }

 

3.vecswap：批量移动元素

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); }

 

万事俱备，开始详解。

private static void sort1(int x[], int off, int len) {// Insertion sort on smallest arraysif (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;}

开头部分便判断，如果数组长度小于7，便使用插入方法排序。

 

// Choose a partition element, vint m = off + (len >> 1); // Small arrays, middle elementif (len > 7) { int l = off; int n = off + len - 1; if (len > 40) { // Big arrays, pseudomedian of 9int 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];

如果长度较长，便需要利用快速排序，第一步就是找到合适的主元。这里并不是简单使用数组第一位作为主元，而是通过计算得到。

这么做是快速排序的一个变种。不过即不是随机快排，也不是平衡快排，倒更像是将两者所结合。不过找主元这个事，对数组排序效率的影响，都是拼人品的事情。

v 便是通过计算得到的中值。在以后的计算中，充当主元的角色。

 

// 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，只是b++和c--）否则，互换位置（swap(x,b++,c--)）。等于中值的，与最两边数互换位置。（第一第二个swap）。

这样，数组便是中间由小于主元的数（左边）和大于主元的数（右边），以及主元本身（最左边，最右边）组成。

 

 

// Swap partition elements back to middleint 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);

将经过一次快排后的数组重新组合。大致意思是，将两边存在的主元，与中间位置的数对调位置。形成最终主元在中间，左边均比主元小，右边均比主元大的数组。

其中为了提高性能，判断了移动元素的个数要竟可能少。

s=Math.min(a-off,b-a); a-off：是最左边主元个数，b-a是小于主元的个数。取最小值。vecswap(x,off,b-s,s);  将他们位置对调，即保真主元回到中间位置。

同理：s=Math.min(d-c,n-d-1); d-c：大于主元个数，n-d-1是最右边主元个数。再利用vecswap对调。

 

// Recursively sort non-partition-elementsif ((s = b-a) > 1) sort1(x, off, s);if ((s = d-c) > 1) sort1(x, n-s, s); }

分片迭代。接下来，就是将左边和右边不等于中值的，用递归再进行排序。

b-a,即小于主元的元素个数大于1时，才有必要继续迭代排序。

同理，d-c 是大于主元的元素个数，大于1时才继续迭代排序。