快速排序的两个JAVA实现

快速排序的两个实现， 差别在分段函数不同的分段函数

import java.util.Arrays;

public class SortTest {
	public static void main(String[] args) {
		Integer[] list = new Integer[100000];
//		Integer[] list = new Integer[10000];
		for (int i = 0; i < list.length; i++) {
			list[i] = (int) (Math.random() * 100000);
		}
		long start = System.currentTimeMillis();
//		maopao(list);
		 quickSort(list,0,list.length);
//		QuickSort.sort(list, 0, list.length - 1);
		long end = System.currentTimeMillis();
		System.out.println(end - start);

		// list = new Integer[5000];
		// for(int i=0; i<list.length;i++)
		// {
		// list[i] = (int)(Math.random()*100000);
		// }
		// start = System.currentTimeMillis();
		// maopao(list);
		// Arrays.sort(list);
		// end = System.currentTimeMillis();
		// System.out.println(end - start);

		// list = new Integer[10000];
		// for(int i=0; i<list.length;i++)
		// {
		// list[i] = (int)(Math.random()*100000);
		// }
		// start = System.currentTimeMillis();
		// maopao(list);
		// end = System.currentTimeMillis();
		// System.out.println(end - start);

//		 System.out.println(Arrays.deepToString(list));
	}

	public static <T extends Comparable<T>> void maopao(T[] list) {
		for (int i = 0; i < list.length; i++) {
			for (int j = i + 1; j < list.length; j++) {
				if (list[i].compareTo(list[j]) > 0) {
					swap(list, i, j);
				}
			}
		}

	}

	/**
	 * 把数组安装一个数 分成两部分
	 * 
	 * @param list
	 */
	public static <T extends Comparable<T>> void quickSort(T[] list, int from,
			int to) {
		if (from == to) {
			return;
		}
		int position = partition(list, from, to);

		quickSort(list, from, position);
		quickSort(list, position + 1, to);

	}

	/**
	 * 
	 * @param list
	 */
	public static <T extends Comparable<T>> int partition(T[] list, int from,
			int to) {
		int position = from;
		
		int mid = from + (to - from)/2;
		T key = list[mid];
		SortTest.swap(list, from, mid);
		
		for (int i = from + 1; i < to; i++) {
			if (key.compareTo(list[i]) > 0) {
				//把中值交换到比较位置
				swap(list, position, i);
				//移回到原来位置的下一个
				swap(list, ++position, i);

			}
		}
		return position;
	}

	public static <T> void swap(T[] list, int left, int right) {
		T temp = list[left];
		list[left] = list[right];
		list[right] = temp;
	}

}

class QuickSort {


	private static <T extends Comparable<T>> int partition(T[] array, int low,
			int high) {

		int stack = low;
		int position = low + (high - low)/2;
		T key = array[position];
		SortTest.swap(array, low, position);
		while (low < high) {
			// 从后向前搜索比key小的值
			while (array[high].compareTo(key) >= 0 && high > low) {
				--high;
			}
			// 从前向后搜索比key大的值，比key大的放右边
			while (array[low].compareTo(key) <=0 && high > low) {
				++low;
			}
			if(low<high)
			{
				SortTest.swap(array, low, high);	
			}			
			// System.out.println(low + "," + high);
		}
		SortTest.swap(array, stack, low);	
		// System.out.println(Arrays.toString(array));
		return high;
	}

	/**
	 * 快速排序
	 * 
	 * @param arry
	 * @return
	 */
	public static <T extends Comparable<T>> void sort(T[] array, int low,
			int high) {
		if (low >= high) {
			return;
		}
		// 完成一次单元排序
		int index = partition(array, low, high);
		// 对左边单元进行排序
		sort(array, low, index - 1);
		// 对右边单元进行排序
		sort(array, index + 1, high);
	}
}