快速排序算法

学习快速排序算法后，发现java.util.Arrays中的sort(int[] a)方法中用的就是快速排序，

步骤一1.快速排序就是在数组int[]a 找一个数 a[n]，然后遍历所有需要排序的数字，把小于n的数放到n的前面，把大于n的数放到n后面，

步骤二2.然后在把a[0]到a[n-1]之间的数字重复步骤一，a[n+1]到a[length-1]的数字也是如此，然后再重复前面的步骤（递归），直到每次需要排序的数的个数小于2，

 

下面是java.util.Arrays中的sort(int[] a)方法中截取的代码，使用的是反编译过来的代码，里面的有些部分不是必须的，刚开始学习快读排序的话最好先找一个最基本的例子看看其中的流程：

//外部调用的sort方法

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

//排序的主要方法，x为数组，off为数组的起始位置，len为结束位置

private static void sort1(int x[], int off, int len) {
 // Insertion sort on smallest arrays

//如果数组长度小于7,则使用的是选择排序
 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) {

//从左到右找一个比v大的数
     while (b <= c && x[b] <= v) {
  if (x[b] == v)
      swap(x, a++, b);
  b++;
     }

//从右到左找一个比v小的数
     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));
    }