java实现冒泡、选择、快速排序算法

冒泡排序（Bubble Sort）是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

选择排序(Selection sort)是一种简单直观的排序算法。它的工作原理如下。首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

快速排序（Quicksort）是对冒泡排序的一种改进。由C. A. R. Hoare在1962年提出。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

注：详细的排序算法可以参考wiki；

下面给出三种排序算法的具体实现：

package com.xjtu.cruise;

public class Sort {

	/**
	 * 冒泡排序
	 * 
	 * @param data
	 *            目标数组
	 */
	public static void bubbleSort(int[] data) {

		for (int i = 0; i < data.length - 1; i++) {// 控制趟数
			for (int j = 0; j < data.length - i - 1; j++) {

				if (data[j] > data[j + 1]) {
					int tmp = data[j];
					data[j] = data[j + 1];
					data[j + 1] = tmp;
				}
			}
		}

	}

	/**
	 * 选择排序
	 * 
	 * @param data
	 *            目标数组
	 */
	public static void selectSort(int[] data) {
		if (data == null || data.length == 0) {
			return;
		}

		for (int i = 0; i < data.length - 1; i++) {
			int min = i;// 将当前下标定为最小值下标
			for (int j = i + 1; j < data.length; j++) {
				if (data[j] < data[min]) {
					min = j;
				}
			}

			if (i != min) {
				int tmp = data[i];
				data[i] = data[min];
				data[min] = tmp;
			}
		}
	}

	/**
	 * 选择排序 此算法效率不如上面的高
	 * 
	 * @param sort
	 */
	public static void selectSort2(int[] data) {

		for (int i = 0; i < data.length - 1; i++) {
			for (int j = i + 1; j < data.length; j++) {
				if (data[j] < data[i]) {
					int temp = data[j];
					data[j] = data[i];
					data[i] = temp;
				}
			}
		}
	}

	/**
	 * 快速排序算法
	 * 
	 * @param data
	 *            目标数组
	 * @param start
	 *            起始位
	 * @param end
	 *            结束位
	 */
	public static void quickSort(int[] data, int start, int end) {
		// 设置关键数据key为要排序数组的第一个元素，
		// 即第一趟排序后，key右边的数全部比key大，key左边的数全部比key小
		int key = data[start];
		// 设置数组左边的索引，往右移动比key大的数
		int i = start;
		// 设置数组右边的索引，往左移动比key小的数
		int j = end;
		// 如果左边索引比右边索引小，则还有数据没有排序
		while (i < j) {
			while (data[j] > key && j > i) {
				j--;
			}
			data[i] = data[j];

			while (data[i] < key && i < j) {
				i++;
			}
			data[j] = data[i];
		}
		// 此时 i==j
		data[i] = key;

		// 递归调用
		if (i - 1 > start) {
			// 递归调用，把key前面的完成排序
			quickSort(data, start, i - 1);
		}
		if (i + 1 < end) {
			// 递归调用，把key后面的完成排序
			quickSort(data, i + 1, end);
		}
	}

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		int[] p = { 34, 21, 54, 18, 23, 76, 38, 98, 45, 33, 27, 51, 11, 20, 79,
				30, 89, 41 };

		long start = System.currentTimeMillis();

//		Sort.bubbleSort(p);// 冒泡排序
//		Sort.selectSort(p);// 选择排序
//		Sort.selectSort2(p);// 选择排序2
		Sort.quickSort(p, 0, p.length - 1);// 快速排序

		System.out.println("所用时间：" + (System.currentTimeMillis() - start));
		for (int i = 0; i < p.length; i++) {
			System.out.print(p[i] + " ");
		}
	}

}