Java排序算法深度解析：从冒泡到快排的原理、优化与面试考点

提到排序算法，很多朋友第一反应是“面试八股文”，背完就忘，工作里好像也用不上。但说实话，排序算法里藏着的思想，比我见过的大部分“高级架构”都值钱。冒泡排序和快速排序，一个是算法启蒙老师，一个是实战中的性能标杆，这俩连起来看，正好能看到一个程序员从“能写代码”到“会写代码”的进化路径。

这篇内容我会结合Java实现，把两个算法的原理、代码、优化、面试考点一次性讲透。不管你是在准备面试，还是写业务代码时突然需要对一个集合排序，希望这篇能真正帮到你。同时也会聊聊排序算法在真实业务中的选型思路，以及很多文档里不会写的性能优化细节。

1. 排序算法在Java中的基本功：从冒泡到快排的思维跃迁

1.1 为什么每个Java开发者都得过排序这道坎

先别急着觉得排序“太基础”。我在实际面试中筛过不少人，真到白板写快排，能一次写对边界条件的候选人，比例低得惊人。排序算法考察的不只是语法，而是你对循环边界、递归终止、数组索引这些基本功的掌握程度。

Java写排序又尤其特殊。Java的数组是引用类型，sort方法操作的是原数组本身的引用，而不是值拷贝。这就意味着，你在排序方法里对数组做的修改，会直接影响调用方。很多人写排序方法时没注意这一点，以为传进去的是副本，结果在业务代码里排查了半天“数据怎么被改了”。

另外一点，Java的自动装箱机制在排序时是个隐藏性能杀手。如果你用List<Integer>直接排序，每个int都会装箱成Integer对象，排序过程中的每一次比较都会触发一次拆箱。数据量小还好，一旦上了百万级别，性能差距就非常明显。这也是为什么我建议用基本类型数组（int[]）而不是包装类集合（List<Integer>）来写排序核心逻辑。

再来说说这两种算法的定位。冒泡排序是“稳”的代表——稳定排序、实现简单、容易理解，但平均时间复杂度是O(n²)，数据稍大就崩。快速排序是“快”的标杆——平均时间O(n log n)，但最坏情况退化到O(n²)，而且它是不稳定排序。理解每种算法的“性格”，才能在实际业务中做出正确的选型。

1.2 从O(n²)到O(n log n)：为什么冒泡慢，快排快

这是整个排序算法理解的核心，我换个方式讲。

假设你有一万个数要排。冒泡排序的思路，是把每两个相邻的数做比较，如果顺序不对就交换。每轮下来，最大的数就像气泡一样“浮”到最后面。如果数组基本有序，它也会傻乎乎地做完全部n-1轮比较。一万个数，差不多要做5000万次比较。

快速排序的思路则是“分而治之”。它随便挑一个数当“哨兵”，然后把剩余的数分成两拨：比哨兵小的放左边，比哨兵大的放右边。之后，左右两拨再各自重复这个过程。这种分治策略的好处在于，每一轮都能把问题的规模缩小一半，所以整体比较次数大约只有n log n级别。

我习惯用一个生活化的类比——扑克牌整理。冒泡排序就像你拿着一副乱牌，一次只比较相邻两张，然后一路交换到整副牌有序；而快速排序则像是先把牌分成“比基准小的”和“比基准大的”两堆，再对每堆递归处理，效率自然高得多。

但快排也有它的“命门”——哨兵选择不当会导致严重退化。比如一个已经有序的数组，如果每次都选第一个元素作为基准，那每次分区都极不均衡，一边有0个元素，另一边有n-1个元素，复杂度就退化成O(n²)。这就是为什么工程级排序实现里，不会简单地取第一个或最后一个元素。

2. Java实现冒泡排序的核心细节与优化

2.1 冒泡排序的基础实现：标准版代码逐行拆解

先给一份最标准、最好理解的冒泡排序Java实现，这是面试时最容易快速写出来的版本：

java复制/**
 * 标准冒泡排序
 * 时间复杂度：O(n²)
 * 空间复杂度：O(1)
 * 稳定性：稳定
 */
public static void bubbleSort(int[] arr) {
    if (arr == null || arr.length < 2) {
        return;
    }
    int n = arr.length;
    // 外层循环控制排序轮数，共需要 n-1 轮
    for (int i = 0; i < n - 1; i++) {
        // 内层循环控制每轮比较的次数
        // 第 i 轮时，最后 i 个元素已经有序，无需再比较
        for (int j = 0; j < n - 1 - i; j++) {
            // 如果前一个元素大于后一个，交换位置
            if (arr[j] > arr[j + 1]) {
                swap(arr, j, j + 1);
            }
        }
    }
}

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

这段代码有几个细节值得特别注意：

第一，n - 1 - i 这个边界条件不是拍脑袋写的。外层循环每执行一轮，就有一个元素被“冒泡”到最终位置。所以第i轮时，数组末尾已经有i个元素排好了，内层循环就没必要再跟这些元素比较。如果写成了j < n - 1，结果也能排对，但会多做很多无意义的比较。

第二，java的swap方法要自己写。不像C++里有现成的std::swap，Java没有提供数组元素交换的快速方法。建议提取成一个私有方法，避免在循环里重复写三行交换逻辑。

第三，传入数组是引用类型。我前面提过，这个方法会直接修改传入的arr数组，不会返回新数组。如果你需要在原数组不变的情况下得到排序结果，必须手动拷贝一份再传进去：

java复制int[] sorted = arr.clone();
bubbleSort(sorted);

2.2 冒泡排序的优化演进：从基础版到鸡尾酒版

基础版冒泡排序有个明显缺陷：即使数组在某轮已经全部有序了，它依然会继续执行完所有轮次。比如{1, 2, 3, 4, 5, 6, 7, 8}这个已经排好的数组，基础版依然会执行7轮。

优化思路非常简单——加一个标志位，判断本轮内层循环是否发生了交换。如果没有发生任何交换，说明数组已经有序，直接终止排序。

java复制/**
 * 优化版冒泡排序
 * 提前终止机制：某轮无交换则说明已经有序
 */
public static void bubbleSortOptimized(int[] arr) {
    if (arr == null || arr.length < 2) {
        return;
    }
    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]) {
                swap(arr, j, j + 1);
                swapped = true;
            }
        }
        // 如果没有发生交换，说明数组已有序
        if (!swapped) {
            break;
        }
    }
}

这个优化让最好情况下的时间复杂度从O(n²)直接降到了O(n)。如果传入的是一个已经排好序的数组，第一轮扫描后发现没有交换，直接break，只做了一次O(n)的比较就结束了。这在某些数据“近似有序”的场景下非常实用。

再进一步，还有鸡尾酒排序（也叫双向冒泡排序）。传统冒泡每一轮只能把一个最大值“沉底”，而鸡尾酒排序交替进行两个方向的扫描，一轮把最大值沉到末尾，下一轮把最小值“飘”到开头。这对于处理那种“前大半部分基本有序，只有少量大数在开头”的数组效率更高。

我提供一下鸡尾酒排序的实现，面试时偶尔会考到，写出这个版本能给面试官留下不错的印象：

java复制/**
 * 鸡尾酒排序（双向冒泡）
 */
public static void cocktailSort(int[] arr) {
    if (arr == null || arr.length < 2) {
        return;
    }
    int left = 0;
    int right = arr.length - 1;
    while (left < right) {
        // 从左到右，把最大值移动到右侧
        boolean swapped = false;
        for (int i = left; i < right; i++) {
            if (arr[i] > arr[i + 1]) {
                swap(arr, i, i + 1);
                swapped = true;
            }
        }
        if (!swapped) {
            break;
        }
        right--;
        
        // 从右到左，把最小值移动到左侧
        swapped = false;
        for (int i = right; i > left; i--) {
            if (arr[i] < arr[i - 1]) {
                swap(arr, i, i - 1);
                swapped = true;
            }
        }
        if (!swapped) {
            break;
        }
        left++;
    }
}

这个版本的边界条件比标准版复杂一些，left和right指针每一次循环都在收缩，维护起来需要小心。写完后建议用随机数组和有序数组各测一次。

2.3 冒泡排序的适用场景与性能边界分析

说实话，在真实业务中，我几乎没见过用冒泡排序处理超过一万条数据的场景。但这不代表它“没用”。冒泡排序真正的价值在三个方面：

• 教学价值：它是最容易理解的排序算法，适合用来建立“算法分析”的思维框架——什么是时间复杂度、什么是稳定性、怎么优化。
• 小数据量兜底：如果你处理的数据量很小（比如两位数级别），冒泡排序的简洁性反而成为优势，写起来不会出错，维护成本最低。
• 对“近乎有序”数据的高效处理：配上2.2节标志位优化后，对于基本有序的数据，冒泡排序实际表现能达到O(n)，比很多“高级”算法都稳。

性能边界上有一个非常典型的数据：当数组长度超过10万时，冒泡排序的计算量会急剧上升，在我的测试机上需要好几秒才能完成排序。同样的数据，快速排序只需要几十毫秒。这个差距在业务场景里就是“卡顿”和“流畅”的区别。

所以，如果你在业务中需要排序，优先用Java原生提供的Arrays.sort()。这个静态方法内部是工程级优化过的双基准快速排序，99%的情况下性能都是最优的。你自己手写冒泡排序，除非明确知道数据量极小，否则没有意义。

3. Java实现快速排序的核心细节与进阶技巧

3.1 快速排序的原理与分治思想拆解

快速排序的核心思想只有一句话：寻找基准元素的正确位置，然后递归处理左右两侧。

具体流程是这样的：

1. 从数组中选择一个元素，称为“基准”（pivot）。
2. 重新排列数组，所有比基准小的元素放在基准前面，所有比基准大的元素放在基准后面（相等的可以放任意一边）。这个操作称为“分区”（partition）。
3. 递归地对基准左边和右边的两个子数组重复以上步骤。

快排的平均时间复杂度是O(n log n)，这得益于分区操作的“分治”结构：每一层递归里，所有分区操作加起来只需要扫描一遍数组（O(n)），而递归深度平均是O(log n)。所以总复杂度是O(n log n)。

关键是第二步分区操作怎么高效实现。最经典的写法是Hoare分区法和Lomuto分区法。Lomuto版更简单、写起来不容易出错，适合面试和快速开发；Hoare版更高效，但边界条件更难理解，容易写错。

我先给一个基于Lomuto的完整实现，这是面试中最稳的版本：

java复制/**
 * 快速排序（Lomuto分区版）
 * 时间复杂度：平均O(n log n)，最坏O(n²)
 * 空间复杂度：O(log n)（递归栈深度）
 * 稳定性：不稳定
 */
public static void quickSort(int[] arr) {
    if (arr == null || arr.length < 2) {
        return;
    }
    quickSort(arr, 0, arr.length - 1);
}

private static void quickSort(int[] arr, int low, int high) {
    if (low >= high) {
        return;
    }
    // 获取分区点位置
    int pivotIndex = partition(arr, low, high);
    // 递归排序左右两侧
    quickSort(arr, low, pivotIndex - 1);
    quickSort(arr, pivotIndex + 1, high);
}

private static int partition(int[] arr, int low, int high) {
    // 选择最右侧元素作为基准
    int pivot = arr[high];
    // i 指向小于基准的区域的最后一位
    int i = low - 1;
    for (int j = low; j < high; j++) {
        // 如果当前元素小于等于基准，i先前进一位，再交换
        if (arr[j] <= pivot) {
            i++;
            if (i != j) {
                swap(arr, i, j);
            }
        }
    }
    // 把基准放到正确位置（i+1）
    swap(arr, i + 1, high);
    return i + 1;
}

3.2 快速排序的三种基准选择策略对比

刚才的实现里，基准直接取了arr[high]。这在数组随机排列时没问题，但如果数组已经有序，就会导致分区极度不平衡，递归深度变成n，复杂度退化成O(n²)，还可能出现栈溢出错误（StackOverflowError）——注意，Java默认的栈深度大约在几千到一万多层递归，数据量稍大就会爆栈。

所以工程开发中，基准选择是快排优化的重要一环，常见策略有三类：

我自己在业务实现里最常用的是三数取中，因为它不依赖随机数生成器，而且对“几乎有序”的数据分布适应性最好。实际效果来说，它不是理论上最优的，但工程上最省心。

java复制/**
 * 三数取中优化：选择low、mid、high中的中位数作为基准
 * 并将基准交换到high位置，保证后续partition逻辑不变
 */
private static void medianOfThree(int[] arr, int low, int high) {
    int mid = low + ((high - low) >> 1);
    // 确保 arr[low] <= arr[mid] <= arr[high] 的某种排序关系
    if (arr[mid] > arr[high]) {
        swap(arr, mid, high);
    }
    if (arr[low] > arr[high]) {
        swap(arr, low, high);
    }
    if (arr[mid] > arr[low]) {
        swap(arr, mid, low);
    }
    // 此时 arr[low] 是三个数中的中位数
}

在使用这个优化时，只需要在partition前先调用medianOfThree(arr, low, high)，然后再把arr[high]作为基准。这里我设计成了把中位数放到low位置，这样partition里面的基准逻辑可以相应调整：把基准取为arr[high]，但low位置的元素已经是中位数，所以数组最左侧放的是三个数中间的值。

这里有个细节很容易踩坑——基准的交换必须与partition逻辑保持一致。如果你改了基准位置的取值，却没有同步修改partition的初始化和swap逻辑，排序结果就会错乱。我当时第一次把“三数取中”集成到手写快排里时，就是因为只改了选择逻辑，忘了调整partition里循环的初始值，排查了半天才发现问题。

3.3 快速排序的工程级优化：三向切分与插入排序阈值

到了这一步，你的快排已经能应付绝大多数面试场景。但如果你的数据里有大量重复元素，比如一个数组里一半以上都是同一个值，标准的Lomuto分区会怎么做？

把所有小于等于基准的元素都放到左边，等于基准的元素也混在左边区域。递归处理左右子数组时，等于基准的那些元素还会被反复扫描、反复分区。这显然是浪费。

解决方案是三向切分快排。思路是维护三个区域：小于基准的、等于基准的、大于基准的。分区完成后，中间“等于”的区域已经就位，只需要递归排序“小于”和“大于”两个区域。处理大量重复元素时，性能提升非常显著。

java复制/**
 * 三向切分快速排序
 * 特别适合有大量重复元素的数组
 */
public static void quickSort3Way(int[] arr) {
    if (arr == null || arr.length < 2) {
        return;
    }
    quickSort3Way(arr, 0, arr.length - 1);
}

private static void quickSort3Way(int[] arr, int low, int high) {
    if (low >= high) {
        return;
    }
    int pivot = arr[low];
    // lt 是小于区域的右边界，gt 是大于区域的左边界
    int lt = low;
    int gt = high;
    int i = low + 1;
    while (i <= gt) {
        if (arr[i] < pivot) {
            swap(arr, i++, lt++);
        } else if (arr[i] > pivot) {
            swap(arr, i, gt--);
        } else {
            i++;
        }
    }
    // 递归排序小于区域和大于区域，等于区域不用再处理
    quickSort3Way(arr, low, lt - 1);
    quickSort3Way(arr, gt + 1, high);
}

这个版本的代码比其他快排复杂不少，但理解它的边界条件是分水岭。lt从low开始，表示小于基准的区域逐渐向右扩展；gt从high开始，表示大于基准的区域逐渐向左扩展；i是当前遍历的位置。三者之间的区间就是等于基准的区域。

另一个工程优化是小数组时切换到插入排序。快排在递归到很深层时，子数组的长度可能只剩不到10个元素，此时递归开销已经大于排序本身的收益。很多工程实现会在子数组长度（比如）小于某个阈值时，直接用插入排序或者简单排序来处理。JDK的Arrays.sort里也有类似的阈值优化。

java复制private static final int INSERTION_SORT_THRESHOLD = 7;

private static void quickSortWithThreshold(int[] arr, int low, int high) {
    // 小数组走插入排序，避免过深的递归开销
    if (high - low + 1 <= INSERTION_SORT_THRESHOLD) {
        insertionSort(arr, low, high);
        return;
    }
    if (low >= high) {
        return;
    }
    int pivotIndex = partition(arr, low, high);
    quickSortWithThreshold(arr, low, pivotIndex - 1);
    quickSortWithThreshold(arr, pivotIndex + 1, high);
}

private static void insertionSort(int[] arr, int low, int high) {
    for (int i = low + 1; i <= high; i++) {
        int key = arr[i];
        int j = i - 1;
        while (j >= low && arr[j] > key) {
            arr[j + 1] = arr[j];
            j--;
        }
        arr[j + 1] = key;
    }
}

这个优化的核心理由是：递归调用本身有开销，包括方法调用、栈帧创建、参数传递，当子问题规模小到一定值后，这个开销已经占总耗时的固定比例，与其继续递归，不如用简单的插入排序线性扫一次。

3.4 快速排序的迭代式实现：怎么把递归转成非递归

面试有时候会追加一问：“快排能用非递归实现吗？”考查点不只是“会不会”，更是**“理解不理解递归的本质”**。

递归的本质是用系统栈保存调用现场，那么非递归方案很自然就是——自己维护一个栈。

java复制import java.util.ArrayDeque;
import java.util.Deque;

/**
 * 快速排序的迭代实现
 * 使用显式栈模拟递归调用
 */
public static void quickSortIterative(int[] arr) {
    if (arr == null || arr.length < 2) {
        return;
    }
    Deque<Integer> stack = new ArrayDeque<>();
    stack.push(0);
    stack.push(arr.length - 1);
    
    while (!stack.isEmpty()) {
        int high = stack.pop();
        int low = stack.pop();
        
        if (low >= high) {
            continue;
        }
        
        int pivotIndex = partition(arr, low, high);
        
        // 先把右半部分压栈
        if (pivotIndex + 1 < high) {
            stack.push(pivotIndex + 1);
            stack.push(high);
        }
        // 再把左半部分压栈
        if (low < pivotIndex - 1) {
            stack.push(low);
            stack.push(pivotIndex - 1);
        }
    }
}

这里用Deque<Integer>模拟栈，压入的是子数组的边界索引。每次弹出两个值，就是拿到一个[low, high]的子数组，然后做一次partition，再把分出来的左右子数组重新压栈。

需要注意一个细节：栈里同时维护的元素是“成对”的出栈入栈。所以压栈时要注意顺序，先压左边界还是先压右边界，要和出栈时的pop顺序对应好。上面代码里，手动压栈时是先push low再push high，pop时先拿到high再拿到low，这样对应关系不会乱。

非递归版本的好处在于不会受递归深度限制。数据量特别大（比如千万级别）而且分区极不均衡时，递归版本可能爆栈，但迭代版本只要内存够，就能一路跑完。

4. 冒泡排序与快速排序的系统对比与选型指南

4.1 复杂度、稳定性、空间占用：一张表看懂差异

做了这么多实现，我们回到最核心的问题：这两种算法到底怎么选？我把它们的核心指标放在一张表里，方便直接对比：

这里的稳定性要特别解释一下：排序算法的稳定性指的是，如果两个元素值相等，排序后它们的相对顺序保持不变。冒泡排序在比较相邻元素时，只有严格大于才交换，相等的元素不会交换位置，所以是稳定的。快排的分区交换过程可能把相等的元素换到对方之前，所以不稳定。

稳定性在业务中什么时候很重要？举个例子：你有一个人员列表，先按部门分组，再按薪资排序。如果排序算法不稳定，那么在按部门“二次排序”时，原本按薪资排好的顺序就可能被打乱。反之，稳定排序能保证第二次排序后，组内仍然保持第一次的薪资顺序。

4.2 面试必问题：什么情况下选冒泡，什么情况下选快排

面试官问这个问题，其实不是真的要你背结论，而是看你有没有基于数据特征做技术决策的意识。

选冒泡排序的合理场景：数据量很小（比如几十个）、近乎有序、要求代码简单可维护、不在乎性能。还有一种是要求稳定排序，且数据规模小——这时冒泡简单有效，没必要上个复杂的归并排序。

选快速排序的合理场景：数据量大、性能优先、排序稳定性不敏感。绝大多数Java业务场景，Arrays.sort()内部就是快排的优化版本，直接使用即可。如果你需要稳定排序且数据量大，那就上归并排序或Collections.sort()。

还有一个Java特有的细节——Arrays.sort()对不同类型有不同策略：

• 对基本类型数组（int[]、long[]等），使用双基准快速排序（Dual-Pivot QuickSort）。
• 对引用类型数组（Integer[]、String[]等），使用TimSort（一种基于归并思想的稳定排序）。

所以如果你用的是Integer[]排序，得到的排序结果是稳定的；但用int[]排序，结果就是不稳定。这个细节在面试八股文中经常被忽略，但实际排查问题时偶尔会用到。

4.3 Java内置排序与手写排序的对比：什么时候自己写

很多人学了这两种排序后，会纠结“我到底要不要自己手写排序算法用在业务代码里”。我的建议很简单：

业务代码中，永远优先用Java内置的Arrays.sort()或Collections.sort()。

理由有三点：

第一，内置排序的性能经过极度调优。以Arrays.sort()为例，它内部会综合判断数组长度、已排序程度、数据分布，选择最合适的排序策略。比如小数组用插入排序，大数组用双基准快排，已经能自动识别部分有序数据并采用高效策略。你手写快排，大概率打不过它。

第二，内置排序经过极其充分的测试，边界情况处理得非常完善。包括空数组、单元素数组、全部相等数组、大量重复值数组等，这些case你手写时很容易忽略某一个，从而埋下bug。

第三，手写排序更应该作为“理解工具”而非“生产工具”。你理解了冒泡和快排的实现，就能明白排序算法的时间复杂度、稳定性、空间占用这些概念，在系统设计时能做出更合理的选型。

那么，什么时候确实需要自己写排序算法？我的经验是：如果要排序的数据不能简单通过Comparable比较，或者需要按多个维度动态指定排序规则，但各种比较器的组合已经复杂到不可维护时，这时候你可能需要自定义排序逻辑。不过即使这样，也建议用Java内置的Comparator接口配合Arrays.sort()，而不是真的从零手写快速排序。

如果你确实在巨大的数据集上遇到了性能瓶颈，那问题大概率不在排序算法本身，而在数据结构和整体设计上。不要过早优化，先跑一遍JProfiler或VisualVM看看热点到底在哪。

5. 排序算法调试实录：边界条件与性能陷阱

5.1 我踩过的坑：为什么快排会栈溢出、冒泡会死循环

先说我印象最深的一个bug。有一次用快排对10万个整数排序，程序直接抛了StackOverflowError。我当时第一反应是“数据量太大了？”，但10万对JVM来说根本不算大，最终定位到原因是：数组已经有序，而我的基准又固定选第一个元素，导致每一轮分区都非常不均衡，递归深度被拉到了10万层，直接爆掉JVM默认栈深度。

这个问题的解决方式就是我前面提到的“三数取中”或“随机基准”。我发现之后，习惯性地就在所有手写快排里都加上三数取中，现在已经成了肌肉记忆。

另一个常见问题出现在冒泡排序内层循环边界写错。我见过不少人写成：

java复制for (int j = 0; j < n - 1; j++) {

这样不报错，也能排序成功，但因为每轮都要比较末尾已经就位的大元素，导致做了大量多余操作。在数据规模大时，性能差距可达数倍。这类问题不报错，隐蔽性很强，只能靠性能分析和直觉排查。

还有一个深坑——用Integer数组而不是int数组跑排序。我之前排查过一个线上问题：用List<Integer>存了300万个数据，排序耗时接近5秒，换用int[]后直接降到不到100毫秒。原因就是自动装箱（Autoboxing）和拆箱（Unboxing）的开销。每次比较都要拆箱成int，每次交换都要装箱成Integer对象，生成了大量临时对象，垃圾回收压力也变大。排序这种高频操作，一定要用基本类型数组。

5.2 排序性能爆表的排查工具与方法

如果业务代码里排序突然变慢，怎么系统性排查？我给你一个我自己常用的排查路径：

第一步：评估数据量。如果数据量本身就在百万以上，先确认排序次数是否合理。比如在一个循环里反复对同一个数组排序，就可能出现O(n²·m)级别的开销。

第二步：分析算法复杂度。检查排序是否每次进入循环都执行。许多性能问题不在于排序本身，而在于“非必要的重复排序”。

第三步：使用JFR或JMC分析热点。Java Flight Recorder能在不显著影响性能的情况下记录方法级调用热力分布，可以看到排序方法占用了多少CPU时间。如果排序方法确实是主要热点，再进一步看数据分布。

第四步：对比不同实现。写一个小demo，分别用Arrays.sort()和自己的排序实现跑同一批数据，测出真实耗时差异。结合System.nanoTime()做微基准测试，注意要预热JIT，否则测试结果不准。

第五步：检查GC问题。如果用了List<Integer>，极有可能是GC压力导致的性能下降。可以通过-verbose:gc或JMC观察GC频率和耗时。

提示：微基准测试时不要被“第一次运行”的结果迷惑。JVM有JIT编译机制，方法会先解释执行，再编译为机器码。预热后再测才是真实性能。

5.3 常见面试追问：快速排序最快什么时候，最慢什么时候

最后聊几个高频面试追问，我帮你把考点和答法理清楚。

“快排的最好情况是什么？”

答：每次分区都恰好把数组分成等长的两半时，递归深度最小，总共O(log n)层，每层扫描O(n)，总体O(n log n)。这在数据分布上意味着基准元素恰好是中位数附近。从概率上说，随机数据下快排的表现接近最好情况。

“快排的最坏情况是什么？”

答：数组已经有序（升序或降序），且基准固定取首或尾元素时。此时每次分区只有一个元素到位，问题规模只减少1，递归深度O(n)，整体复杂度O(n²)。注意，这种情况下空间复杂度也会变成O(n)，因为递归栈的深度相应增加，对JVM的栈空间压力会非常大。

“如果数组里全是重复元素，快排表现怎么样？”

这个问题是在考察三向切分。如果全是重复元素，标准Lomuto分区会做大量等于基准的无意义交换，性能很差。三向切分快排在这种场景下只需要O(n)时间，因为它一次分区就把所有元素都归到了“等于”区域，递归直接结束。

“为什么JDK的Arrays.sort()不用手写的快排？”

JDK的排序实现综合了多种策略，比如对小数组用插入排序、对基本类型用双基准快排，还会检测输入是否大致有序，如果有序会走TimSort的优化路径。你手写一个简单快排放到生产环境，不太可能比它更优。但手写快排的意义在于理解“分治”这个思想，它是一切高级算法的基础。

“解释一下什么是稳定排序，为什么业务里重要？”

两个相等的元素，排序后相对顺序是否保持不变。比如电商订单列表，先按订单金额排序，再按下单时间排序。如果第二次排序是稳定排序，那么在金额相同的一组订单里，下单时间依然是有序的。常见的稳定排序有冒泡排序、插入排序、归并排序；不稳定排序有快速排序、堆排序、选择排序。

6. 我的实操体会排序学习路线建议

做了一段时间Java开发和面试官，我越来越觉得排序算法是“入门简单、精通难”的典型代表。冒泡排序是三分钟就能写出来的算法，但真要让你解释清楚它为什么在数据有序时停下是对，在数据乱序时为什么要做那么多轮，背后涉及的就是对循环不变量的理解。快排更是如此，一个看似很短的递归算法，里面藏着的分治思想、栈深控制、基准选择策略，每一个都能展开成一篇长文。

如果你正在学习这部分内容，我给一个实操路线：先手写十遍冒泡排序基础版，确保闭着眼都能写出来；加上优化标志位；再加上鸡尾酒排序。这一步是打地基。然后进入快排，先会写Lomuto版本，再理解Hoare版本，然后自己实现三数取中优化和三向切分，最后把递归改成迭代。整个过程走下来，你对“递归”“分治”“边界条件”这几个概念的掌握一定会有一个质变。

如果是为了面试，建议把这两个算法的时间复杂度推导过程也准备好。面试官很少只问“快排复杂度是多少”，而是会问“为什么是O(n log n)”“最坏为什么退化成O(n²)”。能清楚地推导出来，比背诵答案有用得多。

最后再多说一句，排序算法是那种“工作中未必常用，但每次用都希望你懂”的基础能力。希望这篇内容能帮你真正打通冒泡和快排的底层逻辑，不管面试还是实践，都心里有底。