Java交换排序之冒泡排序与快速排序代码实例

作者：袖梨 2026-08-10

Java交换排序之冒泡排序与快速排序代码实例需要先看清适用场景和关键步骤，避免只记结论却忽略实际限制。

一、冒泡排序

1. 标准版代码

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. 优化版代码（提前终止）

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. 代码（随机基准版）

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)