数据结构（四十二）冒泡排序（O(n²)）

Posted 2020-12-03 bigjunoba

　　一、冒泡排序的定义

　　冒泡排序（Bubble Sort）是一种交换排序，它的基本思想是：两两比较相邻记录的关键字，如果反序则交换，直到没有反序的记录为止。

 

　　二、冒泡排序的实现

　　1.非标准冒泡排序算法--最简单的交换排序

　　

　　思想就是让每一个关键字，都和它后面的每一个关键字比较，如果大则交换，这样第一位置的关键字在一次循环后一定变成最小值。

　　然而缺陷就是，在排序号1和2之后，数字3反而到了最后一位。

// 不是标准的冒泡排序算法，因为它不满足"两两比较相邻记录"的冒泡排序思想，是最简单的交换排序而已。
    public static void BubbleSort0(int[] L) {
        for (int i = 0; i < L.length; i++) {
            for (int j = i + 1; j < L.length; j++) {
                if (L[i] > L[j]) {
                    Assistant_And_Test.swap(L, i, j);
                }
            }
        }
    }

　　int[] array2 = {9,1,5,8,3,7,4,6,2};
　　当i=0时，9与1交换，因为1比其他位置的数字都小，所以1在第0位
　　当i=1时，9与5交换，5与3交换，3与2交换，所以2在第1位
　　...

　　2.标准冒泡排序算法

　　

    // 标准的冒泡排序算法
    public static void BubbleSort1(int[] L) {
        for (int i = 0; i < L.length; i++) {
            for (int j = L.length - 2; j >= i; j--) {
                if (L[j] > L[j + 1]) {
                    swap(L, j, j + 1);
                }
            }
        }
    }

　　int[] array2 = {9,1,5,8,3,7,4,6,2};
　　当i=0时，j从7开始，6与2交换，4与2交换，7与2交换，3与2交换，8与2交换，5与2交换，9与1交换，1排在第0位，2的位置也上升了
　　当i=1时，j从7开始，7与4交换，8与3交换，9与2交换，2排在第1位，3和4的位置也上升了
　　...

 　　3.改进的冒泡排序

　　

　　假设待排序的序列为{2,1,3,4,5,6,7,8,9}，当i=0时，交换2和1，此时序列已经有序，但是算法仍然将i=1到8以及每个循环中的j循环都执行了一遍，尽管并没有交换数据，但是之后的大量比较还是大大多余了。因此，增加一个标记变量flag来实现这一算法的改进。

    // 改进的冒泡排序算法，增加一个标记变量flag
    public static void BubbleSort2(int[] L) {
        boolean flag = true;    // 用flag来做标记
        for (int i = 0; i < L.length && flag; i++) {
            flag = false;        // 初始值为false
            for (int j = L.length - 2; j >= i; j--) {
                if (L[j] > L[j + 1]) {
                    swap(L, j, j + 1);
                    flag = true;// 如果有数据交换，则flag为true
                }
            }
        }
    }
　　
　　int[] array3 = {2,1,3,4,5,6,7,8,9};
　　i=0，flag=false，j=7开始，8和9不交换，7和8不交换，...2和1交换，flag=true，进入for循环
　　i=1，flag=false，j=7开始，没有交换的，所以flag仍然等于false，不进入for循环，
　　...

　　

　　三、冒泡排序算法的时间复杂度

　　对于改进的冒泡排序来说，如果待排序的序列本身就是有序的，那么需要比较n-1次，交换0次，时间复杂度为O(n)。最坏的情况，即待排序的序列是逆序的情况下，此时需要比较1+2+3+...+(n-1) = n(n-1)/2次，并移动n(n-1)/2次，所以总的时间复杂度为O(n2)