交换排序——冒泡排序&改进的冒泡排序

冒泡排序&改进的冒泡排序

核心思想：

• 比较N趟，依次两两比较，大的后移（小的后移），每趟产生一个最大（最小）值

时间复杂度：

• O(n^2)

适用场景：

• 一般不直接使用原生的冒泡排序，效率低（可使用改进的冒泡排序）

稳定性：

• 稳定（因为依次两两比较，只有前比后大才交换，相同的两个数不会交换）

算法改进：

• 可通过记录最后一次交换位置的地方，下趟排序就只比较到这个位置即可（因为后面都是有序且都比前面大）。若上次无交换位置的地方，就直接结束。

java源码

public class BubbleSort {
	public static void yiCiSort(int []a,int n){
		for(int j=0;j<n-1;j++){//从前往后两两比较，这儿n-1是因为下面是i位置跟i+1位置作比较
			if(a[j]>a[j+1]){
				int temp=a[j];
				a[j]=a[j+1];
				a[j+1]=temp;
			}
		}
	}
	public static void bulleSort(int[]a){
		for(int i=0;i<a.length;i++){
			yiCiSort(a,a.length-i);//每趟排序后长度减一，
			for(int t:a)System.out.print(t+" ");
			System.out.println();
		}
		
	}
	//改进后的冒泡排序
	public static void newBulleSort(int []a){
		int loc=a.length-1;//初始化上次最后交换位置的地方，因为首次比较肯定会比较到最后一位，所以初始化为a.length-1
		while(loc>0){
			int lastLoc=loc;//记录上次位置，用于本次访问的结束位置
			loc=0;//将loc初始化为0,若无交换则退出循环
			for(int i=0;i<lastLoc;i++){
				if(a[i]>a[i+1]){
					int temp=a[i];
					a[i]=a[i+1];
					a[i+1]=temp;
					loc=i;
				}
			}
			
			for(int t:a)System.out.print(t+" ");
			System.out.println();
		}
	}
	public static void main(String[] args) {
		//测试
				int []a={99,100,2,5,3,1,1,111,123,150};
				//原生冒泡排序
				System.out.println("原生冒泡排序：");
				bulleSort(a);
				int []b={99,100,2,5,3,1,1,111,123,150};
				//改进后的冒泡排序
				System.out.println("改进后的冒泡排序：");
				newBulleSort(b);
	}
}

运行结果对比（从上往下为每次排序后的结果）：

原生冒泡排序：
99 2 5 3 1 1 100 111 123 150
2 5 3 1 1 99 100 111 123 150
2 3 1 1 5 99 100 111 123 150
2 1 1 3 5 99 100 111 123 150
1 1 2 3 5 99 100 111 123 150
1 1 2 3 5 99 100 111 123 150
1 1 2 3 5 99 100 111 123 150
1 1 2 3 5 99 100 111 123 150
1 1 2 3 5 99 100 111 123 150
1 1 2 3 5 99 100 111 123 150
改进后的冒泡排序：
99 2 5 3 1 1 100 111 123 150
2 5 3 1 1 99 100 111 123 150
2 3 1 1 5 99 100 111 123 150
2 1 1 3 5 99 100 111 123 150
1 1 2 3 5 99 100 111 123 150