经典排序之---冒泡排序-Java实现

【1】算法思想：
-从待排序序列从前往后(或从后往前)然后两两比较相邻的元素,若为逆序如arr[j]>arr[j+1] 那么它俩交换
然后继续两两比较下去,直到比较到 end-1 与 end 比较。然后第一躺冒泡结束。

每次冒泡都会选出当前最大的放到末尾。如第一次冒泡选出第一大放到末尾第一个
第二次冒泡选出第二大放到末尾第二个
第三次冒泡选出第二大放到末尾第三个
…
最后一次冒泡出第N-1大放到末尾第N-1个
最后一个就不用冒泡了
因此一共冒泡N-1躺，每次冒泡选出当前最大的冒泡到上次末尾的前一个位置。

• 空间效率：仅适用了常数个辅助单元，因而空间复杂度为O(1)

• 时间效率:
  最坏：O(n方) 一共n-1躺,每趟移动n-1,n-2,n-3,…2,1最后为一个等差数列。因此时间复杂度为O(n方)
  最好：o(n) 第一躺直接有序直接return但是第一躺要比较n-1次 因此时间复杂度为O(n)

• 稳定性：稳定 在冒泡过程中代码设计的时候,如果前一个后后一个相等前一个不会与后一个发生交换,而且每次躺冒泡都是大的向前移动,不会有插入的情况，因此是稳定的。

【2】代码

/**
 * @Auther: 米兰的小铁匠
 * @Date： 2022/4/18 12:01
 * @Description: 冒泡排序
 * 算法思想：从待排序序列从前往后(或从后往前)然后两两比较相邻的元素,若为逆序如arr[j]>arr[j+1] 那么它俩交换
 *          然后继续两两比较下去,直到比较到 end-1 与 end 比较。然后第一躺冒泡结束。
 *          每次冒泡都会选出当前最大的放到末尾。如第一次冒泡选出第一大放到末尾第一个
 *          第二次冒泡选出第二大放到末尾第二个
 *          第三次冒泡选出第二大放到末尾第三个
 *          ......
 *          最后一次冒泡出第N-1大放到末尾第N-1个
 *          最后一个就不用冒泡了
 *          因此一共冒泡N-1躺，每次冒泡选出当前最大的冒泡到上次末尾的前一个位置。
 *
 * 空间效率：仅适用了常数个辅助单元，因而空间复杂度为O(1)
 *
 * 时间效率:
 *          最坏：O(n方) 一共n-1躺,每趟移动n-1,n-2,n-3,....2,1最后为一个等差数列。因此时间复杂度为O(n方)
 *          最好：o(n)  第一躺直接有序直接return但是第一躺要比较n-1次 因此时间复杂度为O(n)
 */

@SuppressWarnings("all")
public class Code01_BubbleSort {
    public static void bubbleSort(int[] arr) {
        //先考虑边界情况---待排序序列若为空或者只有一个元素,直接返回即可
        if (arr == null || arr.length < 2) {
            return;
        }
        int N = arr.length;
        boolean flag = true;//定义一个标志.当下面经历一次冒泡比较时,不用交换那么就代表为有序的,因此就不用排序了直接就返回。
        /*
         * 这里的思路是 0与1 比较 1与2 比较 2与3 比较 ... end-1 与 end 比较 然后将最大的冒泡的 end位置
         * 下一次将第二大的冒泡的end-1 位置 在下一次 将第三大位置 冒泡到 end-2 位置 以此下去...
         * 【注】这里为啥外层for终止条件是N-1? 里层for终止条件是N-1-i?
         *
         * 里层:由于每次外层循环一次都会将当前最大的数冒泡的end位置,因此下一次循环里层就不用判断上次末尾那个
         * 即只用判断到上次末尾的前一个,因此N会减-i。
         * 而N-1-i中减1 是因为从j与j+1比较时从 0与1 1与2 2与3 一直比较到 end-1与end 因此j只用到end-1就可以
         * 如果j到了end那么j+1就会越界
         *
         * 外层：由于整个待排序序列经过数组长度-1次冒泡即可比较完成，因此就循环N-1次即可
         * */
        for (int i = 0; i < N - 1; i++) {
            for (int j = 0; j < N - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {//如果当前大于下一个就交换,注意:等于不交换,保证了稳定性。
                    swap(arr, j, j + 1);
                }
                flag = false;
            }
        }
        if (flag == true) return;//如果此时没有发生交换,说明序列有序,即直接返回。
    }

    //交换
    public static void swap(int[] arr, int i, int j) {
        int tmp = arr[j];
        arr[j] = arr[i];
        arr[i] = tmp;
    }

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

    //主函数
    public static void main(String[] args) {
        int[] arr = {7, 1, 3, 1, 2, 5, 6, 7, 12, 34, 2, 0, 1};
        printArray(arr);
        bubbleSort(arr);
        printArray(arr);
    }
}