交换排序:冒泡排序 vs 快速排序(Java)

一、冒泡排序

1. 标准版代码

java 复制代码
public void bubbleSort01(int[] arr) {
    int n = arr.length;
    for (int i = 0; i < n - 1; i++) {
        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;
            }
        }
    }
}

2. 优化版代码(提前终止)

java 复制代码
public void bubbleSort02(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;
    }
}

3. 复杂度与稳定性

指标 值
最好时间复杂度 O(n)(优化版,已有序)
最坏时间复杂度 O(n²)
平均时间复杂度 O(n²)
空间复杂度 O(1)
稳定性 ✅ 稳定

4. 适用场景

  • 数据量小(<1000)

  • 数据基本有序(优化版效率高)

  • 教学演示


二、快速排序

1. 核心思路

选一个基准(pivot),把比它小的放左边,比它大的放右边,然后递归处理左右两边。

2. 代码(随机基准版)

java 复制代码
public void quickSort(int[] arr, int left, int right) {
    if (left >= right) return;
    int pivotIndex = partition(arr, left, right);
    quickSort(arr, left, pivotIndex - 1);
    quickSort(arr, pivotIndex + 1, right);
}

public int partition(int[] arr, int left, int right) {
    // 随机选基准,避免最坏情况
    int randomIndex = left + (int)(Math.random() * (right - left + 1));
    swap(arr, randomIndex, right);
    
    int pivot = arr[right];
    int i = left;
    for (int j = left; j < right; j++) {
        if (arr[j] <= pivot) {
            swap(arr, i, j);
            i++;
        }
    }
    swap(arr, i, right);
    return i;
}

public void swap(int[] arr, int i, int j) {
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

3. 复杂度与稳定性

指标 值
最好时间复杂度 O(n log n)
最坏时间复杂度 O(n²)(随机化后几乎不出现)
平均时间复杂度 O(n log n)
空间复杂度 O(log n)(递归栈)
稳定性 ❌ 不稳定

4. 为什么快排不稳定?

快排的不稳定性来源于分区时的远距离交换。

举例:[(3A), 2, (3B)](括号表示相同值 3,A 和 B 区分顺序)

  • 以 2 为基准分区后,3A 和 3B 的相对顺序可能改变

  • 因为 swap 会把右边的小元素换到左边,可能让 3B 跑到 3A 前面

而冒泡排序只交换相邻元素,相同值的元素不会互相跨越,所以是稳定的。

5. 适用场景

  • 数据量大、不要求稳定性

  • 平均性能最好的通用排序


三、两者对比总结

对比项 冒泡排序 快速排序
最好时间复杂度 O(n) O(n log n)
最坏时间复杂度 O(n²) O(n²)(随机化后极少出现)
平均时间复杂度 O(n²) O(n log n)
空间复杂度 O(1) O(log n)
稳定性 ✅ 稳定 ❌ 不稳定
数据量大时 慢 快
数据基本有序时 快(优化版) 反而可能慢(固定基准)

如何选择?

场景 推荐算法 原因
数据量小(<1000) 冒泡排序 简单,常数小
数据量大、不要求稳定 快速排序 最快
数据量大、要求稳定 归并排序 稳定 O(n log n)
数据基本有序 冒泡排序(优化版) O(n)

四、扩展:快速排序的优化技巧(选读)

  1. 随机选基准(已实现)→ 避免最坏情况

  2. 三数取中 → 更稳定的基准选择

  3. 小数组切换插入排序 → 减少递归深度

  4. 尾递归优化 → 节省栈空间


五、总结

冒泡排序 :简单、稳定、适合小数据,优化版对基本有序数据友好。
快速排序:高效、不稳定、适合大数据,随机选基准避免了最坏情况。

复习:01dx

相关推荐
顧棟10 小时前
组件生命周期设计:从硬编码初始化到状态机
java·ide
Pniubi10 小时前
01背包类问题-力扣416.分割等和子集
算法·leetcode·职场和发展
特立独行的猫A18 小时前
别再用 nohup 了:让应用在后台常驻的正确姿势与 systemd 服务详解
java·后端·python
一起_java18 小时前
技术文章-基于Dify-Agent的智能问答系统设计与实现
java·spring boot·后端·agent·dify
Flynn Liang20 小时前
I/O 密集型高并发实战:Java 服务 10 维优化,从线程打满到 10 万 QPS
java·spring boot·性能优化·高并发·系统设计·虚拟线程·io密集型
吃我一窝jio21 小时前
Python与Go线程模型深度对比
java·开发语言·python
这个昵称不容易21 小时前
SpringBoot 购物推荐网站的设计与实现:120 个 Java 文件、147 个接口、13 张表,附真实运行截图
java·springboot·毕设
文丑颜不良啊21 小时前
LeetCode3041~3060题目解析
java·leetcode
罗西的思考21 小时前
【轻量化复现大模型 / KIMI K3】MTP / EAGLE‑3 模块交互式演示
人工智能·深度学习·算法
文丑颜不良啊1 天前
LeetCode3101~3120题目解析
java·leetcode