排序算法

1

public class SortTest {

	public static int test1[] = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 };

	public static int test2[] = { 3, 1, 6, 4, 5, 2 };

	public static int test3[] = { 57, 68, 59, 52, 72, 28, 96, 33, 24, 19 };

	public static void main(final String[] args) {
		// bubbleSort(test2);
		// selectSort(test2);
		quickSort(test3);
	}

	/**
	 * 冒泡排序算法(升序)的运作如下：
	 * 比较【相邻】的元素。如果第一个比第二个大，就交换他们两个。
	 * 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
	 * 针对所有的元素重复以上的步骤，除了最后一个(最后一个已经是上一趟中找出的最大的元素了，不需要再排序)。
	 * 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
	 * 
	 * @param array
	 */
	public static void bubbleSort(final int[] array) {
		System.out.println("冒泡排序开始：\n0:" + Arrays.toString(array));
		int changeNum = 1;
		for (int i = 0; i < array.length - 1; i++) {
			System.out.println("开始第" + (i + 1) + "趟");
			for (int j = 0; j < array.length - 1 - i; j++) {
				if (array[j] > array[j + 1]) {
					final int temp = array[j];
					array[j] = array[j + 1];
					array[j + 1] = temp;
					System.out.println(changeNum++ + ":" + Arrays.toString(array));
				}
			}
		}
		System.out.println("冒泡排序结束!");

		/*
		 * 冒泡开始：
		 * 0:[3, 1, 6, 4, 5, 2]
		 * 开始第1趟
		 * 1:[1, 3, 6, 4, 5, 2]
		 * 2:[1, 3, 4, 6, 5, 2]
		 * 3:[1, 3, 4, 5, 6, 2]
		 * 4:[1, 3, 4, 5, 2, 6]
		 * 开始第2趟
		 * 5:[1, 3, 4, 2, 5, 6]
		 * 开始第3趟
		 * 6:[1, 3, 2, 4, 5, 6]
		 * 开始第4趟
		 * 7:[1, 2, 3, 4, 5, 6]
		 * 开始第5趟
		 * 冒泡结束!
		 */

	}

	/**
	 * 选择排序原理：
	 * 先假设无序数组中第一个元素是最小元素（记住下标）,从第二个开始依次和第一个比较；
	 * 如果比第一个小，就把最小元素下标替换掉；
	 * 依次比较完毕后，如果下标已经被替换，就把第一个元素和替换下标的元素交换位置;
	 * 然后开始下一轮比较(下一轮把上一轮找到的最小的元素去掉)
	 * 
	 * @param array
	 */
	public static void selectSort(final int[] array) {
		System.out.println("选择排序开始：\n0:" + Arrays.toString(array));
		int changeNum = 1;

		int minIndex = 0;// 第n趟比较中的最小元素的下标
		for (int i = 0; i < array.length - 1; i++) {
			minIndex = i;// 无序区的最小数据数组下标
			for (int j = i + 1; j < array.length; j++) {// 在无序区中找到最小数据并保存其数组下标
				if (array[j] < array[minIndex]) {
					minIndex = j;
				}
			}
			if (minIndex != i) {
				// 如果不是无序区的最小值位置不是默认的第一个数据，则交换之。
				final int temp = array[i];
				array[i] = array[minIndex];
				array[minIndex] = temp;
				System.out.println(changeNum++ + ":" + Arrays.toString(array));
			}
		}
		System.out.println("选择排序结束!");

		/*
		 * 选择排序开始：
		 * 0:[3, 1, 6, 4, 5, 2]
		 * 1:[1, 3, 6, 4, 5, 2]
		 * 2:[1, 2, 6, 4, 5, 3]
		 * 3:[1, 2, 3, 4, 5, 6]
		 */
	}

	/**
	 * 快速排序：
	 * ①以第一个关键字 K1 为控制字，将 [K1 ,K2 ,…,Kn ] 分成两个子区，
	 * 使左区所有关键字小于等于 K1 ，右区所有关键字大于等于 K1 ，最后控制字居两个子区中间的适当位置。
	 * 在子区内数据尚处于无序状态。
	 * ②把左区作为一个整体，用①的步骤进行处理，右区进行相同的处理。（即递归）
	 * ③重复第①、②步，直到左区处理完毕。
	 * 
	 * @param array
	 */
	public static void quickSort(final int[] array) {
		if (array.length > 0) { // 查看数组是否为空
			System.out.println("快速排序开始：\n" + Arrays.toString(array) + "\n");
			quickSort(array, 0, array.length - 1);
			System.out.println("快速排序结束：\n" + Arrays.toString(array));
		}
	}

	private static void quickSort(final int[] array, final int low, final int high) {
		if (low < high) {

			final int middle = getMiddle(array, low, high); // 将list数组进行一分为二

			quickSort(array, low, middle - 1); // 对低字表进行递归排序

			quickSort(array, middle + 1, high); // 对高字表进行递归排序
		}
	}

	private static int getMiddle(final int[] array, int low, int high) {
		final int temp = array[low]; // 数组的第一个作为中轴
		while (low < high) {
			while (low < high && array[high] >= temp) {
				high--;
			}
			array[low] = array[high]; // 比中轴小的记录移到低端
			while (low < high && array[low] <= temp) {
				low++;
			}
			array[high] = array[low]; // 比中轴大的记录移到高端
		}
		array[low] = temp; // 中轴记录到尾
		return low; // 返回中轴的位置
	}

}

2

3