用Java泛型实现快速排序

package ch10;

public class QuickSort {
	/**
	 * successfully-快速排序
	 * 使用了泛型-自然排序
	 * @param <T>
	 * @param t
	 */
	public static <T extends Comparable> void quikSort(T[] t){
		recursiveSort(t, 0, t.length-1);
	}
	
	/**
	 * 快速排序-递归调用
	 * @param <T>
	 * @param t
	 * @param low
	 * @param high
	 */
	private static <T extends Comparable> void recursiveSort(T[] t, int low, int high){
		if(t == null || low >= high) return;
		int pivotLoc = partition(t, low, high);
		//先对长度较短的子序列进行快速排序，以使栈的最大深度在最坏情况下降为O(logn)
		if(pivotLoc-low > high-pivotLoc){
			recursiveSort(t, pivotLoc+1, high);
			recursiveSort(t, low, pivotLoc-1);
		}else{
			recursiveSort(t, low, pivotLoc-1);
			recursiveSort(t, pivotLoc+1, high);
		}
	}
	
	/**
	 * 快速排序-一次划分
	 * @param <T>
	 * @param t
	 * @param low
	 * @param high
	 * @return
	 */
	private static <T extends Comparable> int partition(T[] t, int low, int high){
		selectPivotKey(t, low, high);
//		System.out.println("low---"+t[low]);
		T pivotKey = t[low];
		while(low < high){
			while(t[high].compareTo(pivotKey)>=0 && low<high){
				high--;
			}
			t[low] = t[high];
			while(t[low].compareTo(pivotKey)<=0 && low<high){
				low++;
			}
			t[high] = t[low];
		}
		t[low] = pivotKey;
		
		return low;
	}
	
	/**
	 * 快速排序-三者取中来设置pivotKey
	 * @param <T>
	 * @param t
	 * @param low
	 * @param high
	 * @return
	 */
	private static <T extends Comparable> boolean selectPivotKey(T[] t, int low, int high) {
		if(t==null || low < 0 || high > t.length){
			throw new IllegalArgumentException("参数传递不正确");
		}
		T min = t[low];
		T mid = t[(low+high)/2];
		T max = t[high];
		if(min.compareTo(mid) > 0){
			T temp = min;
			min = mid;
			mid = temp;
		}
		if(max.compareTo(min) < 0) mid = min;
		else if(max.compareTo(mid) < 0) mid = max;
		if(mid.compareTo(t[low]) == 0) return true;
		else if(mid.compareTo(t[(low+high)/2]) == 0){
			return swap(t, low, (low+high)/2);
		}else{
			return swap(t, low, high);
		}
	}
	
	/**
	 * 交换数组中的元素
	 * @param <T>
	 * @param t
	 * @param i
	 * @param j
	 */
	private static <T> boolean swap(T[] t, int i, int j){
		if(i<0 || i>=t.length || j<0 || j>=t.length) return false;
		if(t == null) return true;
		
		T temp = t[i];
		t[i] = t[j];
		t[j] = temp;
		
		return true;
	}
	
	public static void main(String[] args) {
		Integer[] arr = new Integer[]{1,2,5,4,5,6,7,8,9};
		QuickSort.<Integer>quikSort(arr);
		for(int i : arr){
			System.out.println(i);
		}
	}
}