排序与算法--冒泡排序

1.原理

比较两个相邻的元素，将较大的值交换到右边

2.举例：2 8 7 5 9 4 3?

第一趟：

? ? ? ? 第一次：比较第一个和第二个：2 8 ，不需要交换

? ? ? ? 第二次：比较 8 7，将8和7进行交换：2 7 8? 5 9 4 3

? ? ? ? 第三次：比较 8 5，将8和5进行交换：2 7 5 8 9 4 3

? ? ? ? 第四次：比较 8 9，不需要交换

? ? ? ? 第五次：比较 9 4，将9和4进行交换：2 4 5 8 4 9 3

? ? ? ? 第六次：比较 9 3，需要交换 2 7 5 8 4 3 9

第一趟结束后，最大的数字出现在最后一位

第二趟

? ? ? ? 第一次：比较 2 7，不需要交换

? ? ? ? 第二次：比较 7 5，需要交换：2 5 7 8 4 3 9

? ? ? ? 第三次：比较 5 8，不需要交换

? ? ? ? 第四次：比较 8 4 ，需要交换：2 5 7 4 8 3 9

? ? ? ? 第五次：比较 8 3 ，需要交换：2 5 7 4 3 8 9

第二趟结束后，第二大的数字出现在倒数第二位

第三趟

? ? ? ? 第一次：比较 2 5?，不需要交换

? ? ? ? 第二次：比较 5 7，不需要交换

? ? ? ? 第三次：比较 7 4，需要交换：2 5 4 7 3 8 9

? ? ? ? 第四次：比较 7 3，需要交换：2 5 4 3 7 8 9

以此类推：

第四趟：2 4 3 5 7 8 9 第五趟：2 3 4 5 7 8 9 直到排序完成

简化：第一趟跑完，最大的数字在最后一位，不用参与排序

第二趟，第二大的数字在倒数第二位，不用参与排序

每跑完一趟，就可以少跑一次。

3.题目

排序：【10,1,35,61,89,36,55】

4.代码

package 排序;

public class 冒泡排序 {
	public static void main(String[] args) {
		//外层for循环控制趟，内层控制次
		int a[]= {10,1,35,61,89,36,55};
		//为什么趟的次数可以确定？
		//因为每一趟都可以确定一个数字的位置
		for(int i=0;i<a.length-1;i++) {
			for(int j=0;j<a.length-1-i;j++) {
				if(a[j]>a[j+1]) {
					//左边大于右边
					int k=a[j];
					a[j]=a[j+1];
					a[j+1]=k;
				}
			}
		}
		for(int i=0;i<a.length;i++) {
			System.out.print(a[i]+" ");
		}	
	}
}

5.结果截图

6.注意点

（1）双层循环：外层控制趟，内层控制次

（2）每跑完一趟，就可以少跑一次。j <a.length-1- i