冒泡排序

算法思想

冒泡排序通过不断地比较两个相邻的元素，将较大的元素交换到右边(升序),从而实现排序。

代码

不考虑优化的实现方式

public static void bubbleSort(int[] array){
	for(int i=0;i<array.length-1;i++)
	{
		for(int j=0;j<array.length-i-1;j++)
		{
			int tmp=0;
			if(array[j]>array[j+1]){  //从小到大
				tmp=array[j];
				array[j]=array[j+1];
				array[j+1]=tmp;
			}
		}
	}
}

一次优化的实现方式

判断出数列是否已经有序，并做出标记，那么剩下的几轮排序就不必执行了，可以提前结束工作

public static void bubbleSort(int[] array){	
   
	for(int i=0;i<array.length-1;i++)
	{	
		//有序标记，每一轮的初始值都是true
		boolean isSorted=true;
		for(int j=0;j<array.length-i-1;j++)
		{
			int tmp=0;
			if(array[j]>array[j+1]){
				tmp=array[j];
				array[j]=array[j+1];
				array[j+1]=tmp;
				//因为有元素交换，所以不是有序的，标记变为false
				isSorted=false;
			}
		}
		if(isSorted)
			break;
	}
}

二次优化的实现方式

在每一轮排序后，记录下来最后一次元素交换的位置，该位置即为无序数列的边界，再往后就是有序区。

public static void bubbleSort(int array[]){
	//记录最后一次交换的位置
	int lastExchangeIndex=0;
	//无序数组的边界，每次比较只需要比到这里为止
	int sortBorder=array.length-1;
	for(int i=0;i<array.length-1;i++){
		//有序标记，每一轮的初始值都是true
		boolean isSorted=true;
		for(int j=0;j<sortBorder;j++){
		   int tmp=0;
		   if(array[j]>array[j+1]){
			   tmp=array[j];
			   array[j]=array[j+1];
			   array[j+1]=tmp;
			   //因为有元素进行交换，所以不是有序的，标记变为false
			   isSorted=false;
			   //更新为最后一次交换元素的位置
			   lastExchangeIndex=j;
		   }
		}
		SortBorder=lastExchangeIndex;
		if(isSorted)
			break;
	}
}

复杂度分析

时间复杂度：

• 最佳情况：o(n)
• 最佳情况：o(n²)
• 平均情况：o(n²)

空间复杂度：没有使用额外的空间，空间复杂度为o(1),是典型的原地排序算法(In-place Sorting Algorithm)

稳定性分析

冒泡排序是稳定的，原因在于冒泡排序比较和交换的是两个相邻的元素，对于键值相同的关键字是不交换位置的，所以排序前后键值相同的关键字的相对位置才保持不变的。