算法系列-冒泡排序

基本介绍

基本思想： 通过对待排序序列从前向后(从下标较小的元素开始)，依次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前移到后部，就像水底的气泡一样逐渐向上冒。

因为排序过程中，各元素不断接近自己的位置，如果一趟比较下来没有进行过交换，就说明序列有序，因此要在排序过程中设置一个 flag用来判断元素是否进行交换过，从而减少不必要的比较。

规则思路

我们对一个简单的序列进行排序，10，6，7，-2，-1
第一趟排序
第1次比对结果： 6，10，7，-2，-1
第2次比对结果：6，7，10，-2，-1
第3次比对结果： 6，7，-2，10，-1
第4次比对结果：6，7，-2，-1，10
得出最大值10
第二趟排序
第1次比对结果： 6，7，-2，-1，10
第2次比对结果：6，-2，7，-1，10
第3次比对结果： 6，-2，-1，7，10
第三趟排序
第1次比对结果： -2，6，-1，7，10
第2次比对结果： -2，-1，6，7，10
第四趟排序
第1次比对结果： -2，-1，6，7，10

总结冒泡排序规则：

1. 一共进行数组的大小size-1次循环
2. 每一趟排序的次数在逐渐的减少
3. 如果我们发现某一趟的排序中，没有发生一次交换，可以提前结束冒泡排序

代码演示

首先让我们演示一下上面的思路：

public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = {10,6,7,-2,-1};

        int temp = 0;
        for(int j = 0;j<arr.length-1;j++){
            if(arr[j] > arr[j+1]){
                temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
        System.out.println("第一趟排序后的数组");
        System.out.println(Arrays.toString(arr));

        for(int j = 0;j<arr.length-2;j++){
            if(arr[j] > arr[j+1]){
                temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
        System.out.println("第二趟排序后的数组");
        System.out.println(Arrays.toString(arr));

        for(int j = 0;j<arr.length-3;j++){
            if(arr[j] > arr[j+1]){
                temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
        System.out.println("第三趟排序后的数组");
        System.out.println(Arrays.toString(arr));

        for(int j = 0;j<arr.length-4;j++){
            if(arr[j] > arr[j+1]){
                temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
        System.out.println("第四趟排序后的数组");
        System.out.println(Arrays.toString(arr));
    }
}

运行结果：

第一趟排序后的数组
[6, 7, -2, -1, 10]
第二趟排序后的数组
[6, -2, -1, 7, 10]
第三趟排序后的数组
[-2, -1, 6, 7, 10]
第四趟排序后的数组
[-2, -1, 6, 7, 10]

整理后代码为；

public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = {10, 6, 7, -2, -1};

        int temp = 0;
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
            System.out.println("第"+(i+1)+"趟排序后的数组");
            System.out.println(Arrays.toString(arr));
        }
    }
}

查看运行结果：

第1趟排序后的数组
[6, 7, -2, -1, 10]
第2趟排序后的数组
[6, -2, -1, 7, 10]
第3趟排序后的数组
[-2, -1, 6, 7, 10]
第4趟排序后的数组
[-2, -1, 6, 7, 10]

时间复杂度:
通过整理后的代码可以看到，一共有两个循环，其时间复杂度为O($n^2$)

优化后的代码：

public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = {10, 6, 7, -2, -1};

        int temp = 0;
        boolean flag = false;
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    flag = true;
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
            if(!flag){ //此次排序中没有交换，说明已经是一个有序数组，退出比较
                break;
            }else {
                flag = false;
            }
            System.out.println("第"+(i+1)+"趟排序后的数组");
            System.out.println(Arrays.toString(arr));
        }
    }
}

运行结果：

第1趟排序后的数组
[6, 7, -2, -1, 10]
第2趟排序后的数组
[6, -2, -1, 7, 10]
第3趟排序后的数组
[-2, -1, 6, 7, 10]