Java 排序算法详解：冒泡排序、选择排序、堆排序

在学习算法的过程中，排序是非常重要的一部分，它不仅是面试常考题，也是理解算法思路和复杂度分析的基础。今天，我们来讲三种经典排序算法：冒泡排序、选择排序、堆排序，并附上可运行的 Java 示例。

冒泡排序（Bubble Sort）

概念

冒泡排序是一种交换排序，通过重复比较相邻元素，将较大的元素慢慢"冒泡"到数组的末尾。
特点

时间复杂度：O(n²)

空间复杂度：O(1)

稳定排序（相等元素相对位置不变）
思路

从数组的第一个元素开始，依次比较相邻两个元素，如果前一个比后一个大，则交换。

每一轮循环后，最大的元素会被放到最后。

重复步骤 1 和 2，直到所有元素有序。

java 复制代码

public class BubbleSortDemo {
    public static void bubbleSort(int[] arr) {
        int n = arr.length;
        for (int i = 0; i < n - 1; i++) {
            boolean swapped = false; // 优化：如果一轮没有交换，则提前结束
            for (int j = 0; j < n - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    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 = {5, 2, 9, 1, 5, 6};
        System.out.println("排序前：" + java.util.Arrays.toString(arr));
        bubbleSort(arr);
        System.out.println("排序后：" + java.util.Arrays.toString(arr));
    }
}

选择排序（Selection Sort）

概念

选择排序是一种选择最小（或最大）元素的排序方法，每次从未排序部分选择最小元素，放到已排序部分的末尾。
特点

时间复杂度：O(n²)

空间复杂度：O(1)

不稳定排序（相等元素可能改变顺序）
思路

从数组中找到最小元素。

将其与当前未排序区的第一个元素交换。

将已排序区的范围加1，重复步骤 1 和 2。

java 复制代码

public class SelectionSortDemo {
    public static void selectionSort(int[] arr) {
        int n = arr.length;
        for (int i = 0; i < n - 1; i++) {
            int minIndex = i;
            for (int j = i + 1; j < n; j++) {
                if (arr[j] < arr[minIndex]) {
                    minIndex = j;
                }
            }
            // 交换
            int temp = arr[i];
            arr[i] = arr[minIndex];
            arr[minIndex] = temp;
        }
    }

    public static void main(String[] args) {
        int[] arr = {64, 25, 12, 22, 11};
        System.out.println("排序前：" + java.util.Arrays.toString(arr));
        selectionSort(arr);
        System.out.println("排序后：" + java.util.Arrays.toString(arr));
    }
}

堆排序（Heap Sort）

概念

堆排序是一种利用堆（Heap）结构的选择排序，通过构建最大堆或者最小堆实现排序。

最大堆：父节点 >= 子节点，适合升序排序

最小堆：父节点 <= 子节点，适合降序排序
特点

时间复杂度：O(n log n)

空间复杂度：O(1)

不稳定排序
思路

构建最大堆。

将堆顶（最大值）与最后一个元素交换，然后对剩余部分重新调整堆。

重复步骤 2，直到所有元素有序。

java 复制代码

public class HeapSortDemo {

    public static void heapSort(int[] arr) {
        int n = arr.length;

        // 构建最大堆
        for (int i = n / 2 - 1; i >= 0; i--) {
            heapify(arr, n, i);
        }

        // 逐个将堆顶元素与末尾元素交换，并重新调整堆
        for (int i = n - 1; i > 0; i--) {
            int temp = arr[0];
            arr[0] = arr[i];
            arr[i] = temp;

            heapify(arr, i, 0); // 调整剩余部分
        }
    }

    // 堆化函数
    private static void heapify(int[] arr, int heapSize, int rootIndex) {
        int largest = rootIndex;
        int left = 2 * rootIndex + 1;
        int right = 2 * rootIndex + 2;

        if (left < heapSize && arr[left] > arr[largest]) {
            largest = left;
        }
        if (right < heapSize && arr[right] > arr[largest]) {
            largest = right;
        }
        if (largest != rootIndex) {
            int swap = arr[rootIndex];
            arr[rootIndex] = arr[largest];
            arr[largest] = swap;

            heapify(arr, heapSize, largest);
        }
    }

    public static void main(String[] args) {
        int[] arr = {12, 11, 13, 5, 6, 7};
        System.out.println("排序前：" + java.util.Arrays.toString(arr));
        heapSort(arr);
        System.out.println("排序后：" + java.util.Arrays.toString(arr));
    }
}