快速排序算法

import java.util.Arrays;
import java.util.Comparator;

public class QuickSort {

	/**
	 * 對實現了Comparable接口的對象組成的數組進行排序
	 * 
	 * @param <T>
	 *            數組元素類型
	 * @param array
	 *            待排序數組
	 */
	public static <T extends Comparable<T>> void sort(T[] array) {
		sort(array, 0, array.length - 1);
	}

	/**
	 * 對實現了Comparable接口的對象組成的數組進行排序
	 * 
	 * @param <T>
	 *            數組元素類型
	 * @param array
	 *            待排序數組
	 * @param fromIndex
	 *            排序開始位置
	 * @param toIndex
	 *            排序結束位置
	 */
	public static <T extends Comparable<T>> void sort(T[] array, int fromIndex, int toIndex) {
		if (fromIndex < toIndex) {
			int left = fromIndex;
			int right = toIndex;
			T pivot = array[fromIndex];
			while (left < right) {
				while (array[left].compareTo(pivot) < 0) {
					left++;
				}

				while (array[right].compareTo(pivot) > 0) {
					right--;
				}

				if (left >= right) {
					break;
				}

				swap(array, left, right);

				if (array[left] == pivot) {
					right--;
				}
				if (array[right] == pivot) {
					left++;
				}
			}

			sort(array, fromIndex, right - 1);
			sort(array, right + 1, toIndex);
		}
	}

	/**
	 * 對未實現Comparable接口的對象組成的數組使用自定義比較器進行排序
	 * 
	 * @param <T>
	 *            數組元素類型
	 * @param array
	 *            待排序數組
	 * @param c
	 *            自定義比較器
	 */
	public static <T> void sort(T[] array, Comparator<T> c) {
		sort(array, c, 0, array.length - 1);
	}

	/**
	 * 對未實現Comparable接口的對象組成的數組使用自定義比較器進行排序
	 * 
	 * @param <T>
	 *            數組元素類型
	 * @param array
	 *            待排序數組
	 * @param c
	 *            自定義比較器
	 * @param fromIndex
	 *            排序開始位置
	 * @param toIndex
	 *            排序結束位置
	 */
	public static <T> void sort(T[] array, Comparator<T> c, int fromIndex, int toIndex) {
		if (fromIndex < toIndex) {
			int left = fromIndex;
			int right = toIndex;
			T pivot = array[fromIndex];
			while (left < right) {
				while (c.compare(array[left], pivot) < 0) {
					left++;
				}

				while (c.compare(array[right], pivot) > 0) {
					right--;
				}

				if (left >= right) {
					break;
				}

				swap(array, left, right);

				if (array[left] == pivot) {
					right--;
				}
				if (array[right] == pivot) {
					left++;
				}
			}

			sort(array, c, fromIndex, right - 1);
			sort(array, c, right + 1, toIndex);
		}
	}

	/**
	 * 交換數組中指定位置的元素
	 * 
	 * @param <T>
	 *            數組元素類型
	 * @param array
	 *            原始數組
	 * @param a
	 *            索引
	 * @param b
	 *            索引
	 */
	private static <T> void swap(T[] array, int a, int b) {
		T temp = array[a];
		array[a] = array[b];
		array[b] = temp;
	}
	
	public static void main(String[] args) {
		Integer[] array = { 10, 9, 8, 7, 5, 2, 4, 3, 6, 8, 7, 12, 4, 3, 2, 44, 566, 33, 11 };

		sort(array);

		System.out.println(Arrays.toString(array));
	}
}