Java语言——冒泡排序

1. 问题简介

在计算机科学的世界里，排序算法是数据处理的基础之一，而冒泡排序作为最简单直观的排序算法之一，是每个程序员学习之旅的必经之路。本文将带您深入探索冒泡排序的基本原理、Java实现代码以及如何对其进行优化，以提高效率。

3. 冒泡排序简介

3.1 简介

冒泡排序，英文名Bubble Sort，其基本思想是通过重复遍历待排序的数列，比较相邻元素的值，如果顺序错误（即前一个元素大于后一个元素），就交换它们的位置。这样，每一轮遍历后，最大的元素就像水中的气泡一样“浮”到了数列的末尾。因此得名“冒泡排序”。

3.2.基本原理

1. 比较相邻的元素。如果第一个元素比第二个元素大，就交换它们两个的位置。
2. 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
3. 针对所有的元素重复以上的步骤，除了最后一个。
4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

4. 动图演示

我想到另外一种办法了，视频格式csdn还是传不上去，但是我将视频转为gif格式，以图片的格式是可以上传的，大家以后遇到这个问题，注意一下就好了。

5. Java代码实现

5.1 基本实现

public class BubbleSort {

    /**
     * 冒泡排序：每次交换都是相邻(从小到大)
     * @param arr 等待排序的数组
     */
    public static void bubbleSort(int[] arr) {
        int n = arr.length;
        // 用于优化，检查本轮是否进行了交换
        boolean swapped;

        for (int i = 0; i < n-1; i++) {
            swapped = false;
            for (int j = 0; j < n-i-1; j++) {
                if (arr[j] > arr[j+1]) {
                    // 交换 arr[j+1] 和 arr[j]
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                    swapped = true;
                }
            }
            // 如果在某轮遍历中没有发生交换，说明数组已经是有序的了，可以提前结束排序
            if (!swapped) {
                break;
            }
        }
    }
    public static void main(String[] args) {
        int[] arr = {66, 33, 22, 11, 22, 44, 99};
        System.out.println("====排序之前的数组===========");
        for (int i=0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
        System.out.println("====排序之后的数组===========");
        bubbleSort(arr);
        for (int i=0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

最终控制台打印效果如下：

5.2 代码优化

虽然上面的代码已经实现了排序的功能，但是代码还不够优雅。对于一个追求完美的程序员来说，自然是需要优化一下了，优化之前先说明上述代码存在的问题：
1.排序与交换放在一个方法中，代码显得有些臃肿。
2.main()方法承担了打印数组的代码写了两次for循环。如果每次都这样写，那工作量岂不是太大了，所以必须优化。既然知道问题所在，那么优化起来，自然就是水到渠成的事儿了。
优化方案如下：
1.将交换数据封装一个通用的方法，方便后续写选择排序、插入排序，需要交换数据的时候直接调用
2.将打印数组元素，封装一个通用的方法，方便对照排序前后打印的测试
废话不多说，直接上代码：

public class BubbleSort {

    /**
     * 交换方法：交换一个整型数组中指定下标的两个元素。
     *
     * @param array  需要进行元素交换的整型数组
     * @param first  需要交换的第一个元素的下标。
     * @param second 需要交换的第二个元素的下标。
     */
    public static void swap(int[] array, int first, int second) {
        // 用临时变量存储array数组中第second个元素的值
        int temp = array[second];

        // 将array数组中第second个元素的值更新为第first个元素的值
        array[second] = array[first];

        // 将array数组中第first个元素的值更新为temp变量的值。
        array[first] = temp;
    }

    /**
     * 冒泡排序：对输入的整型数组进行排序
     *
     * @param array 等待输入的整型数组
     */
    public static void bubbleSort(int[] array) {
        // 边界处理: 若只有一个元素or没有元素,则不进行排序
        if (array == null || array.length < 2) {
            return;
        }

        // 获取数组的长度
        int n = array.length;
        // 从数组的最后一个元素开始向前遍历，直到第一个元素。
        for (int end = n - 1; end >= 0; end--) {
            // 内层循环使用变量second从第二个元素开始，遍历到当前外层循环的位置end。
            for (int second = 1; second <= end; second++) {
                // 比较相邻的两个元素，如果前一个元素比后一个元素大，则交换它们的位置。
                if (array[second - 1] > array[second]) {
                    swap(array, second - 1, second);
                }
            }
        }
    }

    /**
     * 打印整型数组元素
     *
     * @param array 等待打印的整型数组
     */
    public static void printArray(int[] array) {
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        int[] arr = {66, 33, 22, 11, 22, 44, 99};
        System.out.println("====排序之前的数组元素===========");
        printArray(arr);
        bubbleSort(arr);
        System.out.println("====排序之后的数组元素===========");
        printArray(arr);
    }
}

控制台打印效果如下：

6. 算法分析

冒泡排序算法的时间复杂度为O(n^2)，其中n是要排序的元素个数。在最坏情况下，即数组已经按照相反的顺序排列时，需要进行n(n-1)/2次比较和交换操作。因此，冒泡排序算法在处理大规模数据时效率较低。
虽然冒泡排序算法的时间复杂度较高，但是它的实现简单易懂，可以作为排序算法的入门练习。同时，由于冒泡排序算法是稳定的，因此在某些特殊情况下，它仍然可以被使用。

7. 总结

冒泡排序以其简单直接的逻辑，成为学习排序算法的入门之选。虽然在效率上不占优势，但它为我们理解排序原理和算法设计提供了很好的示例。希望本文能帮助您更好地掌握冒泡排序及其背后的逻辑，为您的编程之旅增添一份坚实的基础。以上就是关于冒泡排序的简要介绍和实现，如果您有任何疑问或需要进一步探讨的话题，欢迎留言讨论！