java数据结构与算法之排序之冒泡排序

BubbleSorting.java(未优化)

package com.zhanglei.bubblesorting;

public class BubbleSorting {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[] a=new int[] {1,2,3,6,5,4};
		System.out.println("Before BubbleSorting:");
		for(int i=0;i<a.length;i++) {
			System.out.print(a[i]+" ");
		}
		System.out.println();
		int num=0;
		for(int i=0;i<a.length-1;i++) {//外循环决定要走多少趟,比如length个元素的数组要比较length-1趟
			num++;
			for(int j=0;j<a.length-1-i;j++) {//内循环决定每一趟的具体操作
				if(a[j]>a[j+1] ) {
					int temp=a[j];
					a[j]=a[j+1];
					a[j+1]=temp;
				}
			}
		}
		System.out.println("After BubbleSorting:");
		for(int i=0;i<a.length;i++) {
			System.out.print(a[i]+" ");
		}
		System.out.println();
		System.out.println("长度为"+a.length+"的数组"+"在没有优化时，外循环进行了"+num+"趟");
	}
}

运行结果：

Before BubbleSorting:
1 2 3 6 5 4 
After BubbleSorting:
1 2 3 4 5 6 
长度为6的数组在没有优化时，外循环进行了5趟

备注

1. 冒泡排序的原理就是先找到最大(或最小)值，然后再找到次大(或次小)值，以此类推
2. 外循环决定要走多少趟,比如length个元素的数组要比较length-1趟
3. 内循环决定每一趟的具体操作，比如逆序就互换位置
4. 趟的意思就是从左到右两两比较完一轮

BubbleSortingOptimized.java(已优化)

package com.zhanglei.bubblesorting;

public class BubbleSortingOptimized {

//	public static void main(String[] args) {
//		// TODO Auto-generated method stub
//		int[] a=new int[] {1,2,3,6,5,4};
//		//1st_round:1,2,3,5,4,6
//		//2nd_round:1,2,3,4,5,6
//		//3rd_round:1,2,3,4,5,6 此时没有进行位置变化，故后续的外循环进行break
//		int num=0;
//		boolean flag=false;//flag标志位用于对外循环进行break操作when内循环没有出现位置变动时
//		for(int i=0;i<a.length-1;i++) {//外循环决定要走多少趟,比如length个元素的数组要比较length-1趟
//			if(flag) {
//            	break;
//            }
//			num++;
//            int flag1=0;//flag1用于判断内循环是否出现位置变动
//			for(int j=0;j<a.length-1-i;j++) {//内循环决定每一趟的具体操作
//				if(a[j]>a[j+1] ) {
//					int temp=a[j];
//					a[j]=a[j+1];
//					a[j+1]=temp;
//					flag1++;
//				}
//				if(j==a.length-1-i-1) {
//					if(flag1==0) {
//						flag=true;
//					}
//				}
//			}
//		}
//		System.out.println("After BubbleSorting:");
//		for(int i=0;i<a.length;i++) {
//			System.out.print(a[i]+" ");
//		}
//		System.out.println();
//		System.out.println("长度为"+a.length+"的数组"+"在进行优化时，外循环进行了"+num+"趟");
//	}
//	
	
	public static void main(String[] args) {
		int[] a=new int[] {1,2,3,6,5,4};
		//1st_round:1,2,3,5,4,6
		//2nd_round:1,2,3,4,5,6
		//3rd_round:1,2,3,4,5,6 此时没有进行位置变化，故后续的外循环进行break
		System.out.println("Before BubbleSortingOptimized:");
		for(int i=0;i<a.length;i++) {
			System.out.print(a[i]+" ");
		}
		System.out.println();
		int num=0;
		for(int i=0;i<a.length-1;i++) {//外循环决定要走多少趟,比如length个元素的数组要比较length-1趟
			boolean flag=false;
			num++;
			for(int j=0;j<a.length-1-i;j++) {//内循环决定每一趟的具体操作
				if(a[j]>a[j+1] ) {
					int temp=a[j];
					a[j]=a[j+1];
					a[j+1]=temp;
					flag=true;
				}
			}
			if(!flag) {
				break;
			}
		}
		System.out.println("After BubbleSortingOptimized:");
		for(int i=0;i<a.length;i++) {
			System.out.print(a[i]+" ");
		}
		System.out.println();
		System.out.println("长度为"+a.length+"的数组"+"在进行优化时，外循环进行了"+num+"趟");
	}

}

运行结果：

Before BubbleSortingOptimized:
1 2 3 6 5 4 
After BubbleSortingOptimized:
1 2 3 4 5 6 
长度为6的数组在进行优化时，外循环进行了3趟

备注：

1. 注释部分为我自己写的优化代码，缺点是过于啰嗦
2. 优化的含义是当某些情况下外循环并不需要进行length-1次就可以得到最终的排序结果，此时就可以终止外循环，如1,2,3,5,4，当外循环进行第一次时就可以得到1,2,3,4,5,当下一次外循环时不会有任何元素进行位置的移动，此时就可以提前终止外循环

BubbleSortingSpeedMeasuring.java（测速）

package com.zhanglei.bubblesorting;

import java.text.SimpleDateFormat;
import java.util.Date;

public class BubbleSortingSpeedMeasuring {

	public static void main(String[] args) {
		int maxsize=80000;
		int[] a=new int[maxsize];
		for(int i=0;i<a.length;i++) {
			a[i]=(int)(Math.random()*8000000);//output is in range of [0,8000000)
		}
		Date date=new Date();
		SimpleDateFormat sd=new SimpleDateFormat("yyyy-MM-dd HH-mm-ss");
		String s1=sd.format(date);
		System.out.println("Before BubbleSorting:"+s1);
		
		bubblesort(a);//参数为引用类型，故可以形参变，实参也跟着变
		Date date1=new Date();
		String s2=sd.format(date1);
		System.out.println("After BubbleSorting:"+s2);
	}
	
	public static void bubblesort(int[] a) {
//		int num=0;
		for(int i=0;i<a.length-1;i++) {//外循环决定要走多少趟,比如length个元素的数组要比较length-1趟
			boolean flag=false;
//			num++;
			for(int j=0;j<a.length-1-i;j++) {//内循环决定每一趟的具体操作
				if(a[j]>a[j+1] ) {
					int temp=a[j];
					a[j]=a[j+1];
					a[j+1]=temp;
					flag=true;
				}
			}
			if(!flag) {
				break;
			}
		}
//		System.out.println("After BubbleSorting:");
//		for(int i=0;i<a.length;i++) {
//			System.out.print(a[i]+" ");
//		}
//		System.out.println();
//		System.out.println("长度为"+a.length+"的数组"+"在进行优化时，外循环进行了"+num+"趟");
	}
}

运行结果：

Before BubbleSorting:2021-03-22 14-17-39
After BubbleSorting:2021-03-22 14-17-47

可以看出80000个数据的冒泡排序需要耗时8秒钟
这也是为了跟其他排序算法作比较

备注：

1. 将排序算法打包成一个类方法，其形参为引用类型，故实参随形参变化
2. 由于待排序的数据过多，所以将原来排序算法中的打印语句注释掉，避免控制台显示异常