Java算法——冒泡排序

冒泡排序（Bubble Sort）思想

冒泡排序是一种简单的交换排序算法。其核心思想是通过多次遍历数组，从头到尾依次比较相邻的两个元素，并交换它们的位置，确保较大的元素逐渐“冒泡”到数组的末尾。

主要思想：

1. 比较相邻元素：依次比较数组中相邻的两个元素，如果前一个元素比后一个元素大，则交换它们的位置。
2. 重复过程：对数组进行多次遍历，每次遍历后最大的元素会被“冒泡”到数组的末尾。
3. 减少遍历范围：由于每次遍历后最后一个元素已经是最大的，因此可以在下一次遍历时减少已排序部分的范围。

时间复杂度

• 最坏情况时间复杂度：(O(n^2))（当数组是逆序时，需要进行最多的交换）
• 平均时间复杂度：(O(n^2))
• 最好情况时间复杂度：(O(n))（当数组已经有序时，只需进行一次遍历）
• 空间复杂度：(O(1))（因为它是就地排序算法）

Java 实现

public class BubbleSort {

    // 冒泡排序方法
    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 - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    // 交换相邻元素
                    swap(arr, j, j + 1);
                    swapped = true;
                }
            }
            // 如果一次完整的遍历中没有发生交换，则说明数组已排序
            if (!swapped) break;
        }
    }

    // 交换数组中的两个元素
    private void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

    // 打印数组方法
    public static void printArray(int[] arr) {
        for (int num : arr) {
            System.out.print(num + " ");
        }
        System.out.println();
    }

    // 主方法
    public static void main(String[] args) {
        BubbleSort sorter = new BubbleSort();
        int[] arr = { 64, 34, 25, 12, 22, 11, 90 };
        System.out.println("Unsorted array:");
        printArray(arr);

        sorter.bubbleSort(arr);

        System.out.println("\nSorted array:");
        printArray(arr);
    }
}

代码解析

1. 外层循环：控制遍历的次数，总共需要进行 (n-1) 次遍历，每次遍历使得当前最大元素冒泡到未排序部分的末尾。
2. 内层循环：用于比较和交换相邻的元素，范围是从数组开始到未排序部分的末尾。每次遍历结束后，最后一个元素是当前未排序部分的最大值。
3. 交换元素：当前一个元素比后一个元素大时，交换它们的位置。
4. 优化：使用 swapped 标志，如果在某次遍历中没有发生任何交换，说明数组已经有序，可以提前终止排序过程。

总结

冒泡排序是一种基础的排序算法，虽然其时间复杂度较高，但实现简单，适合对小规模数据进行排序或教学演示。通过优化（如提前终止），可以在最佳情况下实现线性时间复杂度。尽管如此，对于大型数据集，冒泡排序效率较低，不推荐使用。