Java必须掌握的冒泡排序（含面试大厂题含源码）

冒泡排序是一种简单的排序算法，它通过重复遍历待排序的元素列，比较相邻的两个元素并在必要时交换它们的位置，从而使得特定的元素“浮”到数组的一端。面试大厂时，了解冒泡排序的以下关键知识点会非常有帮助：

1. 基本原理

• 冒泡排序的基本思想是通过对待排序数组的连续的遍历，使得每次遍历都能找出未排序部分的最大（或最小）值，将其放到正确的位置上。
• 在每一轮遍历中，算法都会比较相邻的元素，并在这些元素不按排序顺序排列时，交换它们的位置。

2. 算法步骤

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

3. 复杂度分析

• 时间复杂度：平均情况和最坏情况下的时间复杂度都是 O(n^2)，其中 n 是数组长度。最好情况（已经排序的数组）的时间复杂度是 O(n)。
• 空间复杂度：O(1)，因为排序是原地进行的。

4. 优化

冒泡排序可以通过设置一个标志位来优化。如果在一次遍历中发生了交换，那么表明数组可能仍未完全排序；如果没有交换，那么数组已经排好序，可以结束排序。

5. 特点

• 简单，但效率较低。
• 稳定排序：相等的元素之间不会改变顺序。
• 原地排序（不需要额外的存储空间）。

6. 应用场景

由于其低效的排序效率，在处理大数据集时不推荐使用冒泡排序。但它是一个不错的教学工具，可以用来介绍排序算法的概念。

示例代码

以下是一个简单的冒泡排序实现示例：

public 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] 和 arr[j+1]
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
                swapped = true;
            }
        }
        // 如果没有发生交换，则说明数组已经有序，无需继续排序
        if (!swapped) break;
    }
}

掌握这些知识点能帮助你在面试中更好地解释冒泡排序的原理和性能，展现你对基本排序算法的深入理解。在面试大厂时，考察冒泡排序算法的变种和优化以及其与其他排序算法的比较是很常见的。下面是三道相关的面试题，包括解题思路和Java实现代码：

1. 优化后的冒泡排序算法

题目描述：
实现一个优化后的冒泡排序算法，使其在最佳情况下（输入数组已经是排序好的）具有线性时间复杂度。

解题思路：
通过设置一个布尔变量来标记某次遍历中是否发生了元素之间的交换。如果在整个遍历过程中没有发生交换，说明数组已经是排序好的，可以立即结束排序过程。

源码实现：

public void optimizedBubbleSort(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] 和 arr[j + 1]
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
                swapped = true;
            }
        }
        if (!swapped) break;
    }
}

2. 比较冒泡排序与插入排序

题目描述：
比较冒泡排序和插入排序的算法时间复杂度和稳定性，并实现一个插入排序算法。

解题思路：

• 时间复杂度：冒泡排序和插入排序在平均和最坏情况下的时间复杂度都是O(n^2)，但插入排序在最佳情况下的时间复杂度为O(n)。
• 稳定性：冒泡排序和插入排序都是稳定的排序算法。

插入排序源码实现：

public void insertionSort(int[] arr) {
    int n = arr.length;
    for (int i = 1; i < n; ++i) {
        int key = arr[i];
        int j = i - 1;

        // 将 arr[i] 插入到已排序序列 arr[0...i-1] 中的正确位置
        while (j >= 0 && arr[j] > key) {
            arr[j + 1] = arr[j];
            j = j - 1;
        }
        arr[j + 1] = key;
    }
}

3. 冒泡排序的逆序对计数

题目描述：
使用冒泡排序的思想编写一个函数，计算一个数组中的逆序对数量。逆序对是数组中一对元素，其中前者大于后者。

解题思路：
在冒泡排序的每一次元素交换过程中，实际上是减少了一对逆序对。通过修改冒泡排序算法，可以在排序的同时计算逆序对的数量。

源码实现：

public int countInversions(int[] arr) {
    int n = arr.length;
    int inversionCount = 0;
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                // 交换元素同时增加逆序对的数量
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
                inversionCount++;
            }
        }
    }
    return inversionCount;
}

这些题目不仅考察了你对冒泡排序算法的理解和应用，还扩展到了其他排序算法和相关概念，帮助你全面准备面试大厂的算法题。