java的几种排序算法

我老老师写的排序算法：

package sort;

import java.util.Comparator;

public class ArrayUtil {
private static final int MERGE_SORT_MIN_SIZE = 7;


/**
* 可用排序方法
*/
public static enum SORT_METHOD {
/**
* 冒泡排序
*/
BUBBLE,
/**
* 快速排序
*/
QUICK,
/**
* 归并排序
*/
MERGE,
/**
* 插入排序
*/
INSERT,
/**
* 选择排序
*/
CHOOSE,
/**
* 希尔排序
*/
SHELL
}

/**
* 排序
* 
* @param <T>
*            数组元素类型
* @param array
*            被排序数组
* @param method
*            排序方法
* @param comparator
*            比较器
*/
public static <T> void sort(T[] array, SORT_METHOD method,
Comparator<? super T> comparator) {
switch (method) {
case BUBBLE:
bubbleSort(array, comparator);
break;
case QUICK:
quickSort(array, comparator, 0, array.length - 1);
break;
case MERGE:
mergeSort(array.clone(), array, 0, array.length, comparator);
break;
case INSERT:
insertSort(array, comparator);
break;
case CHOOSE:
chooseSort(array, comparator);
break;
case SHELL:
shellSort(array, comparator);
break;
}
}

/**
* 冒泡排序实现
* 
* @param <T>
*            数组元素类型
* @param array
*            被排序数组
* @param comparator
*            比较器
*/
private static <T> void bubbleSort(T[] array,
Comparator<? super T> comparator) {
for (int i = array.length - 1; i > -1; --i) {
for (int j = 0; j < i; ++j) {
if (comparator.compare(array[j], array[j + 1]) > 0) {
swap(array, j, j + 1);
}
}
}
}

/**
* 快速排序实现
* 
* @param <T>
*            数组元素类型
* @param array
*            被排序数组
* @param comparator
*            比较器
* @param low
*            开始
* @param high
*            结束
*/
private static <T> void quickSort(T[] array,
Comparator<? super T> comparator, int low, int high) {
if (low >= high)
return;
int lo = low;
int hi = high + 1;
T elem = array[low];
for (;;) {
while (comparator.compare(array[++lo], elem) < 0 && lo < high)
;
while (comparator.compare(array[--hi], elem) > 0 && hi > low)
;
if (lo < hi)
swap(array, lo, hi);
else
break;
}
swap(array, low, hi);
quickSort(array, comparator, low, hi - 1);
quickSort(array, comparator, hi + 1, high);
}

/**
* 归并排序
* 
* @param <T>
*            数组元素类型
* @param src
*            源数组
* @param dest
*            目标数组
* @param low
*            开始
* @param high
*            结束
* @param c
*            比较器
*/
private static <T> void mergeSort(T[] src, T[] dest, int low, int high,
Comparator<? super T> c) {
int length = high - low;
if (length < MERGE_SORT_MIN_SIZE) {
for (int i = low; i < high; i++)
for (int j = i; j > low && c.compare(dest[j - 1], dest[j]) > 0; j--)
swap(dest, j, j - 1);
return;
}
int destLow = low;
int destHigh = high;
int mid = (low + high) >>> 1;
mergeSort(dest, src, low, mid, c);
mergeSort(dest, src, mid, high, c);
if (c.compare(src[mid - 1], src[mid]) <= 0) {
System.arraycopy(src, low, dest, destLow, length);
return;
}
for (int i = destLow, p = low, q = mid; i < destHigh; i++) {
if (q >= high || p < mid && c.compare(src[p], src[q]) <= 0)
dest[i] = src[p++];
else
dest[i] = src[q++];
}
}

/**
* 插入排序实现
* 
* @param <T>
*            数组元素类型
* @param array
*            被排序数组
* @param comparator
*            比较器
*/
private static <T> void insertSort(T[] array,
Comparator<? super T> comparator) {
for (int i = 1; i < array.length; i++) {
for (int j = i; (j > 0)
&& (comparator.compare(array[j], array[j - 1]) < 0); j--) {
swap(array, j, j - 1);
}
}
}

/**
* 选择排序
* 
* @param <T>
*            数组元素类型
* @param array
*            被排序数组
* @param comparator
*            比较器
*/
private static <T> void chooseSort(T[] data,
Comparator<? super T> comparator) {
for (int i = 0; i < data.length; i++) {
int lowIndex = i;
for (int j = data.length - 1; j > i; j--) {
if (comparator.compare(data[j], data[lowIndex]) < 0) {
lowIndex = j;
}
}
swap(data, i, lowIndex);
}
}

/**
* 希尔排序
* 
* @param <T>
*            数组元素类型
* @param array
*            被排序数组
* @param comparator
*            比较器
*/
private static <T> void shellSort(T[] data, Comparator<? super T> comparator) {
for (int i = data.length / 2; i > 2; i /= 2) {
for (int j = 0; j < i; j++) {
shellInsertSort(data, comparator, j, i);
}
}
shellInsertSort(data, comparator, 0, 1);
}

/**
* 希尔排序的增量排序
* 
* @param <T>
*            数组元素类型
* @param array
*            被排序数组
* @param comparator
*            比较器
* @param start
*            开始位置
* @param inc
*            步长
*/
private static <T> void shellInsertSort(T[] data,
Comparator<? super T> comparator, int start, int inc) {
for (int i = start + inc; i < data.length; i += inc) {
for (int j = i; (j >= inc)
&& (comparator.compare(data[j], data[j - inc]) < 0); j -= inc) {
swap(data, j, j - inc);
}
}
}

/**
* 交换两个元素的位置
* 
* @param <T>
*            元素
* @param array
*            数组
* @param i
*            位置1
* @param j
*            位置2
*/
private static <T> void swap(T[] array, int i, int j) {
T t = array[i];
array[i] = array[j];
array[j] = t;
}


}