10 冒泡排序

冒泡排序

1 概念

冒泡排序（Bubble Sort），是计算机科学领域中较简单的一种排序算法。
它重复地走访需要进行排序的元素，依次比较两个相邻的元素，如果元素的顺序（如从大到小、首字母从A到Z）错误就把元素的位置互换。
走访元素是重复进行的,直到没有任何相邻位置上的元素需要交换位置，排序完成。
这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”。
光看理论可能会有些迷糊,没有关系,接下来我们详细学习一下冒泡排序究竟是如何比较,又是如何排序的~

2 排序思路

先给大家放几张图，让大家感受下冒泡排序是怎么排序的：
比如我现在有一组乱序的数据：
11 9 13 6 8 5，希望通过冒泡排序后得到从小到大按顺序排列的数据
首先开始第1轮的第1次比较：11与9进行比较，11>9,所以互换位置：

这是11与9互换位置后的结果，红线标注的就是当前正在比较的两个数据：

第1轮的第2次比较：11与13进行比较，11<13,符合顺序，无需互换位置：

第1轮的第3次比较：6与13进行比较，13>6,不符合顺序，这是互换位置后的结果：

第1轮的第4次比较：8与13进行比较，13>8,不符合顺序，这是互换位置后的结果：

第1轮的第5次比较：5与13进行比较，13>5,不符合顺序，这是互换位置后的结果：
目前第一轮所有元素都参与了比较,结果：9 11 6 8 5 13
第2轮的第1次比较：9与11进行比较，9<11,符合顺序，无需互换位置：
第2轮的第2次比较：11与6进行比较，11>6,不符合顺序，这是互换位置后的结果：

第2轮的第3次比较：11与8进行比较，11>8,不符合顺序，这是互换位置后的结果：

第2轮的第4次比较：11与5进行比较，11>5,不符合顺序，这是互换位置后的结果：
第二轮结果：9 6 8 5 11 13
第3轮的第1次比较：9与6进行比较，9>6,不符合顺序，这是互换位置后的结果：
第3轮的第2次比较：9与8进行比较，9>8,不符合顺序，这是互换位置后的结果：

第3轮的第3次比较：9与5进行比较，9>5,不符合顺序，这是互换位置后的结果：
第三轮结果：6 8 5 9 11 13

第4轮的第1次比较：6与8进行比较，6<8,符合顺序，无需互换位置：

第4轮的第2次比较：5与8进行比较,8>5,不符合顺序，这是互换位置后的结果：
第四轮结果：6 5 8 9 11 13

第5轮的第1次比较：6与5进行比较,6>5,不符合顺序，这是互换位置后的结果：

第五轮结果：5 6 8 9 11 13,到目前为止,排序完成
那么大家可以思考这么几个问题:

1. 一共有几个元素参与比较?(6个)
2. 一共比较了几轮?(5轮)
3. 每一轮是怎么比较的?(相邻比较,顺序不对就互换)
4. 每轮的结果?(每轮都会确定一个最大的元素)
5. 有哪些相邻元素可以不参与比较?(之前轮确认的最大值)

3 实现冒泡排序

那如果通过编程,我们该怎么实现呢?
如下图:我们可以通过嵌套for循环来实现:
外层循环来控制比较的轮数:最大轮数=个数-1
内层循环来控制每轮比较的次数
在比较过程中,如果顺序不对,就互换元素的位置

创建类: BubbleSort.java

package cn.tedu.array;

import java.util.Arrays;

/**本类用来完成冒泡排序*/
public class TestBubbleSort {
	public static void main(String[] args) {
		//1.创建一个无序的数组
		int[] a = {27,96,73,25,21};
		//2.调用method()完成排序
		int[] newA = method(a);
		System.out.println("排序完毕:"+Arrays.toString(newA));
	}
	public static int[] method(int[] a) {
		//1.外层循环,控制比较的轮数,假设有n个数,最多比较n-1次
		//开始值:1 结束值:<= a.length-1 变化:++
		//控制的是循环执行的次数,比如5个数,最多比较4轮,<= a.length-1,最多取到4,也就是[1,4]4次
		for(int i = 1 ; i <= a.length-1 ; i++) {
			System.out.println("第"+i+"轮:");
			//2.内层循环:相邻比较+互换位置
			for(int j=0; j < a.length-i ; j++) {
				//相邻比较,a[j]代表的就是前一个元素,a[j+1]代表的就是后一个元素
				if(a[j] > a[j+1]) {
					//交换数据
					int t = a[j];
					a[j] = a[j+1];
					a[j+1] = t;
					//System.out.println("第"+(j+1)+"次比较交换后:"+Arrays.toString(a));
				}
			}
			System.out.println("第"+i+"轮的结果:"+Arrays.toString(a));
		}
		return a;//把排序好的数组a返回
	}
}

其实我们还可以对现有的排序做优化：
优化1：前面几轮排序产生的最大值不需要参与后几轮的比较，执行过几轮就会产生几个值不需要参与比较 , i 轮产生 i 个值,所以需要 - i

优化2：我们要设置一个量，这个量用来检测在当前这一轮的相互比较中究竟有没有发生元素的互换位置,如果发生了互换,说明顺序还没排好,flag就改成true,进行下一轮比较,但是如果在当前轮,所有元素都进行了相互比较,并没有互换位置,这就说明顺序已经排好序了,无需下一轮比较,直接return结束方法即可