冒泡排序【Java 实现】

冒泡排序（从小到大排序）

基本介绍

冒泡排序的基本思想是：遍历若干次数组，每次遍历时，它都会从前往后依次的比较相邻两个数的大小；如果前者比后者大，则交换它们的位置。一次遍历之后，最大的元素就在数组的最后一位， 之后的遍历就不再比较这个最大值（因为最大值的位置已经确定）；然后再次遍历，第二大的元素就被排列在数组的倒数第二位。重复此操作，直到整个数列都有序为止。

由此可知：

遍历的次数为 = 数组的长度 - 1

每次遍历比较的次数 = 数组的长度 - 轮次

举例

以此数组为例： 
int[] arr = {1, 5, 6, 3, 7, 4};  数组长度 = 6

第一次遍历：{1，5，3，6，4，7} 比较 6-1=5 次
第二次遍历：{1，3，5，4，6，7} 比较 4 次
第三次遍历：{1，3，4，5，6，7} 比较 3 次
第四次遍历：{1，3，4，5，6，7} 比较 2 次
第五次遍历：{1，3，4，5，6，7} 比较 1 次

这里可以发现一个有意思的现象，第三次遍历之后，数组没有任何的变化

那么请思考一下，如何避免多余的比较？

代码实现

public static void bubbleSort(int[] arr) {
    for (int i = 0; i < arr.length - 1; i++) {//遍历 数组长度-1 次
        for (int j = 0; j < arr.length - 1 - i; j++) {//比较 数组长度-轮次
            //若前一个数大于后一个数，交换
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

测试

public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = {1, 5, 6, 3,  7, 4};
        
        System.out.println("排序前数组情况");
        for (int i = 0;i < arr.length;i++){
            System.out.print(arr[i] + "\t");
        }
        System.out.println();

        //调用排序方法
        bubbleSort(arr);
        
        System.out.println("排序后数组情况");
        for (int i = 0;i < arr.length;i++){
            System.out.print(arr[i] + "\t");
        }
    }

    public static void bubbleSort(int[] arr) {
        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]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }
}

测试结果

排序前数组情况
1	5	6	3	7	4	
排序后数组情况
1	3	4	5	6	7	

优化

前面提到过，第三次遍历之后，数组没有任何的变化，出现了多次没有必要的比较

那么如何优化？

其实很简单，设置一个标志 flag，初始化为 0 ，若某次遍历有比较的操作（即出现了前一个数大于后一个数的情况），就将 flag 置为 1，若末次遍历没有比较操作，说明此时的数组已经是排序好的数组了，就直接 break 退出循环，避免多余的比较。

代码如下

public static void bubbleSort2(int[] arr) {
    for (int i = 0; i < arr.length - 1; i++) {
        int flag = 0;//标志
        for (int j = 0; j < arr.length - 1 - i; j++) {
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
                flag = 1;//说明有比较操作，置为 1
            }
        }
        if(flag == 0){//说明无比较操作，直接退出循环
            break;
        }
    }
}

测试

public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = {1, 5, 6, 3,  7, 4};
        System.out.println("排序前数组情况");
        for (int i = 0;i < arr.length;i++){
            System.out.print(arr[i] + "\t");
        }
        System.out.println();
        
        bubbleSort2(arr);
        
        System.out.println("排序后数组情况");
        for (int i = 0;i < arr.length;i++){
            System.out.print(arr[i] + "\t");
        }
    }

    public static void bubbleSort2(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            int flag = 0;
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                    flag = 1;
                }
            }
            if(flag == 0){
                break;
            }
        }
    }
}

测试结果

排序前数组情况
1	5	6	3	7	4	
排序后数组情况
1	3	4	5	6	7	

冒泡排序的事件复杂度

冒泡排序的时间复杂度是O(N²)。

假设被排序的数列中有 N 个数。遍历一趟的时间复杂度是O(N)，需要遍历多少次呢? N-1次！

即：O(N) = N(N - 1)，取最高次项，所以，冒泡排序的时间复杂度是O(N²)。