深入 Java 排序算法详解：从基础到进阶的四大经典排序

Java 四大经典排序算法详解

原创已于 2025-08-02 17:35:29 修改 · 691 阅读

15 ·

CC 4.0 BY-SA版权

文章标签：

#排序算法 #java #算法

于 2025-07-31 17:36:33 首次发布

排序算法是计算机科学的基础，也是面试中的高频考点。无论是处理日常数据还是构建高效系统，选择合适的排序算法都至关重要。本文将详细解析四种经典排序算法 —— 冒泡排序、快速排序、插入排序和希尔排序，包括它们的实现思路、代码示例、时间复杂度及适用场景，帮助你深入理解并灵活运用这些算法。

一、冒泡排序：最简单直观的排序

冒泡排序（Bubble Sort）是最基础的排序算法之一，其核心思想正如其名 —— 像水中的气泡一样，将大的元素逐步 "浮" 到数组末端。

1. 算法思路

相邻元素两两比较，若前一个元素大于后一个，则交换位置
每一轮遍历都会将当前未排序部分的最大值 "冒泡" 到末尾
重复上述过程，直到所有元素有序

2. 代码实现

import java.util.Arrays;

public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = {5, 7, 4, 2, 0, 3, 1, 6};
        sort(arr);
        System.out.println(Arrays.toString(arr)); // 输出：[0, 1, 2, 3, 4, 5, 6, 7]
    }
    
    public static void sort(int[] arr) {
        for (int j = 0; j < arr.length; j++) {
            for (int i = 0; i < arr.length - 1 - j; i++) { // 优化：每轮减少一次比较
                if (arr[i] > arr[i + 1]) {
                    // 交换元素
                    int temp = arr[i];
                    arr[i] = arr[i + 1];
                    arr[i + 1] = temp;
                }
            }
        }
    }
}

注意：代码中添加了一个小优化 ——arr.length - 1 - j，因为每轮排序后，末尾的 j 个元素已经是有序的，无需再比较。

3. 算法分析

时间复杂度：
- 最坏情况（逆序数组）：O (n²)
- 最好情况（已排序数组）：O (n)（可通过添加标志位进一步优化）
- 平均情况：O (n²)
空间复杂度：O (1)（仅使用常数级额外空间）
稳定性：稳定排序（相同元素的相对位置不会改变）

4. 适用场景

冒泡排序实现简单，易于理解，但效率较低，适合：

教学演示和算法入门学习
处理小规模数据（n < 1000）
对排序稳定性有要求的场景

二、快速排序：高性能的分治排序

快速排序（Quick Sort）是实践中应用最广泛的排序算法之一，采用分治思想，具有出色的平均性能。

1. 算法思路

选择一个 "基准值"（pivot）
将数组分为两部分：小于基准值的元素和大于基准值的元素（分区操作）
对左右两部分递归执行快速排序，直到子数组长度为 1

2. 代码实现

import java.util.Arrays;

public class QuickSort {
    public static void main(String[] args) {
        int[] arr = {5, 7, 4, 2, 0, 3, 1, 6};
        sort(arr, 0, arr.length - 1);
        System.out.println(Arrays.toString(arr)); // 输出：[0, 1, 2, 3, 4, 5, 6, 7]
    }
    
    public static void sort(int[] arr, int left, int right) {
        if (left >= right) {
            return; // 递归终止条件：子数组长度为1
        }
        
        int base = arr[left]; // 选择最左元素作为基准值
        int i = left;
        int j = right;
        
        // 分区操作
        while (i != j) {
            // 从右向左找小于基准值的元素
            while (arr[j] >= base && i != j) {
                j--;
            }
            // 从左向右找大于基准值的元素
            while (arr[i] <= base && i != j) {
                i++;
            }
            // 交换找到的两个元素
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
        
        // 将基准值放到最终位置
        arr[left] = arr[i];
        arr[i] = base;
        
        // 递归排序左半部分
        sort(arr, left, i - 1);
        // 递归排序右半部分
        sort(arr, i + 1, right);
    }
}

3. 算法分析

时间复杂度：
- 平均情况：O (nlogn)
- 最坏情况（已排序数组且选择端点为基准）：O (n²)
- 最好情况：O (nlogn)
空间复杂度：O (logn)~O (n)（递归调用栈占用的空间）
稳定性：不稳定排序（相同元素的相对位置可能改变）

4. 适用场景

快速排序是综合性能最优的排序算法之一，适合：

大规模数据排序（n > 1000）
随机分布的数据（性能最佳）
对排序效率要求高的场景

优化技巧：选择合适的基准值（如三数取中法）可避免最坏情况，大幅提升性能。

三、插入排序：适合近乎有序的数据

插入排序（Insertion Sort）的思想类似于整理扑克牌，将元素逐个插入到已排序的部分中。

1. 算法思路

假设数组的第一个元素已排序
从第二个元素开始，将其与已排序部分的元素依次比较
找到合适位置并插入，使已排序部分始终保持有序
重复上述过程，直到所有元素插入完成

2. 代码实现

import java.util.Arrays;

public class InsertSort {
    public static void main(String[] args) {
        int[] arr = {22, 53, 123, 324, 12, 23, 1};
        sort(arr);
        System.out.println(Arrays.toString(arr)); // 输出：[1, 12, 22, 23, 53, 123, 324]
    }
    
    public static void sort(int[] arr) {
        for (int i = 1; i < arr.length; i++) {
            // 将arr[i]插入到前面已排序的部分
            for (int j = i - 1; j >= 0; j--) {
                if (arr[j] > arr[j + 1]) {
                    // 交换元素
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                } else {
                    break; // 已找到合适位置，提前退出
                }
            }
        }
    }
}

3. 算法分析

时间复杂度：
- 最坏情况（逆序数组）：O (n²)
- 最好情况（已排序数组）：O (n)
- 平均情况：O (n²)
空间复杂度：O(1)
稳定性：稳定排序

4. 适用场景

插入排序在处理近乎有序的数据时性能优异，适合：

小规模数据排序
数据基本有序的场景（如数据库索引维护）
作为复杂排序算法的子过程（如归并排序、快速排序的优化）

四、希尔排序：插入排序的高效改进版

希尔排序（Shell Sort）又称 "缩小增量排序"，是插入排序的改进版本，通过分组排序大幅提升效率。

1. 算法思路

选择初始增量（通常为数组长度的一半）
按增量将数组分为多个子数组，对每个子数组进行插入排序
逐步缩小增量（通常减半），重复分组和排序
当增量为 1 时，进行最后一次插入排序（此时数组已接近有序）

2. 代码实现

import java.util.Arrays;

public class ShellSort {
    public static void main(String[] args) {
        int[] arr = {5, 7, 4, 2, 0, 3, 1, 6};
        sort(arr);
        System.out.println(Arrays.toString(arr)); // 输出：[0, 1, 2, 3, 4, 5, 6, 7]
    }
    
    public static void sort(int[] arr) {
        // 初始增量为数组长度的一半，每次减半
        for (int gap = arr.length / 2; gap > 0; gap /= 2) {
            // 遍历每个子数组的元素
            for (int i = gap; i < arr.length; i++) {
                // 对每个子数组进行插入排序
                for (int j = i - gap; j >= 0; j -= gap) {
                    if (arr[j] > arr[j + gap]) {
                        // 交换元素
                        int temp = arr[j];
                        arr[j] = arr[j + gap];
                        arr[j + gap] = temp;
                    } else {
                        break; // 已找到合适位置，提前退出
                    }
                }
            }
        }
    }
}

3. 算法分析

时间复杂度：
- 取决于增量序列，平均约为 O (nlogn)
- 最坏情况：O (n²)（取决于增量选择）
空间复杂度：O(1)
稳定性：不稳定排序

4. 适用场景

希尔排序是对插入排序的有效改进，适合：

中等规模数据排序
对内存使用有严格限制的场景
不要求排序稳定性的情况

五、四大排序算法对比与选择指南

排序算法	平均时间复杂度	最坏时间复杂度	空间复杂度	稳定性	适用场景
冒泡排序	O(n²)	O(n²)	O(1)	稳定	小规模数据、教学演示
快速排序	O(nlogn)	O(n²)	O(logn)	不稳定	大规模随机数据、追求效率
插入排序	O(n²)	O(n²)	O(1)	稳定	小规模数据、近乎有序数据
希尔排序	O(nlogn)	O(n²)	O(1)	不稳定	中等规模数据、内存受限场景