冒泡排序详解

冒泡排序的实现:

/**
	功能：数组排序（无序数组-----有序数组）
	排序算法很多，冒泡排序，选择排序，插入排序，是三种最基本最简单的排序算法，效率最低
	技能：冒泡排序
	
	冒泡排序的算法
	 *  1.整个数列分成两部分：前面是无序数列，后面是有序数列
	 *  2.初始状态下，整个数列都是无序的，有序数列是空
	 *  3.如果一个数列有n个元素，则至多需要n-1趟循环才能保证数列有序
	 *  4.每一趟循环可以让无序数列中最大数排到最后，（也就是说有序数列的元素个数增加1）
	 *  5.每一趟循环都从数列的第一个元素开始进行比较，依次比较相邻的两个元素，比较到无序数列的末尾即可（而不是数列的末尾）
	 *  6.如果前一个大于后一个，交换

*/
public class TestBubbleSort{
	public static void main(String [] args){
		//定义一个无序数组
		int [] scoreArr = {75,87,56,45,89,100,76,34,89,97};	
		
		//排序前输出
		System.out.println("排序前");
		for(int score :scoreArr){
			System.out.print(score+"\t");
		}
		//排序
		//大循环：n个元素排序，则至多需要n-1趟循环
		for(int i=0;i<scoreArr.length-1;i++){
			//小循环：每一趟循环都从数列的前两个元素开始进行比较，比较到数组的最后
			for(int j=0;j<scoreArr.length-1;j++){
				//如果前一个大于后一个
				if(scoreArr[j] > scoreArr[j+1]){
					//交换
					int temp;
					temp = scoreArr[j];
					scoreArr[j] = scoreArr[j+1];
					scoreArr[j+1] = temp;
				}
			}
		}
		//排序后输出
		System.out.println("排序后");
		for(int score :scoreArr){
			System.out.print(score+"\t");
		}
	}
}

/**
	功能：数组排序（无序数组-----有序数组）
	排序算法很多，冒泡排序，选择排序，插入排序，是三种最基本最简单的排序算法，效率最低
	技能：冒泡排序
	
	冒泡排序的算法
	 *  1.整个数列分成两部分：前面是无序数列，后面是有序数列
	 *  2.初始状态下，整个数列都是无序的，有序数列是空
	 *  3.如果一个数列有n个元素，则至多需要n-1趟循环才能保证数列有序
	 *  4.每一趟循环可以让无序数列中最大数排到最后，（也就是说有序数列的元素个数增加1）
	 *  5.每一趟循环都从数列的第一个元素开始进行比较，依次比较相邻的两个元素，比较到无序数列的末尾即可（而不是数列的末尾）
	 *  6.如果前一个大于后一个，交换
	 
	 缺点1：每一趟比较都要比较到数组的最后，没有必要，只要比较到无序数列的最后即可
		for(int j=0;j<scoreArr.length-1;j++){	}
		i      j<?
		0      <6
		1      <5
		2      <4
		3      <3
		
		i      j<6-i scoreArr.length-1-i
	 
		解决：j<scoreArr.length-1 修改为 j<scoreArr.length-1-i
	 
	 缺点2：不管是否有序，都要进行n-1趟循环
	  如何判断有序：比较了一趟，没有发生交换
	 解决：定义一个符号量flag，默认有序true；发生交换，置为false，
	 一趟循环结束后，根据flag的值判断是否有序；有序，退出即可
	 
	 缺点3：int temp;每次比较的时候都要给temp分配空间，比较完毕后释放空间；
	 解决：所有的比较都使用都一个temp变量，同一个空间；
	 将temp变量提取到大循环外

*/
public class TestBubbleSort2{
	public static void main(String [] args){
		//定义一个无序数组
		//int [] scoreArr = {75,87,56,45,89,100,76,34,89,97};	
		int [] scoreArr = {1,2,3,4,5,6,7};	
		//排序前输出
		System.out.println("排序前");
		for(int score :scoreArr){
			System.out.print(score+"\t");
		}
	
		//排序
		//大循环：n个元素排序，则至多需要n-1趟循环
		int temp;
		int i;
		for(i=0;i<scoreArr.length-1;i++){	
			//1. 假设有序
			boolean flag = true;
			//2.小循环：每一趟循环都从数列的前两个元素开始进行比较，比较到数组的最后
			for(int j=0;j<scoreArr.length-1-i;j++){			
				//如果前一个大于后一个
				if(scoreArr[j] > scoreArr[j+1]){
					//交换					
					temp = scoreArr[j];
					scoreArr[j] = scoreArr[j+1];
					scoreArr[j+1] = temp;
					//发生了交换，数组无序
					flag = false;
				}
			}
			//3.判断是否有序，有序，退出
			if(flag){
				break;
			}			
		}
		//排序后输出
		System.out.println("排序后");
		for(int score :scoreArr){
			System.out.print(score+"\t");
		}
		System.out.println("\n一共进行了"+(i+1)+"趟循环");
	}
}

冒泡排序的分析：
空间效率：仅使用一个辅存单元。
时间效率：假设待排序的元素个数为 n，则总共要进行 n-1 趟排序，对 j 个元素的子序
列进行一趟起泡排序需要进行 j-1 次关键字比较。由此，起泡排序的总比较次数为

因此，起泡排序的时间复杂度为Ο(n^2)。
稳定性：稳定