数据结构与算法系列(6)冒泡排序算法

1、冒泡排序原理

冒泡排序只会操作相邻的两个数据。每次冒泡操作都会对相邻的两个元素进行比较，看是否满足大小关系要求。如果不满足就让它俩互换。一次冒泡会让至少一个元素移动到它应该在的位置，重复 n 次，就完成了 n 个数据的排序工作。

如果我们要对一组数据 4，5，6，3，2，1从小到到大进行排序，第一次冒泡操作的详细过程就是这样：

1. 4和5比较，4小于5，不进行位置交换，结果：[4，5，6，3，2，1]
2. 5和6比较，5小于6，不进行位置交换，结果：[4，5，6，3，2，1]
3. 6和3比较，6大于3，进行位置交换，结果：[4，5，3，6，2，1]
4. 6和2比较，6大于2，进行位置交换，结果：[4，5，3，2，6，1]
5. 6和1比较，6大于1，进行位置交换，结果：[4，5，3，2，1，6]

要想完成所有数据的排序，只要进行 6 次这样的冒泡操作就可以了：

冒泡次数	冒泡后的结果
初始状态	[ 4 ，5，6，3, 2, 1]
第一次 冒泡	[ 4 ，5，3，2, 1, 6]
第二次 冒泡	[ 4 ，3，1，1, 5, 6]
第三次 冒泡	[ 3 ，2，1，4, 5, 6]
第四次 冒泡	[ 2 ，1，3，4, 5, 6]
第五次 冒泡	[ 1，2，3，4, 5, 6]
第六次 冒泡	[ 1，2，3，4, 5, 6]

2、代码实现

 *  从小到大排序
     * @param a
     * @return
     */
    public static int[] bubbleSort(int[] a){
        if (a.length<=1)
            return a;
        //外层for总共冒泡操作的次数
        for (int i=0;i<a.length-1;i++){
            //内层for  两个元素的交换
            for (int j=0;j<a.length-i-1;j++){
                if (a[j]>a[j+1]){
                    //交换数据
                    int tmp=a[j];
                    a[j]=a[j+1];
                    a[j+1]=tmp;
                }
            }
        }
        return a;
    }

3、冒泡排序优化

通过上图，我们发现在第五次冒泡操作后，已经没有数据交换，这时已经达到完全有序，不用再继续执行后续的冒泡操作，我们可以通过添加一个标识符，来判断当前是否还有数据交换，经过优化，对 4，5，6，3，2，1这组数据排序，只需执行5次冒泡操作。

冒泡次数	冒泡后的结果	是否有数据交换
初始状态	[ 4 ，5，6，3, 2, 1]	----
第一次 冒泡	[ 4 ，5，3，2, 1, 6]	有
第二次 冒泡	[ 4 ，3，1，1, 5, 6]	有
第三次 冒泡	[ 3 ，2，1，4, 5, 6]	有
第四次 冒泡	[ 2 ，1，3，4, 5, 6]	有
第五次 冒泡	[ 1，2，3，4, 5, 6]	无

代码实现：

/**
     *  从小到大排序
     * @param a
     * @return
     */
    public static int[] bubbleSort(int[] a){
        if (a.length<=1)
            return a;
        //外层for总共冒泡操作的次数
        for (int i=0;i<a.length-1;i++){
            //标识当前冒泡操作是否有数据交换
            boolean flag=false;
            //内层for  两个元素的交换
            for (int j=0;j<a.length-i-1;j++){
                if (a[j]>a[j+1]){
                    //交换数据
                    int tmp=a[j];
                    a[j]=a[j+1];
                    a[j+1]=tmp;
                    flag=true;
                }
            }
            //如果数据已经有序，无需再执行冒泡操作
            if (!flag) break;
        }
        return a;
    }

4、算法分析

4.1、时间复杂度

• 最好情况：T(n)=O(n)
• 最坏情况：T(n)=O(n^2)
• 平均情况：T(n)=O(n^2)

4.2、是否稳定

在冒泡排序中，只有交换才可以改变两个元素的前后顺序。为了保证冒泡排序算法的稳定性，当有相邻的两个元素大小相等的时候，我们不做交换，相同大小的数据在排序前后不会改变顺序，所以冒泡排序是稳定的排序算法。