Java排序算法之——冒泡排序，插入排序，选择排序

<1>冒泡排序
这个名词的还是很形象的，就是每次比较相邻的两个数，大的数总是往后面冒，所以每轮比较结束后，大数都会冒到最后面。
每次比较的结果如下：
无序数组  ：8 2 4 3 5 7 1 9 6 （后面所有的排序都将使用这个数组）
第一轮比较：2 4 3 5 7 1 8 6 9 
第二轮。。：2 3 4 5 1 7 6 8 9
第三轮。。：2 3 4 5 1 6 7 8 9 
第四轮。。：2 3 4 1 5 6 7 8 9 
第五轮。。：2 3 1 4 5 6 7 8 9 
第六轮。。：2 1 3 4 5 6 7 8 9 
第七轮。。：1 2 3 4 5 6 7 8 9 
我们用程序来描述这种变化：

/**
	 * 冒泡排序，默认为从小到大排序
	 * @param array 需要排序的数组
	 */
	public static void bubbleSort(int[] array) {
		int length = array.length;
		for (int i = 1; i < length; i++) {//外层循环表示每一轮的比较,为了便于理解我们将i初始化为1,表示从第一轮开始，也能避免内层循环的下标越界
			for (int j = 0; j < length-i; j++) {//内层循环表示相邻的两个数比较,我们同数组下标一样,从0开始
				if (array[j] > array[j+1]) {
					int temp = array[j];
					array[j] = array[j+1];
					array[j+1] = temp;
				}
			}
		}
	}

如果是递减排序：

/**
	 * 冒泡排序
	 * @param array 需要排序的数组
	 * @param pattern 当参数不为空的时候，表示递减排序
	 */
	public static void bubbleSort(int[] array, String pattern) {
		if (StringHelper.isEmpty(pattern)) {//isEmpty()这是我自己写的一个工具类,用于判断字符串是否为null或者空
			bubbleSort(array);//当pattern 为空或者为null时候递增排序
			return;
		}
		int length = array.length;
		for (int i = 1; i < length; i++) {
			for (int j = 0; j < length-i; j++) {
				if (array[j] < array[j+1]) {//递减排序的话,那就让小的往后面冒就行了
					int temp = array[j];
					array[j] = array[j+1];
					array[j+1] = temp;
				}
			}
		}
	}

<2>插入排序
插入排序个人认为是很好理解的一种算法，实现的话也比较简单。
对于一个要排序的数组，我们将第一个数作为有序数组，然后后面的元素一次插入到这个有序数组中。
那么对于无序数组，他的元素就会分为已经插入的，和尚未插入的。
唯一不好理解的就是，用程序插入时候，移动元素怎么移动。
我们先看看数组每次的变化，我们还用上面的无序数组：
无序数组  ：8 2 4 3 5 7 1 9 6 
已插入数组：                        8 尚未插入元素：2 4 3 5 7 1 9 6 
已插入数组：                     2 8 尚未插入元素：4 3 5 7 1 9 6 
已插入数组：                  2 4 8 尚未插入元素：3 5 7 1 9 6 
已插入数组：               2 3 4 8 尚未插入元素：5 7 1 9 6 
已插入数组：            2 3 4 5 8 尚未插入元素：7 1 9 6 
已插入数组：         2 3 4 5 7 8 尚未插入元素：1 9 6 
已插入数组：      1 2 3 4 5 7 8 尚未插入元素：9 6 
已插入数组：   1 2 3 4 5 7 8 9 尚未插入元素：6 
已插入数组：1 2 3 4 5 6 7 8 9 尚未插入元素： 
我们用程序来描述这个插入过程：

/**
	 * 插入排序,默认递增排序
	 * @param array 要排序的数组
	 */
	public static void insertSort(int[] array) {
		int length = array.length;
		for (int i = 1; i < length; i ++) {//因为第一个我们默认为已经排序了的，所以我们从第二个开始插入，也就是下标为1
			int j = i;
			int temp = array[j];
			while (j > 0 && temp < array[j-1]) {
				array[j] = array[j-1];//我们这里不需要交换，找到要插入的位置，后面的元素整体后移就行了
				j--;
			}
			array[j] = temp;//插入到对应的位置
		}
	}

递减排序：

/**
	 * 插入排序
	 * @param array 待排序数组
	 * @param parttern 排序方式,值不为空时候表示递减排序
	 * @return 有序数组
	 */
	public static void insertSort(int [] array, String parttern) {
		if (StringHelper.isEmpty(parttern)) {
			insertSort(array);
			return;
		}

		int j = 0;
		for (int i = 1; i < array.length; i++) {
			j = i;
			int temp = array[i];//记录要插入的值
			while (j >0 && temp > array[j-1]) {
				array[j] = array[j-1];
				j--;
			}
			array[j] = temp;
			
		}
	}

<3>选择排序
交换排序的思路是每一轮选出较小元素然后交换。
第一轮交换的时候，找出剩余9个元素中最小的，和第一个交换；
第二轮交换的时候，找出剩余8个元素中修小的，和第二个交换；
...
这个和冒泡排序有点类似的，但是算法实现不一样。
我们先看交换排序的过程：
无序数组  ：8 2 4 3 5 7 1 9 6 
第一轮交换：1 2 4 3 5 7 8 9 6 (8和1交换 )
第二轮交换：1 2 4 3 5 7 8 9 6 (2不用交换)
第三轮交换：1 2 3 4 5 7 8 9 6 (4和3交换)
第四轮交换：1 2 3 4 5 7 8 9 6 (4不用交换)
第五轮交换：1 2 3 4 5 7 8 9 6 (5不用交换)
第六轮交换：1 2 4 3 5 6 8 9 7 (7和6交换)
第七轮交换：1 2 4 3 5 6 7 9 8 (8和7交换)
第八轮交换：1 2 4 3 5 6 7 8 9 (9和8交换)
我们看程序实现这种算法：

/**
	 * 选择排序,默认递增排序
	 * @param array 需要排序的数组
	 */
	public static void selectSort(int[] array) {
		int length = array.length;
		for (int i = 0; i < length; i++) {//外层控制选择次数
			int min = i;
			for (int j = i+1; j < length; j++) {//选择出最小元素的下标
				if (array[min] > array[j]) {
					min = j;
				}
			}
			if (i != min) {
				int temp = array[i];
				array[i] = array[min];
				array[min] = temp;
			}
		}
	}

递减排序：

/**
	 * 选择排序
	 * @param array 需要排序的数组
	 * @param pattern 当传值不为空时候,递减排序
	 */
	public static void selectSort(int[] array, String pattern) {
		if (StringHelper.isEmpty(pattern)) {
			selectSort(array);
			return;
		}
		int length = array.length;
		for (int i = 0; i < length; i++) {//外层控制选择次数
			int min = i;
			for (int j = i+1; j < length; j++) {//选择出最小元素的下标
				if (array[min] < array[j]) {
					min = j;
				}
			}
			if (i != min) {
				int temp = array[i];
				array[i] = array[min];
				array[min] = temp;
			}
		}
	}