Java交换排序之冒泡排序与快速排序代码实例_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)