冒泡排序（鸡尾酒排序）的Java实现

冒泡排序

• 基本思想：
  两两比较相邻记录的关键字，如果反序则交换，直到没有反序的记录为止。

• 算法步骤：
  （1）从数组中第一个数开始，依次与下一个数比较并次交换比自己小的数，直到最后一个数。如果发生交换，则继续下面的步骤，如果未发生交换，则数组有序，排序结束，此时时间复杂度为O(n)；
  （2）每一轮“冒泡”结束后，最大的数将出现在乱序数列的最后一位。重复步骤（1）。

• 时间复杂度：
  O(n)至O(n2)，平均时间复杂度为O(n2)。
  最好的情况：如果待排序数据序列为正序，则一趟冒泡就可完成排序，排序码的比较次数为n-1次，且没有移动，时间复杂度为O(n)。
  最坏的情况：如果待排序数据序列为逆序，则冒泡排序需要n-1次趟起泡，每趟进行n-i次排序码的比较和移动，即比较和移动次数均达到最大值：
  比较次数:Cmax=∑i=1n−1(n−i)=n(n−1)/2=O(n2)
  移动次数等于比较次数，因此最坏时间复杂度为O(n2)。

代码实现：

public class BubbleSort {
	public static void main(String[] args) {	
		System.out.println("=============第一版本==============");
		int[] arr ={11,95,45,15,51,12,24};
		sort1(arr);
		
		System.out.println("=============第二版本==============");
		arr = new int[]{11,95,45,15,51,12,24};
		sort2(arr);
		
		System.out.println("=============鸡尾酒排序==============");
		arr = new int[]{11,95,45,15,51,12,24};
		sort3(arr);
	}
	//第三版本，鸡尾酒排序算法
	public static void sort3(int[] arr){
		boolean sorted1 = true;
		boolean sorted2 = true;
		int len = arr.length;
		for(int j=0; j<len/2; j++){ //趟数
			sorted1 = true; //假定有序
			sorted2 = true; 
			for(int i=0; i<len-1-j; i++){ //次数
				if(arr[i] > arr[i+1]){
					int temp = arr[i];
					arr[i] = arr[i+1];
					arr[i+1] = temp;
					sorted1 = false; //假定失败
				}
			}
			for(int i=len-1-j; i>j; i--){ //次数
				if(arr[i] < arr[i-1]){
					int temp = arr[i];
					arr[i] = arr[i+1];
					arr[i+1] = temp;
					sorted2 =false; //假定失败
				}
			}
			System.out.println(Arrays.toString(arr));
			if(sorted1 && sorted2){ //减少趟数，已有序则结束
				break;
			}
		}
	}
	//第二版本，减少每一趟的次数
	public static void sort2(int[] arr){
		boolean sorted= true;
		int len =arr.length;
		for(int j=0;j<len-1;j++){ //趟数
			sorted =true; //假定有序
			for(int i=0;i<len-1-j;i++){ //次数
				if(arr[i]>arr[i+1]){
					int temp = arr[i];
					arr[i] = arr[i+1];
					arr[i+1] = temp;
					sorted =false; //假定失败
				}
			}
			System.out.println(Arrays.toString(arr));
			if(sorted){ //减少趟数
				break;
			}
		}
	}
	//第一版本，简单的实现冒泡排序
	public static void sort1(int[] arr){
		int len =arr.length;
		for(int j=0;j<len-1;j++){ //趟数
			System.out.println("第"+(j+1)+"趟");
			for(int i=0;i<len-1-j;i++){ //次数
				System.out.print("第"+(i+1)+"次");
				if(arr[i]>arr[i+1]){
					int temp = arr[i];
					arr[i] = arr[i+1];
					arr[i+1] = temp;
				}
				System.out.println(Arrays.toString(arr));
			}
		}
	}
}

执行结果如下：


由第一版本的执行结果可以看出，排序在第四次执行完就已经有序，但是依然会执行第五次和第六次的排序。我们对此进行优化，加入一个标志位，在每趟排序执行前都假定当下数据已经排序完成，在每趟的执行过程中，如果进行了数据的交换，则标志位置为false，如果该趟排序没有进行数据的交换，则结束执行。
以上是简单的冒泡排序，在冒泡排序的基础上，我们再次进行优化，衍生出了鸡尾酒排序算法（定向冒泡排序），以上代码的第三个版本为鸡尾酒排序的实现。

鸡尾酒排序

• 鸡尾酒排序算法
  基本思想：数组中的数字本是无规律的排放，先找到最小的数字，把他放到第一位，然后找到最大的数字放到最后一位。然后再找到第二小的数字放到第二位，再找到第二大的数字放到倒数第二位。以此类推，直到完成排序。
  鸡尾酒排序的时间复杂度与冒泡排序相同。

• 鸡尾酒排序与冒泡排序的区别
  鸡尾酒排序等于是冒泡排序的轻微变形。不同的地方在于从低到高然后从高到低，而冒泡排序则仅从低到高去比较序列里的每个元素。他可以得到比冒泡排序稍微好一点的效能，原因是冒泡排序只从一个方向进行比对(由低到高)，每次循环只移动一个项目。
  以序列(2,3,4,5,1)为例，鸡尾酒排序只需要访问两次（升序降序各一次 ）次序列就可以完成排序，但如果使用冒泡排序则需要四次。