【排序算法】冒泡排序算法优化

冒泡排序算法的思想是通过相邻元素的两两比较与位置交换最终将大的元素移到最右端。

入门

冒泡排序作为最简单的排序算法我们在理解他的思路后，很容易就写出下面的这样一个冒泡算法。

public void sorted(int[] items){
	int temp=0;
	for(int i=0;i<items.length-1;i++){
		for(int l=0;j<items.length-i-1;j++){
			if(items[j]>items[j+1]){
				temp=items[j];
				items[j]=items[j+1];
				items[j+1]=temp;
			}
		}
	}
}

思考

如果我的输入数组本身是一个有序队列，那么冒泡排序算法是一个怎样的流程呢？
将冒泡排序算法的排序过程打印出来

public void sorted(int[] items){
	int temp=0;
        for (int i=0;i<items.length-1;i++){
            System.out.println("##########第【"+(i+1)+"】次#########");
            for(int j=0;j<items.length-i-1;j++){
                if (items[j]>items[j+1]){
                    temp=items[j];
                    items[j]=items[j+1];
                    items[j+1]=temp;
                }
                System.out.println(Arrays.toString(items));
            }
        }
  }

输入数组：[0,1,2,3,4,5,6,7]

打印结果如下：

##########第【1】次#########
[0, 1, 2, 3, 4, 5, 6, 7]
[0, 1, 2, 3, 4, 5, 6, 7]
[0, 1, 2, 3, 4, 5, 6, 7]
[0, 1, 2, 3, 4, 5, 6, 7]
[0, 1, 2, 3, 4, 5, 6, 7]
[0, 1, 2, 3, 4, 5, 6, 7]
[0, 1, 2, 3, 4, 5, 6, 7]
##########第【2】次#########
[0, 1, 2, 3, 4, 5, 6, 7]
[0, 1, 2, 3, 4, 5, 6, 7]
[0, 1, 2, 3, 4, 5, 6, 7]
[0, 1, 2, 3, 4, 5, 6, 7]
[0, 1, 2, 3, 4, 5, 6, 7]
[0, 1, 2, 3, 4, 5, 6, 7]
##########第【3】次#########
[0, 1, 2, 3, 4, 5, 6, 7]
[0, 1, 2, 3, 4, 5, 6, 7]
[0, 1, 2, 3, 4, 5, 6, 7]
[0, 1, 2, 3, 4, 5, 6, 7]
[0, 1, 2, 3, 4, 5, 6, 7]
##########第【4】次#########
[0, 1, 2, 3, 4, 5, 6, 7]
[0, 1, 2, 3, 4, 5, 6, 7]
[0, 1, 2, 3, 4, 5, 6, 7]
[0, 1, 2, 3, 4, 5, 6, 7]
##########第【5】次#########
[0, 1, 2, 3, 4, 5, 6, 7]
[0, 1, 2, 3, 4, 5, 6, 7]
[0, 1, 2, 3, 4, 5, 6, 7]
##########第【6】次#########
[0, 1, 2, 3, 4, 5, 6, 7]
[0, 1, 2, 3, 4, 5, 6, 7]
##########第【7】次#########
[0, 1, 2, 3, 4, 5, 6, 7]

当我们输入一个原本有序的数组时，冒泡算法仍然会将整个流程跑一遍，这样就做了很多无用功。

解决

冒泡排序是由两个循环组成，内部循环的作用是将未排序序列的元素两两比较，并最终将最大的移到最后，如果内部循环一趟下来没有发生元素交换，是不是就是说明本趟待排序列已经是一个有序序列了，所以可以直接停止排序了！

改造排序算法如下：

public  void sorted(int[] items){
        int temp=0;
        boolean isChange=false; // 增加一个是否发生元素交换的标识
        for (int i=0;i<items.length-1;i++){
            isChange=false; // 外层循环开始，默认是有序队列
            System.out.println("##########第【"+(i+1)+"】次#########");
            for(int j=0;j<items.length-i-1;j++){
                if (items[j]>items[j+1]){
                    temp=items[j];
                    items[j]=items[j+1];
                    items[j+1]=temp;
                    isChange=true;  // 如果发生了元素交换，证明不是有序队列
                }
                System.out.println(Arrays.toString(items));

            }
            // 当内层循环走完一次后，没有发生元素交换，则认为队列已经有序，跳出循环，结束算法
            if (!isChange) break;
        }
    }

输入同样的序列[0,1,2,3,4,5,6,7]，查看排序过程：

##########第【1】次#########
[0, 1, 2, 3, 4, 5, 6, 7]
[0, 1, 2, 3, 4, 5, 6, 7]
[0, 1, 2, 3, 4, 5, 6, 7]
[0, 1, 2, 3, 4, 5, 6, 7]
[0, 1, 2, 3, 4, 5, 6, 7]
[0, 1, 2, 3, 4, 5, 6, 7]
[0, 1, 2, 3, 4, 5, 6, 7]

只发生了一次外层循环就结束了排序，也就是说，我们添加的标识起到了作用！

再次验证

可能有人会说，输入有序数组是一种特殊的数组，如过换成局部有序数组还有效吗？

我们输入如下数组：[9,5,7,8,6,1,2,3,4]

优化后的执行结果如下，共经历外侧循环6次

##########第【1】次#########
[5, 9, 7, 8, 6, 1, 2, 3, 4]
[5, 7, 9, 8, 6, 1, 2, 3, 4]
[5, 7, 8, 9, 6, 1, 2, 3, 4]
[5, 7, 8, 6, 9, 1, 2, 3, 4]
[5, 7, 8, 6, 1, 9, 2, 3, 4]
[5, 7, 8, 6, 1, 2, 9, 3, 4]
[5, 7, 8, 6, 1, 2, 3, 9, 4]
[5, 7, 8, 6, 1, 2, 3, 4, 9]
##########第【2】次#########
[5, 7, 8, 6, 1, 2, 3, 4, 9]
[5, 7, 8, 6, 1, 2, 3, 4, 9]
[5, 7, 6, 8, 1, 2, 3, 4, 9]
[5, 7, 6, 1, 8, 2, 3, 4, 9]
[5, 7, 6, 1, 2, 8, 3, 4, 9]
[5, 7, 6, 1, 2, 3, 8, 4, 9]
[5, 7, 6, 1, 2, 3, 4, 8, 9]
##########第【3】次#########
[5, 7, 6, 1, 2, 3, 4, 8, 9]
[5, 6, 7, 1, 2, 3, 4, 8, 9]
[5, 6, 1, 7, 2, 3, 4, 8, 9]
[5, 6, 1, 2, 7, 3, 4, 8, 9]
[5, 6, 1, 2, 3, 7, 4, 8, 9]
[5, 6, 1, 2, 3, 4, 7, 8, 9]
##########第【4】次#########
[5, 6, 1, 2, 3, 4, 7, 8, 9]
[5, 1, 6, 2, 3, 4, 7, 8, 9]
[5, 1, 2, 6, 3, 4, 7, 8, 9]
[5, 1, 2, 3, 6, 4, 7, 8, 9]
[5, 1, 2, 3, 4, 6, 7, 8, 9]
##########第【5】次#########
[1, 5, 2, 3, 4, 6, 7, 8, 9]
[1, 2, 5, 3, 4, 6, 7, 8, 9]
[1, 2, 3, 5, 4, 6, 7, 8, 9]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
##########第【6】次#########
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 2, 3, 4, 5, 6, 7, 8, 9]

原始排序算法结果如下，共经历8次外侧循环

##########第【1】次#########
[5, 9, 7, 8, 6, 1, 2, 3, 4]
[5, 7, 9, 8, 6, 1, 2, 3, 4]
[5, 7, 8, 9, 6, 1, 2, 3, 4]
[5, 7, 8, 6, 9, 1, 2, 3, 4]
[5, 7, 8, 6, 1, 9, 2, 3, 4]
[5, 7, 8, 6, 1, 2, 9, 3, 4]
[5, 7, 8, 6, 1, 2, 3, 9, 4]
[5, 7, 8, 6, 1, 2, 3, 4, 9]
##########第【2】次#########
[5, 7, 8, 6, 1, 2, 3, 4, 9]
[5, 7, 8, 6, 1, 2, 3, 4, 9]
[5, 7, 6, 8, 1, 2, 3, 4, 9]
[5, 7, 6, 1, 8, 2, 3, 4, 9]
[5, 7, 6, 1, 2, 8, 3, 4, 9]
[5, 7, 6, 1, 2, 3, 8, 4, 9]
[5, 7, 6, 1, 2, 3, 4, 8, 9]
##########第【3】次#########
[5, 7, 6, 1, 2, 3, 4, 8, 9]
[5, 6, 7, 1, 2, 3, 4, 8, 9]
[5, 6, 1, 7, 2, 3, 4, 8, 9]
[5, 6, 1, 2, 7, 3, 4, 8, 9]
[5, 6, 1, 2, 3, 7, 4, 8, 9]
[5, 6, 1, 2, 3, 4, 7, 8, 9]
##########第【4】次#########
[5, 6, 1, 2, 3, 4, 7, 8, 9]
[5, 1, 6, 2, 3, 4, 7, 8, 9]
[5, 1, 2, 6, 3, 4, 7, 8, 9]
[5, 1, 2, 3, 6, 4, 7, 8, 9]
[5, 1, 2, 3, 4, 6, 7, 8, 9]
##########第【5】次#########
[1, 5, 2, 3, 4, 6, 7, 8, 9]
[1, 2, 5, 3, 4, 6, 7, 8, 9]
[1, 2, 3, 5, 4, 6, 7, 8, 9]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
##########第【6】次#########
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
##########第【7】次#########
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
##########第【8】次#########
[1, 2, 3, 4, 5, 6, 7, 8, 9]

可以看出当数组的有序元素越多，改造后的冒泡排序算法的时间复杂度越低！