分步图解分析排序方法-冒泡排序

冒泡排序

基本介绍

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

下面是一个冒泡过程得例子，大家看不懂的可以先往后看，了解了冒泡的原理之后再回过来看就会一目了然。

过程详解

我们举一个具体的案例来说明冒泡法：将五个无序的数3, 9, -1, 10, -2 使用冒泡排序法将其排成一个从小到大的有序数列。接下里我们将整个国政分解出来进行分析，首先我们进行第一躺排序过程：红色箭头代表需要比较的索引，在第一趟的第一次排序中，红色箭头分别指向第一个元素和第二个元素，比较两者的大小，发现3是小于9的，所以不需要交换，则第一躺排序的第一次比较以后，数组的元素顺序如下图：

接下来红色箭头需要往后移动一位，继续上面的步骤比较两个箭头指向的元素，如果前者大于后者则交换否则不需要交换，完成以后如下如所示：

以同样的逻辑继续操作，我这里直接给出操作的图，大家对照着看就可以看明白：


第一趟经过四次比较元素中最大的元素就会在最后出现。进行第二趟比较的时候整个最大值就可以不用参与比较，因为它是所有元素中最大的元素，放在最后属于已经排好了序。同样按照同样的逻辑，进行第二趟的排序，我这里直接给出第二趟结束时候的图，相信大家有了上面的推导过程应该很快就能看懂：

然后进行第三趟比较：

进行第四趟比较：

代码实现

这样经过四趟比较最终元素变的有序，我们接下来看一下规律。数组中一共有5个元素，最终我们进行了4趟趟，假设元素个数为n，那就需要进行n-1趟比较，然后在每一趟中，第一趟需要比较4次，第二趟需要比较3次，第三趟需要2次，第四趟只需要比较一次，所以每趟需要比较的次数是总元素减1再减去已经确定的元素的个数。可能这样描述大家有的不太明白，接下里我们用代码来给大家作进一步的解析。同样我们采用分步的形式给大家进行分析。
首先进行第一趟排序比较：

      for (int j = 0; j < arr.length - 1 ; j++) {
			// 如果前面的数比后面的数大，则交换
			if (arr[j] > arr[j + 1]) {
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
		//完事打印出来看看数组此时的顺序
		System.out.println("第一趟排序后的数组：");
		System.out.println(Arrays.toString(arr));

执行以后看到最大的数已经在最后一个了，与我们前面分析的结果一致：

然后进行第二趟排序比较，需要剔除排在倒数第二位：

      for (int j = 0; j < arr.length - 1 - 1 ; j++) {
			// 如果前面的数比后面的数大，则交换
			if (arr[j] > arr[j + 1]) {
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
		//完事打印出来看看数组此时的顺序
		System.out.println("第二趟排序后的数组：");
		System.out.println(Arrays.toString(arr));

然后进行第三趟排序比较，需要剔除排在倒数第三位：

      for (int j = 0; j < arr.length - 1 - 2 ; j++) {
			// 如果前面的数比后面的数大，则交换
			if (arr[j] > arr[j + 1]) {
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
		//完事打印出来看看数组此时的顺序
		System.out.println("第三趟排序后的数组：");
		System.out.println(Arrays.toString(arr));

然后进行第四趟排序比较，需要剔除排在倒数第四位：

      for (int j = 0; j < arr.length - 1 - 3 ; j++) {
			// 如果前面的数比后面的数大，则交换
			if (arr[j] > arr[j + 1]) {
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
		//完事打印出来看看数组此时的顺序
		System.out.println("第四趟排序后的数组：");
		System.out.println(Arrays.toString(arr));

我们把接下来的几步一起输出：

可以看到每一次展示的结果都如我们上面的分析，至此，分步分析已经分析完成，接下来我们就可以直接将这个方法封装起来：

public static void bubbleSort(int[] arr) {
		int temp = 0; // 临时变量
		for (int i = 0; i < arr.length - 1; i++) {
			for (int j = 0; j < arr.length - 1 - i; j++) {
				// 如果前面的数比后面的数大，则交换
				if (arr[j] > arr[j + 1]) {
					temp = arr[j];
					arr[j] = arr[j + 1];
					arr[j + 1] = temp;
				}
			}
		}
	}

那么大家接下来想一想，还有没有可以优化的地方呢？假设有这样的一个场景，在某一趟的排序中，假设排完一次以后此时已经是需要输出的从小打到大的顺序了，如5，1，2，3，4，一次以后为1，2，3，4，5，如果用以上的方式，即使是已经是从小到大的顺序，依然需要进行接下来的三次比较，显示是浪费了时间，那么可以怎么解决呢？我们可以加一个标识变量，表示是否进行过交换，将它的状态放在比较代码里进行改变，然后依据它的状态判断是否需要及逆行下一次的比较，大家可以直接看代码：

public static void bubbleSort(int[] arr) {
		int temp = 0; // 临时变量
		boolean flag = false; // 标识变量，表示是否进行过交换
		for (int i = 0; i < arr.length - 1; i++) {
			for (int j = 0; j < arr.length - 1 - i; j++) {
				// 如果前面的数比后面的数大，则交换
				if (arr[j] > arr[j + 1]) {
					flag = true;
					temp = arr[j];
					arr[j] = arr[j + 1];
					arr[j + 1] = temp;
				}
			}
			if (!flag) { // 在一趟排序中，一次交换都没有发生过
				break;
			} else {
				flag = false; // 重置flag!!!, 进行下次判断
			}
		}
	}

我们来看一下优化前后的比较结果（执行比较的次数）：


可以看到，没有优化前需要比较4次，优化以后只需要比较2次，这里只是数据比较少的情况，当数据量比较大的时候，可以得到很大的性能提升。看到这里，大家可以回头看看文章开头给出的例子，大家是不是一目了然了呢?
本次要总结的内容是排序算法，后面还有其他经典的排序算法，大家可以持续关注。