冒泡排序算法

冒泡排序

时间复杂度O($n^2$)，比较n-1趟，每次比较n - i - 1次
空间复杂度T($n^2$)，只用到一个临时变量

 /**
     * 冒泡排序
     */
    public static void bubbleSort(int[] nums) {
        for (int i = 0; i < nums.length - 1; i++) {
            for (int j = 0; j < nums.length - i - 1; j++) {
                if (nums[j + 1] < nums[j]) {
                    int temp = nums[j + 1];
                    nums[j + 1] = nums[j];
                    nums[j] = temp;
                }
            }
        }
    }

优化1

/**
     * 冒泡排序优化
     * 如果某轮比较未发生交换，说明数据已经有序，可以提前结束
     */
    public static void bubbleSort2(int[] nums) {
        for (int i = 0; i < nums.length - 1; i++) {
            boolean isSorted = true;
            for (int j = 0; j < nums.length - i - 1; j++) {
                if (nums[j + 1] < nums[j]) {
                    int temp = nums[j + 1];
                    nums[j + 1] = nums[j];
                    nums[j] = temp;
                    isSorted = false;
                }
            }
            // 如果在内循环中没有发生交换，则说明数组已经有序，可以提前结束排序
            if (isSorted) {
                break;
            }
        }
    }

优化2

/**
     * 冒泡排序优化
     * 每次排序都会冒泡算法后半部都会有序性都会增加，如果后半部分本身就有序，那么就会浪费多次比较
     */
    public static void bubbleSort3(int[] nums) {
        int lastSorted = nums.length - 1;
        for (int i = 0; i < nums.length - 1; i++) {
            int sortedBord = lastSorted;
            boolean isSorted = true;
            for (int j = 0; j < sortedBord; j++) {
                if (nums[j + 1] < nums[j]) {
                    int temp = nums[j + 1];
                    nums[j + 1] = nums[j];
                    nums[j] = temp;
                    lastSorted = j;
                    isSorted = false;
                }
            }
            sortedBord = lastSorted;
            // 如果在内循环中没有发生交换，则说明数组已经有序，可以提前结束排序
            if (isSorted) {
                break;
            }
        }
    }

优化3

 /**
     * 冒泡排序优化
     * 用来优化23456781这种顺序，正常需要比较7轮，优化后只需要3轮
     */
    public static void bubbleSort4(int[] nums) {
        for (int i = 0; i < nums.length / 2; i++) {
            // 奇数轮
            boolean isSorted = true;
            for (int j = 0; j < nums.length - 1; j++) {
                if (nums[j + 1] < nums[j]) {
                    int temp = nums[j + 1];
                    nums[j + 1] = nums[j];
                    nums[j] = temp;
                    isSorted = false;
                }
            }
            if (isSorted) {
                break;
            }

            isSorted = true;
            // 偶数轮
            for (int j = nums.length - 1; j > 0 ; j--) {
                if (nums[j] < nums[j - 1]) {
                    int temp = nums[j - 1];
                    nums[j - 1] = nums[j];
                    nums[j] = temp;
                    isSorted = false;
                }
            }
            if (isSorted) {
                break;
            }
        }
    }