数据结构与算法day16-冒泡排序算法

基本介绍：
	冒泡排序(Bubble Sorting)的基本思想是：通过对待排序序列从前
	向后(从下标较小的元素开始)，依次比较相邻元素的值，若发现
	逆序则交换，使值较大的元素逐渐从前移向后部，就像水底下
	的气泡一样逐渐向上冒。

	因为排序的过程中，各元素不断接近自己的位置，如果一趟比较下来没有
	进行过交换，就说明序列有序，因此要在排序过程中设置一个标志flag判断
	元素是否进行过交换。从而减少不必要的比较。

	小结冒泡排序规则：
		1.一共进行数组的size-1次循环
		2.每一次循环排序的次数逐渐减少
		3.如果在某次循环排序中，没发生数据的交换，
			则提前结束该循环中的冒泡(算法优化)

冒泡算法图解分析如下：
现以数组[8,7,6,4,5]为例，我们通过将这个数组按从小到大的方式排序，来说明冒泡排序的过程。
初始指针有2个，分别在下标0处和下标1处

第一次循环：此次循环的多次比较交换，使最大的数字8冒到最上面。

第二次循环：此次循环中的多次比较和交换，使7往上冒，最终排到倒数第二个位置。

你会发现，这次循环比前面少一次循环比较。

这是因为第一次循环时已经把最大的8排到最上面的位置了，这次排序肯定不会去占用最上面的位置的，所以此时比较次数可以比前面少一次。

第三次循环：同理，此时6会往上冒。比较次数同理又会比前面少一次。

此时看着最后的结果已经是从小到大了，这是因为在原始数组中，5就在4的上面。

但实际我们不知道5是在4的上面，我们就得继续完成最后一次循环比较。

第四次循环： 5已经排在4的上面了，比较后不交换。

代码实现如下：笨代码

package sort;

import java.util.Arrays;

public class BubbleSort {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[] array = {3, 9, -1, 10, -2};
		
		// 为了好理解，展示冒泡排序过程
		// 第1次循环排序，将最大的数排在最后
		int temp = 0; // 临时变量
		for (int j = 0; j < array.length-1-0; j++) {
			if (array[j] > array[j+1]) {// 如果前面的数比后面的数大，就交换位置
				temp = array[j];
				array[j] = array[j+1];
				array[j+1] = temp;
			}
		}
		System.out.println("第1次循环后的数组：");
		System.out.println(Arrays.toString(array));
		
		
		// 第2次循环排序，将第2大的数排在倒数第2位
		for (int j = 0; j < array.length-1-1; j++) {
			if (array[j] > array[j+1]) {// 如果前面的数比后面的数大，就交换位置
				temp = array[j];
				array[j] = array[j+1];
				array[j+1] = temp;
			}
		}
		System.out.println("第2次循环后的数组：");
		System.out.println(Arrays.toString(array));
		
		
		// 第3次循环排序，将第二大的数排在倒数第3位
		for (int j = 0; j < array.length-1-2; j++) {
			if (array[j] > array[j+1]) {// 如果前面的数比后面的数大，就交换位置
				temp = array[j];
				array[j] = array[j+1];
				array[j+1] = temp;
			}
		}
		System.out.println("第3次循环后的数组：");
		System.out.println(Arrays.toString(array));
		
		
		// 第4次循环排序，将第4大的数排在倒数第4位
		for (int j = 0; j < array.length-1-3; j++) {
			if (array[j] > array[j+1]) {// 如果前面的数比后面的数大，就交换位置
				temp = array[j];
				array[j] = array[j+1];
				array[j+1] = temp;
			}
		}
		System.out.println("第4次循环后的数组：");
		System.out.println(Arrays.toString(array));
	}

}

我们发现上述代码只有一个array.length-1-n处的n变化
精简后的代码如下：

package sort;

import java.util.Arrays;

public class BubbleSort {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[] array = {3, 9, -1, 10, -2};
		
		int temp = 0; // 临时变量
		for (int i = 0; i < array.length-1; i++) {
			for (int j = 0; j < array.length-1-i; j++) {
				if (array[j] > array[j+1]) {// 如果前面的数比后面的数大，就交换位置
					temp = array[j];
					array[j] = array[j+1];
					array[j+1] = temp;
				}
			}
			System.out.println("第"+(i+1)+"次循环后的数组：");
			System.out.println(Arrays.toString(array));
		}
		
	}
}

我们再次发现上述代码有些数已经是排序过的，可以优化代码提前结束
优化后的代码如下：

package sort;

import java.util.Arrays;

public class BubbleSort {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
//		int[] array = {3, 9, -1, 10, -2};
		int[] array = {1, 3, 4, 5, 7};
		
		int temp = 0; // 临时变量
		boolean flag = false; // 标识变量，表示是否进行过交换
		for (int i = 0; i < array.length-1; i++) {
			for (int j = 0; j < array.length-1-i; j++) {
				if (array[j] > array[j+1]) {// 如果前面的数比后面的数大，就交换位置
					flag = true;
					temp = array[j];
					array[j] = array[j+1];
					array[j+1] = temp;
				}
			}
			System.out.println("第"+(i+1)+"次循环后的数组：");
			System.out.println(Arrays.toString(array));
			
			if (!flag) {// 在一趟排序中，没发生过交换，则说明数据顺序完成，直接退出
				break;
			} else {// 如果交换过数据，则重置flag，进行下次判断
				flag = false;
			}
		}
		
	}
}

封装成方法的代码：并测试运行时间

package sort;

import java.util.Arrays;

public class BubbleSort {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		// 测试冒泡排序的速度
		// 测试一下冒泡排序的速度O(n^2)，给80000个数据
		// 创建要给80000个的随机的数组
		int [] array = new int[80000];
		for (int i = 0; i < 80000; i++) {
			// 生成[0, 80000)个随机数
			// 数越大分布约均匀
			array[i] = (int) (Math.random() * 80000);
		}
		
//		System.out.println("排序前的数组：");
//		System.out.println(Arrays.toString(array));
		
		long start = System.currentTimeMillis();
		
		// 测试冒泡排序
		bubbleSort(array);
		
		long end = System.currentTimeMillis();
		
		// 输出排序后的数组
//		System.out.println("排序后的数组：");
//		System.out.println(Arrays.toString(array));
		System.out.println("排序用时："+((end-start)/1000)+"秒");
	}
	
	// 将冒泡排序算法封装成一个方法
	public static void bubbleSort(int[] array) {
		int temp = 0; // 临时变量
		boolean flag = false; // 标识变量，表示是否进行过交换
		for (int i = 0; i < array.length-1; i++) {
			for (int j = 0; j < array.length-1-i; j++) {
				if (array[j] > array[j+1]) {// 如果前面的数比后面的数大，就交换位置
					flag = true;
					temp = array[j];
					array[j] = array[j+1];
					array[j+1] = temp;
				}
			}
			
			if (!flag) {// 在一趟排序中，一次交换都没发生过
				break;
			} else {// 重置flag，进行下次判断
				flag = false;
			}
		}
	}
}