前言

Halo，最近都在忙些什么呢？大家应该都知道我是做运维的，大学所学的专业也是网络技术专业，但心里一直更倾向于从事开发相关的工作，因为对编程的热爱，至于为什么最终选择了运维，这背后有不少原因，等以后有时间再和大家聊聊！

前段时间学校组织报名了第十六届JAVA蓝桥杯比赛，不过学校只给了一个名额，也不知道哪里来的勇气想去尝试一下，结果恍恍惚惚地就被选上了！

虽然有点措手不及，但这也是一个难得的机会，所以我最近正在为4月份的比赛做准备。同时也想趁这个机会给大家讲解一下最简单基础的排序算法，希望对大家有所帮助！

冒泡排序

冒泡排序是一种简单的排序算法，它通过重复地遍历待排序的数列，比较相邻元素并交换它们的位置。如果前一个元素比后一个元素大，就交换它们，直到整个数列有序。

算法步骤

1. 从数组的第一个元素开始，依次比较相邻的元素。
2. 如果前一个元素比后一个元素大，则交换这两个元素。
3. 每次遍历后，最大的元素会“冒泡”到数组的末端。
4. 重复上述过程，直到整个数组有序。

演示动画

基础版冒泡排序代码

int[] array = {9, 10, 3, 4, 5, 6, 7, 8, 1, 2};          //初始数组
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array.length - 1; j++) {
                if (array[j] < array[j + 1]) {
                    // 交换相邻元素
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
        }

进一步优化：减少遍历的范围

在优化版中，我们每一轮排序都会将一个最小值移动到数组的末尾，因此每次排序后，已排序的部分可以不再参与接下来的排序，我们可以通过减少每一轮的遍历范围来进一步优化

int[] array = {9, 10, 3, 4, 5, 6, 7, 8, 1, 2};          //初始数组
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array.length - 1 - i; j++) {        //减小范围
                if (array[j] < array[j + 1]) {
                    // 交换相邻元素
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
        }

优化版：减少无用的比较

我们来查看一下，每次交换完成之后的数据

10 9 4 5 6 7 8 3 2 1           //第1次交换
10 9 5 6 7 8 4 3 2 1            //第2次交换
10 9 6 7 8 5 4 3 2 1            //第3次交换
10 9 7 8 6 5 4 3 2 1            //第4次交换
10 9 8 7 6 5 4 3 2 1            //第5次交换
10 9 8 7 6 5 4 3 2 1            //第6次交换
10 9 8 7 6 5 4 3 2 1            //第7次交换
10 9 8 7 6 5 4 3 2 1            //第8次交换
10 9 8 7 6 5 4 3 2 1            //第9次交换
10 9 8 7 6 5 4 3 2 1            //第10次交换

大家可以看到，在第五次交换的时，即使数组已经部分或完全有序，算法仍然会继续进行所有的比较，我们可以通过引入一个“交换标志”来优化这个过程，如果在某一趟遍历中没有进行任何交换，说明数组已经有序，可以提前结束排序。

int[] array = {9, 10, 3, 4, 5, 6, 7, 8, 1, 2};           //初始数组
        for (int i = 0; i < array.length; i++) {
            boolean flag = true;            // 标记是否有交换发生
            for (int j = 0; j < array.length - 1 - i; j++) {        // 每次遍历的范围缩小
                if (array[j] < array[j + 1]) {
                    // 交换相邻元素
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                    flag = false;           //当本次循环有值进行交换时，flag值改为false;
                }
            }
            if (flag) {         // 如果没有交换发生，说明数组已经是有序的，提前退出
                break;
            }
        }

参考文章：https://blog.csdn.net/weixin_45499166/article/details/118105847

持续更新中......