冒泡排序 java

冒泡排序

先说一下这个算法优缺点
优点：简单，稳定排序，遍历次数可优化
缺点：交换数组元素的操作次数过多

这里用比较直观的栈，演示从栈底冒泡，排在栈顶的排序方法
我用一个特殊的例子，倒序数组来了解每一步算法的执行
{ 9, 8, 7, 6, 5, 4, 3, 2, 1, 0}

图示

上图演示了 i = 0，第一次循环。利用循环 j 把栈底元素“0”排到栈顶的过程。数组变成 0 9 8 7 6 5 4 3 2 1；

其中，黄色框表示 具体对比范围，总是 j 指向的元素值跟上一个元素值 j - 1 比对

			if(arr[j] < arr[j-1])

紫色线段表示 “0”和上一个元素交换后它的位置，多个这样的过程由 j 控制的最终将“0”移到栈顶 当然是因为它在数组中最小才被移到栈顶

				int temp = arr[j];
				arr[j] = arr[j-1];
				arr[j-1] = temp;

i 的取值理解为栈顶有 i 个被排好序的元素
i ------------> 0 1 2 3 4 5 6 7 8 9
j ------------> 9 9 9 9 9 9 9 9 9
j ------------> 8 8 8 8 8 8 8 8
j ------------> 7 7 7 7 7 7 7
j ------------> 6 6 6 6 6 6
j ------------> 5 5 5 5 5
j ------------> 4 4 4 4
j ------------> 3 3 3
j ------------> 2 2
j ------------> 1
j ------------> 9 8 7 6 5 4 3 2 1 j 的循环次数竖着看

j 的语句循环 j 次，意思是把栈底元素移动 j 次，正好放在栈顶位置
用文中的倒序特殊例子理解

i = 9 时，说明9个元素已被排在正确位置，总共10个元素的数组也就排序完毕，不用再遍历了。

每次都把栈中最小的元素排好了，之后视作只需处理除了栈顶元素剩下元素，所以只需要执行 j - 1 次
用 j > i 控制循环条件 这里比较难理解 理解这条语句这个算法就通了

		for(int j = arr.length - 1; j > i; j --)

代码

public static void main(String[] args){
		
	int arr[] = { 9,8,7,6,5,4,3,2,1,0 };
//                0 1 2 3 4 5 6 7 8 9 长度为10
	boolean flag = true;

	for(int i = 0; i < arr.length - 1 && flag; i ++){
	//i跑9次
		for(int j = arr.length - 1; j > i; j --){
		//j下面的语句分别跑9,8,7,6,5,4,3,2,1次
		//每跑一次把一个最小的数排到栈头(45次)
			flag = false;
			//如果没发生交换说明已经排好跳出循环提升效率
			if(arr[j] < arr[j-1]){
				flag = true;
				int temp = arr[j];
				arr[j] = arr[j-1];
				arr[j-1] = temp;
			}
		}
	}
		
	for(int i = 0; i < arr.length; i ++)
		System.out.print( arr[i] + " " );
}	

用 flag 变量优化算法
若 flag = false 表示没有元素可以互换了，意味着数组已经排好，这时跳出 i 控制的循环，节省时间。