经典排序算法1（冒泡排序）

本人初学java，顺便学习算法与数据结构，为了巩固我的学习同时也为了给初学者一个学习算法的信心，我试着写了下我的学习收获与心得！

先介绍三种实现比较简单的排序算法：

1：冒泡排序（Bubble Sort）：

a：算法原理：冒泡算法是基于比较与交换的排序算法，所以不难想象出需要两层循环来实现，外层循环负责每趟选出最大的数并将其放冒泡到数组末尾，内层循环则负责每次比较相邻两数的大小，将较大的数往后移。所以外层最终要进行n-1（n为数组长度）趟排序，那么循环的外层应该是：for(int i=0;i<array.length-1;i++)。由于外层每趟将最大数的数放置在了数组的末尾，所以内层循环每一次比较的数会比上一次少一个，所以内层循环是动态的，我们可以这么写：for(int j=0;j<array.length-1-i;j++)。

b：算法示图：

int[] array={5 7 8 3 6 1};

外层第一趟排序后：5  7  8  3  6  1     //内层第一趟比较，5<7，无需交换

                                5  7  8  3  6  1     //内层第二趟比较，7<8，无需交换

                                5  7  3  8  6  1     //内层第三趟比较，8>3，交换

                                5  7  3  6  8  1     //内层第四趟比较，8>6，交换

                                5  7  3  6  1  8    //内层第五趟比较，8>1，交换

经过外层一趟的比较，最大数8被冒泡到了最后）

-------------------------------------------------------------------------------------------

外层第二趟排序后：5  7  3  6  1  8     //内层第一趟比较，5<7无需交换

                                5  3  7  6  1  8     //内层第二趟比较，7>3交换

                                5  3  6  7  1  8     //内层第三趟比较，7>6交换

                                5  3  6  1  7  8     //内层第四趟比较，7>1交换

-----------------------------------------------------------------------------------------

外层第三趟排序后：3  5  6  1  7  8     //内层第一趟比较，5>3交换

                                3  5  6  1  7  8     //内层第二趟比较，5<6无需交换

                                3  5  1  6  7  8     //内层第三趟比较，6>1交换

----------------------------------------------------------------------------------------

外层第四趟排序后：3  5  1  6  7  8     //内层第一趟比较，3<5无需交换

                                3  1  5  6  7  8     //内层第二趟比较，5>1交换

-----------------------------------------------------------------------------------------

外层第五趟排序后：1  3  5  6  7  8     //内层第一趟比较，3>1交换

c:代码实现（java）：

public static void sort(int[]a){
	for(int i=0;i<a.length-1;i++)
		for(int j=0;j<a.length-i-1;j++){
			if(a[j]>a[j+1]){
				int temp=a[j+1];
				a[j+1]=a[j];
				a[j]=temp;
			}	
		}
}

 

d:算法优化：当我们传入的数组一开始就是有顺序时那我们我们遇到了最好的情况，也就是当我们遍历一次后没有执行交换，这是我们可以通过给程序加入一个boolean类型的变量来判断是否交换发生了，如果没有交换就直接退出！

优化好的代码如下：

public static void sort(int[]a){
		boolean judge=true;
		for(int i=0;i<a.length-1;i++)
			if(judge=true){  //如果遍历一次没有发生交换就直接退出
				judge=false;
				for(int j=0;j<a.length-i-1;j++){
					if(a[j]>a[j+1]){
						judge=true;
						int temp=a[j+1];
						a[j+1]=a[j];
						a[j]=temp;
					}	
				}
			}else{
				break;
			}
		}
	}