快速排序

public static Integer CUTOFF = 10;
 /**
  * 交换位置
  */
 public static <AnyType extends Comparable<? super AnyType>> void swapReferences(AnyType [] a,int left,int right){
  AnyType temp ;
  temp = a[ left ];
  a[ left ] = a[ right ];
  a[ right ] = temp;
 }
   /**
    * 插入排序
    */
 public static <AnyType extends Comparable<? super AnyType>> void insertSort(AnyType [] a){
  int j;
  for(int p = 1; p < a.length; p++){
   AnyType temp = a[ p ];
   for(j = p; j > 0 && temp.compareTo(a[ j - 1 ]) < 0;j--){
    a[ j ] = a[ j - 1 ];
   }
   a[ j ] = temp;
  }
 }
 /**
  * Return median of left,center, and right .
  * Order these and hide the pivot
  */
 public static <AnyType extends Comparable<? super AnyType>> AnyType median3(AnyType [] a,int left,int right){
  int center = ( left + right ) / 2;
  if(a[ center ].compareTo(a[ left ]) < 0){
   swapReferences(a,left,center);
  }
  if(a[ right ].compareTo(a[ left]) < 0){
   swapReferences(a,left,right);
  }
  if(a[ right ].compareTo(a[ center ]) < 0){
   swapReferences(a,center,right);
  }
  //Place pivot at position right - 1
  swapReferences(a,center,right - 1);
  return a[right - 1];
 }
 /**
  * quickSort that makes recursive calls

  * CUTOFF 为截止的个数，书上说经研究，在数量较小的情况下，插入排序比快排的效率高，所以在数量少的情况下使用插入排序，

  * CUTOFF值为10
  */
 public static <AnyType extends Comparable<? super AnyType>> void quickSort(AnyType a[],int left,int right){
  if(left + CUTOFF < right){
   AnyType pivot = median3(a,left,right);
   //Begin partitioning
   int i = left,j = right - 1;
   for(;;){
    while(a[ ++i ].compareTo( pivot ) < 0){}
    while(a[ --j ].compareTo( pivot ) < 0){}
    if(i < j)
     swapReferences( a, i, j);
    else
     break;
   }
   swapReferences(a, i, right - 1);//restore pivot
   quickSort(a, left, i - 1);
   quickSort(a, i + 1, right);
  }
  else{
   insertSort(a);
  }
 }