13-冒泡排序

1. 基本思想

• 从前向后(从下标较小的元素开始)，依次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部，就像水底下的气泡一样逐渐向上冒
• 每循环遍历一次，就能把这一轮见过的元素中 maxValue 放在末尾位置 // 和选择排序正好相反，选择是一轮过后，就确定一个 minVal
• 待排序元素范围从数组末尾开始缩减：每遍历一轮，确定一个 maxValue，就使得下一次遍历的范围 - 1 // 和选择排序正好相反，它是从头缩减

2. 标配

• 平均时间复杂度：O(n^2)
• 最坏时间复杂度：O(n^2)
• 最好时间复杂度：O(1) // 本身就顺序, 你再用一个标记, 进去就出来了
• 时间复杂度：O(n)
• 稳定

3. 举例说明

4. 代码实现

public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = new int[9];
        for (int i = 0; i < 9; i++)
            arr[i] = (int) (Math.random() * 200);
        print(arr);
        bubble_2(arr);
        print(arr);
    }

    public static void bubble_1(int[] arr) {
        // 加了这个 flag, 就能达到最好时间复杂度 O(n)
        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;
                    swap(arr, j, j+1);
                }
            }
            if (flag) flag = false; // 重置flag, 以便下次判断
            else break; // 已顺序，退出
        }
    }

    public static void bubble_2(int[] arr) {
        boolean flag = false;
        for (int i = arr.length - 1; i > 0; i--) {
            for (int j = 0; j < i; j++) {
                if (arr[j] > arr[j+1]) {
                    flag = true;
                    swap(arr, j, j+1);
                }
            }

            if (flag) flag = false;
            else break;
        }
    }

    public static void swap(int[] arr, int a, int b) {
        int temp = arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }

    public static void print(int[] arr) {
        for (int i = 0; i < arr.length; i++)
            System.out.print(arr[i] + " ");
        System.out.println();
    }
}