Java之排序

import java.util.Arrays;
import java.util.Random;

/**
 * 排序工具类<br>
 * 冒泡排序/选择排序/快速排序
 * 
 * @author tang
 * 
 */
public class SortUtils {

	public static void main(String[] args) {

		int[] array = new int[10000];
		Random random = new Random();
		for (int i = 0; i < array.length; i++) {
			array[i] = random.nextInt(array.length);
		}

		System.out.println("冒泡排序：");
		int[] clone1 = array.clone();
		long begin = System.currentTimeMillis();
		bubbleSort(clone1, true);
		System.out.println("本次排序用时：" + (System.currentTimeMillis() - begin));
		println(Arrays.toString(clone1));

		System.out.println("选择排序：");
		int[] clone2 = array.clone();
		begin = System.currentTimeMillis();
		selectionSort(clone2, true);
		System.out.println("本次排序用时：" + (System.currentTimeMillis() - begin));
		println(Arrays.toString(clone2));

		System.out.println("快速排序：");
		int[] clone3 = array.clone();
		begin = System.currentTimeMillis();
		quickSort(clone3, true);
		System.out.println("本次排序用时：" + (System.currentTimeMillis() - begin));
		println(Arrays.toString(clone3));
	}

	private static void println(String str) {
		System.out.println("排序结果：" + str.substring(0, 20).substring(1) + " ...");
	}

	/**
	 * 冒泡排序
	 * 冒泡排序和选择排序的核心思想都是，单轮循环找出最大（或最小）值，找出这个最大值之后，再通过一轮循环找出剩余的最大值，以此类推。
	 * 冒泡排序和选择排序的区别在于，单轮循环冒泡排序用于存放最大值的位置是随循环移动的，而选择排序用于存放最大值的位置是固定不变的。
	 * 
	 * @param array
	 * @param isAsc
	 *            是否升序
	 */
	public static void bubbleSort(int[] array, boolean isAsc) {
		for (int i = 0; i < array.length; i++) {
			for (int j = 0; j < array.length - i - 1; j++) {
				if (isAsc ? (array[j] > array[j + 1]) : (array[j] < array[j + 1])) {
					int temp = array[j];
					array[j] = array[j + 1];
					array[j + 1] = temp;
				}
			}
		}
	}

	/**
	 * 选择排序
	 * 
	 * @param array
	 * @param isAsc
	 *            是否升序
	 */
	public static void selectionSort(int[] array, boolean isAsc) {
		for (int i = 0; i < array.length; i++) {
			for (int j = i + 1; j < array.length; j++) {
				if (isAsc ? (array[i] > array[j]) : array[i] < array[j]) {
					int temp = array[i];
					array[i] = array[j];
					array[j] = temp;
				}
			}
		}
	}

	/**
	 * 快速排序（又称交换排序/exchangeSort）<br>
	 * 参考java.util.DualPivotQuicksort
	 * 
	 * @param array
	 * @param isAsc
	 *            是否升序
	 */
	public static void quickSort(int[] array, boolean isAsc) {
		quickSort(array, 0, array.length - 1, isAsc);
	}

	/**
	 * 快速排序（又称交换排序/exchangeSort）<br>
	 * 参考java.util.DualPivotQuicksort
	 * 
	 * @param array
	 * @param startIndex
	 * @param endIndex
	 * @param isAsc
	 *            是否升序
	 */
	public static void quickSort(int[] array, int startIndex, int endIndex, boolean isAsc) {

		if (startIndex >= endIndex) {
			return;
		}

		int leftIndex = startIndex;
		int rightIndex = endIndex;
		int markValue = array[startIndex];
		int nullValueIndex = startIndex;

		do {
			while (leftIndex < rightIndex && (isAsc ? array[rightIndex] >= markValue : array[rightIndex] < markValue)) {

				rightIndex--;
			}
			if (leftIndex < rightIndex && (isAsc ? array[rightIndex] < markValue : array[rightIndex] >= markValue)) {

				array[nullValueIndex] = array[rightIndex];
				nullValueIndex = rightIndex;
				leftIndex++;
			}
			while (leftIndex < rightIndex && (isAsc ? array[leftIndex] <= markValue : array[leftIndex] > markValue)) {

				leftIndex++;
			}
			if (leftIndex < rightIndex && (isAsc ? array[leftIndex] > markValue : array[leftIndex] <= markValue)) {

				array[nullValueIndex] = array[leftIndex];
				nullValueIndex = leftIndex;
				rightIndex--;
			}
		} while (leftIndex < rightIndex);// ensure last leftIndex less rightIndex, so use do while.

		array[nullValueIndex] = markValue;

		quickSort(array, startIndex, nullValueIndex - 1, isAsc);

		quickSort(array, nullValueIndex + 1, endIndex, isAsc);
	}

}

以下为随机一次10000个数字排序打印结果：
冒泡排序：
本次排序用时：223
排序结果：0, 1, 2, 3, 4, 4, 8 …
选择排序：
本次排序用时：219
排序结果：0, 1, 2, 3, 4, 4, 8 …
快速排序：
本次排序用时：1
排序结果：0, 1, 2, 3, 4, 4, 8 …