经典排序之冒泡排序

冒泡排序（Bubble Sort）是一种比较经典的排序算法。

之所以称为“冒泡排序” ，是因为在排序中，越大（降序排列）或越小（升序排列）的相邻元素会经由交换逐渐“浮”到前面，有如 水中浮出的水泡，故形象地命名为“冒泡排序”。

冒泡排序主要对相邻的两个元素进行比较。

在时间复杂度方面，若数据集的初始状态是正序的，一趟扫描即可完成排序。这时，排序中的比较 次数和移动次数均达到最小值，其时间复杂度O(N)。

若数据集的初始状态是反序的，需要进行n-1趟排序；每趟排序要进行n-i次关键字的比较 (1≤i≤n-1)。在这种情况下，比较和移动次数均达到最大值，其时间复杂度为O(n²)。

总的来说，冒泡排序的平均时间复杂度为O(n²)。

我们接下来通过代码来看冒泡排序。

package 排序算法.冒泡排序;

import java.util.Arrays;

/**
 * 未优化的冒泡排序
 */
public class Demo1 {
    public static void main(String[] args) {
        int[] arr = new int[]{15, 32, 14, 86, 54, 78, 36};
        System.out.println("排序前的数组：" + Arrays.toString(arr));
        System.out.println("排序中：");
        int k = 0;
        for (int j = 0; j < arr.length - 1; j++) {
            for (int i = 0; i < arr.length - 1; i++) {
                if (arr[i] > arr[i + 1]) {
                    int temp = arr[i];
                    arr[i] = arr[i + 1];
                    arr[i + 1] = temp;
                }
                System.out.println("第 " + (++k) + " 次：" + Arrays.toString(arr));
            }
        }
        System.out.println("排序后的数组：" + Arrays.toString(arr));
    }
}

 　　上述代码运行结果如下：

排序前的数组：[15, 32, 14, 86, 54, 78, 36]
排序中：
第 1 次：[15, 32, 14, 86, 54, 78, 36]
第 2 次：[15, 14, 32, 86, 54, 78, 36]
第 3 次：[15, 14, 32, 86, 54, 78, 36]
第 4 次：[15, 14, 32, 54, 86, 78, 36]
第 5 次：[15, 14, 32, 54, 78, 86, 36]
第 6 次：[15, 14, 32, 54, 78, 36, 86]
第 7 次：[14, 15, 32, 54, 78, 36, 86]
第 8 次：[14, 15, 32, 54, 78, 36, 86]
第 9 次：[14, 15, 32, 54, 78, 36, 86]
第 10 次：[14, 15, 32, 54, 78, 36, 86]
第 11 次：[14, 15, 32, 54, 36, 78, 86]
第 12 次：[14, 15, 32, 54, 36, 78, 86]
第 13 次：[14, 15, 32, 54, 36, 78, 86]
第 14 次：[14, 15, 32, 54, 36, 78, 86]
第 15 次：[14, 15, 32, 54, 36, 78, 86]
第 16 次：[14, 15, 32, 36, 54, 78, 86]
第 17 次：[14, 15, 32, 36, 54, 78, 86]
第 18 次：[14, 15, 32, 36, 54, 78, 86]
第 19 次：[14, 15, 32, 36, 54, 78, 86]
第 20 次：[14, 15, 32, 36, 54, 78, 86]
第 21 次：[14, 15, 32, 36, 54, 78, 86]
第 22 次：[14, 15, 32, 36, 54, 78, 86]
第 23 次：[14, 15, 32, 36, 54, 78, 86]
第 24 次：[14, 15, 32, 36, 54, 78, 86]
第 25 次：[14, 15, 32, 36, 54, 78, 86]
第 26 次：[14, 15, 32, 36, 54, 78, 86]
第 27 次：[14, 15, 32, 36, 54, 78, 86]
第 28 次：[14, 15, 32, 36, 54, 78, 86]
第 29 次：[14, 15, 32, 36, 54, 78, 86]
第 30 次：[14, 15, 32, 36, 54, 78, 86]
第 31 次：[14, 15, 32, 36, 54, 78, 86]
第 32 次：[14, 15, 32, 36, 54, 78, 86]
第 33 次：[14, 15, 32, 36, 54, 78, 86]
第 34 次：[14, 15, 32, 36, 54, 78, 86]
第 35 次：[14, 15, 32, 36, 54, 78, 86]
第 36 次：[14, 15, 32, 36, 54, 78, 86]
排序后的数组：[14, 15, 32, 36, 54, 78, 86]

上述是未优化的结果;，优化后的代码如下：

package 排序算法.冒泡排序;
import java.util.Arrays;
/**
 * 优化后的冒泡排序；相邻元素比较，小的浮上来
 */
public class Test {
    static void bubleSort(int[] intArr){
        int k=0;//统计每次排序后的状态
        for(int i=0;i<intArr.length-1;i++){
            boolean boo=false;//判断数组是否存在无序状态，false表示已经有序
            for(int j=0;j<intArr.length-1;j++){
                if(intArr[j]>intArr[j+1]){
                    boo=true;
                    int temp=intArr[j];
                    intArr[j]=intArr[j+1];
                    intArr[j+1]=temp;
                }
            }
            if(!boo){
                break;//如果数组已经有序，则不必再循环
            }
            k++;
            System.out.println("第"+k+"次排序："+ Arrays.toString(intArr));
        }
    }
    public static void main(String[] args) {
        int[] arr=new int[]{15,32,14,86,54,78,36};
        System.out.println("排序前的数组:"+Arrays.toString(arr));
        bubleSort(arr);
        System.out.println("排序后的数组:"+Arrays.toString(arr));
    }
}

　　上述代码运行结果如下：

排序前的数组:[15, 32, 14, 86, 54, 78, 36]
第1次排序：[15, 14, 32, 54, 78, 36, 86]
第2次排序：[14, 15, 32, 54, 36, 78, 86]
第3次排序：[14, 15, 32, 36, 54, 78, 86]
排序后的数组:[14, 15, 32, 36, 54, 78, 86]

　　可见，优化后的代码，比原先重复排序（36-3=33）减少33次之多。