冒泡排序算法

冒泡排序概述：

依次比较相邻的两个数，将大的数往后移。

算法描述

1. 依次比较数组中相邻两个元素大小，若 a[j] > a[j+1]，则交换两个元素，两两都比较一遍称为一轮冒泡，结果是让最大的元素排至最后
2. 重复以上步骤，直到整个数组有序

冒泡排序算法的原理如下：

比较相邻的元素。如果第一个比第二个大，就交换他们两个。
对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
针对所有的元素重复以上的步骤，除了最后一个。 
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
每一趟都能确定一个元素的最终位置。

实例

基本写法（未优化）

/**
 * @author pzz
 * @date 2022/5/24
 * 冒泡排序
 */
public class BubbleSort {
    public static void main(String[] args) {
        int[] a = {5, 2, 7, 4, 1, 3, 8, 9};
//        int[] a = {1, 2, 3, 4, 5, 7, 8, 9};
        bubble_v1(a);
    }

    //基本排序
    private static void bubble_v1(int[] arr) {
        for(int i = 0;i < arr.length - 1;++i){
            for(int j = 0;j < arr.length - 1;++j){
            	System.out.println("比较次数" + j);
                if(arr[j] > arr[j + 1]){
                    swap(arr,j,j + 1);
                }
            }
            System.out.println("第" + i + "轮冒泡"+ Arrays.toString(arr));
        }
    }

    public static void swap(int[] array, int i, int j) {
        int t = array[i];
        array[i] = array[j];
        array[j] = t;
    }
}

运行结果

...省略前面5轮
第4轮冒泡[1, 2, 3, 4, 5, 7, 8, 9]
比较次数0
比较次数1
比较次数2
比较次数3
比较次数4
比较次数5
比较次数6
第5轮冒泡[1, 2, 3, 4, 5, 7, 8, 9]
比较次数0
比较次数1
比较次数2
比较次数3
比较次数4
比较次数5
比较次数6
第6轮冒泡[1, 2, 3, 4, 5, 7, 8, 9]

当数组有序时
int[] a = {1, 2, 3, 4, 5, 7, 8, 9}

运行结果

...省略前面5轮
第4轮冒泡[1, 2, 3, 4, 5, 7, 8, 9]
比较次数0
比较次数1
比较次数2
比较次数3
比较次数4
比较次数5
比较次数6
第5轮冒泡[1, 2, 3, 4, 5, 7, 8, 9]
比较次数0
比较次数1
比较次数2
比较次数3
比较次数4
比较次数5
比较次数6
第6轮冒泡[1, 2, 3, 4, 5, 7, 8, 9]

进一步优化

• 优化点1：每经过一轮冒泡，内层循环就可以减少一次
• 优化点2：如果某一轮冒泡没有发生交换，则表示所有数据有序，可以结束外层循环

/**
 * @author pzz
 * @date 2022/5/24
 * 冒泡排序
 */
public class BubbleSort {
    public static void main(String[] args) {
        int[] a = {5, 2, 7, 4, 1, 3, 8, 9};
//        int[] a = {1, 2, 3, 4, 5, 7, 8, 9};
        bubble_v2(a);
    }


    //优化1
    private static void bubble_v2(int[] arr) {
        boolean swapped = false; // 是否发生了交换
        for(int i = 0;i < arr.length - 1;++i){
            for(int j = 0;j < arr.length - 1 - i;++j){
                System.out.println("比较次数" + j);
                if(arr[j] > arr[j + 1]){
                    swap(arr,j,j + 1);
                    //发生了交换
                    swapped = true;
                }
            }
            System.out.println("第" + i + "轮冒泡"+ Arrays.toString(arr));
            //如果这一轮没有交换，则说明已经有序，直接退出
            if (!swapped){
                break;
            }
        }
    }

    public static void swap(int[] array, int i, int j) {
        int t = array[i];
        array[i] = array[j];
        array[j] = t;
    }
}

运行结果

比较次数0
比较次数1
比较次数2
比较次数3
比较次数4
比较次数5
比较次数6
第0轮冒泡[2, 5, 4, 1, 3, 7, 8, 9]
比较次数0
比较次数1
比较次数2
比较次数3
比较次数4
比较次数5
第1轮冒泡[2, 4, 1, 3, 5, 7, 8, 9]
比较次数0
比较次数1
比较次数2
比较次数3
比较次数4
第2轮冒泡[2, 1, 3, 4, 5, 7, 8, 9]
比较次数0
比较次数1
比较次数2
比较次数3
第3轮冒泡[1, 2, 3, 4, 5, 7, 8, 9]
比较次数0
比较次数1
比较次数2
第4轮冒泡[1, 2, 3, 4, 5, 7, 8, 9]
比较次数0
比较次数1
第5轮冒泡[1, 2, 3, 4, 5, 7, 8, 9]
比较次数0
第6轮冒泡[1, 2, 3, 4, 5, 7, 8, 9]

当数组有序时
int[] a = {1, 2, 3, 4, 5, 7, 8, 9}

运行结果

比较次数0
比较次数1
比较次数2
比较次数3
比较次数4
比较次数5
比较次数6
第0轮冒泡[1, 2, 3, 4, 5, 7, 8, 9]

再优化

每轮冒泡时，最后一次交换索引可以作为下一轮冒泡的比较次数，如果这个值为零，表示整个数组有序，直接退出外层循环即可.

/**
 * @author pzz
 * @date 2022/5/24
 * 冒泡排序
 */
public class BubbleSort {
    public static void main(String[] args) {
        int[] a = {5, 2, 7, 4, 1, 3, 8, 9};
//        int[] a = {1, 2, 3, 4, 5, 7, 8, 9};
        bubble_v3(a);
    }

    //优化2
    private static void bubble_v3(int[] arr) {
        //记录索引是否为初始位置，一个指针
        int n = arr.length - 1;
        //记录循环次数
        int x = 0;
        while (true){
            //最后一次交换的位置
            int last = 0;
            for(int j = 0;j < n;++j){
                System.out.println("比较次数" + j);
                if(arr[j] > arr[j + 1]){
                    swap(arr,j,j + 1);
                    //发生交换的坐标
                    last = j;
                }
            }
            n = last;
            System.out.println("第" + x++ + "轮冒泡"+ Arrays.toString(arr));
            //指针为初始位置，退出循环
            if (n == 0){
                break;
            }
        }
    }

    public static void swap(int[] array, int i, int j) {
        int t = array[i];
        array[i] = array[j];
        array[j] = t;
    }
}

运行结果

比较次数0
比较次数1
比较次数2
比较次数3
比较次数4
比较次数5
比较次数6
第0轮冒泡[2, 5, 4, 1, 3, 7, 8, 9]
比较次数0
比较次数1
比较次数2
比较次数3
第1轮冒泡[2, 4, 1, 3, 5, 7, 8, 9]
比较次数0
比较次数1
比较次数2
第2轮冒泡[2, 1, 3, 4, 5, 7, 8, 9]
比较次数0
比较次数1
第3轮冒泡[1, 2, 3, 4, 5, 7, 8, 9]

当数组有序时
int[] a = {1, 2, 3, 4, 5, 7, 8, 9}

运行结果

比较次数0
比较次数1
比较次数2
比较次数3
比较次数4
比较次数5
比较次数6
第0轮冒泡[1, 2, 3, 4, 5, 7, 8, 9]

结束！！

---

						每当我们过得不好时，总是会怀念曾经那段快乐的日子。