Java面试必备：冒泡排序与快速排序原理及实现详解

1. 排序算法在Java面试里的分量，远比你想的重

先说个我前两天遇到的真实场景。有个工作了三年的Java开发来问我一件事：他说自己投简历时被问到“冒泡排序和快速排序有什么区别”，结果一时语塞，只能挤出“一个快一个慢”这种话。挂了电话他越想越不对劲，觉得自己明明写过那么多业务代码，怎么连这种基础题都答不好。

这事其实很典型。Java面试里，排序算法几乎是八股文中雷打不动的一环。尤其是冒泡排序和快速排序，几乎每个面试官都会让候选人现场手写一遍。你可能会想，现在谁还需要自己写排序？Arrays.sort() 不香吗？这话本身没错，但面试官考察的从来不只是“你会不会调API”，而是透过排序这件事，看你的基本算法素养、边界意识、对时间复杂度的理解，以及你在压力下能不能把思路讲清楚。

从热搜词里也能看出来，像“冒泡排序java”“快速排序java实现”“java面试八股文”这些都是常年挂在搜索榜前面的词。为什么这么多人搜？因为大家都想在面试前临时补一补这块短板。但问题是，临时抱佛脚只能记住代码形态，一旦面试官追问“为什么这个循环要这么写”“最坏情况下会怎样”，就很容易露馅。

所以这篇内容我不想只贴两段代码就完事，而是想把冒泡排序和快速排序掰开揉碎，讲清楚原理、实现、优化、复杂度、稳定性，以及你在面试和实际编码中真正会遇到的坑。文章里的所有代码都是Java实现，我会直接给出可以跑通的完整示例，然后解释每一步为什么要这么写。

我自己从学习Java到现在，这两种排序算法前前后后写过几百遍不止。早期确实是为了应付面试，后来在阅读JDK源码、做性能调优、甚至给团队做代码评审的时候，才发现这些基础算法里蕴含的很多思路，其实一直在影响我对代码的理解。比如快速排序里的分治思想，在解决Top K问题、海量数据去重、甚至设计系统架构时都会用到。多花点时间搞明白它们，远比死记硬背几行代码划算。

这篇文章我尽量不端着，也不绕弯子，直接用实战视角来讲。适合三类人看：第一类是准备Java面试、需要系统过一遍排序算法的求职者；第二类是学过但已经忘得差不多、想快速把知识捡回来的Java开发；第三类是正在带新人、想给团队做一次算法分享的技术Leader。不管你属于哪一类，建议都自己动手把代码敲一遍，然后对照文章里的追问逻辑想一遍，收获会大很多。

2. 冒泡排序：从最直观到考场无懈可击

2.1 冒泡排序的基本原理，一句话就能讲清楚

冒泡排序的思路特别朴素：依次比较相邻的两个元素，如果前一个比后一个大，就交换它们的位置。一轮走完，最大的元素就像气泡一样“浮”到了数组末尾。然后下一轮再从头开始，把第二大的元素浮到倒数第二个位置，依此类推。

你看，这个逻辑甚至不需要任何数学基础。我第一次学数组时就能看懂它的行为：每一轮结束后，数组末尾就会多出一个已经就位的“大块头”，剩下未排序的部分越来越小，直到整个数组有序。

但“看得懂”和“写得出无懈可击的版本”之间，隔着一道很深的沟。很多初学者会写出两层循环嵌套的代码，但内层循环的边界总是搞不对，要么多比较了一次，要么漏掉了最后一次交换的触发。这类错误很小，却直接决定程序能不能正确排序。

2.2 最基本版实现，先跑通再说

先给出最简单的一版Java实现。这版目的是把“相邻交换”的核心思想完整表达出来，不做任何优化，方便对照理解。

java复制public class BubbleSortBasic {

    public static void bubbleSort(int[] arr) {
        int n = arr.length;
        // 外层循环控制排序轮数，n个元素最多需要n-1轮
        for (int i = 0; i < n - 1; i++) {
            // 内层循环负责相邻比较与交换
            // j从0开始，到n-1-i为止
            // n-1-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;
    }
}

你仔细看第6行和第8行，这是最容易写错的两个地方。外层循环i < n - 1，是因为当n-1个元素都已经放到了正确位置，剩下的最后一个元素自然就是有序状态，无需再排。内层循环j < n - 1 - i，是因为每一轮结束后，末尾的i个元素已经确定了最终位置，再比较它们纯属浪费。

这里要重点提醒一个初学者常见误区：有人会把内层循环写成j < n - 1也不设-i，这样排序结果其实也对，因为即使多比较了已有序的区域，也只是做无意义的判断和交换，并不会把排好的顺序打乱。但这样做每一轮都重复扫描整个数组，白白增加了很多操作。面试中如果写成这样，至少说明你还没有真正理解“每轮都会冒出一个最大值”这个事实，给面试官的印象分会大打折扣。

2.3 两个经典优化：提前终止与已排序区缩减

上面的基础版本冒泡排序的时间复杂度是确定的O(n^2)，不管数组本身是否已经有序列都会完整走完两层循环。但我们在真实开发中经常遇到一种情况：数组本身就接近有序，或者干脆就是已经排好序的。这种情况下仍然走满两层循环，就是典型的资源浪费。

优化的思路很直白：如果在某一轮遍历中，一次交换都没有发生，说明整个数组已经有序，那就可以立即结束排序，而不是继续做无意义的比较。

优化后的Java代码如下：

java复制public class BubbleSortOptimized {

    public static void bubbleSort(int[] arr) {
        int n = arr.length;
        boolean swapped;
        for (int i = 0; i < n - 1; i++) {
            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;
            }
        }
    }

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

加了swapped标记之后，对于已经有序的数组，第一轮扫描完成后就会触发break跳出循环，整体时间复杂度直接降为O(n)。这是面试中一个非常高频的考点：面试官会问“如果待排序数组已经有序，冒泡排序还需要O(n^2)吗？”如果你答“需要”，那就是没做过优化；如果你答“不用，加个标志位就可以变成O(n)”，这就是一个很亮眼的加分项。

除了提前终止，还有一个进阶优化思路是缩小排序边界。具体来说，每一轮最后一次发生交换的位置，就是这一轮交换到的右边界。在这个位置之后的所有元素，本轮已经完全有序，下一轮不需要再被扫描。用变量记录这个位置，下一轮直接以内层循环到该位置即可。

2.4 面试追问：稳定性、复杂度与冒泡排序的变体

面试官问完优化之后，通常还会接着追问几个概念性问题，比如“冒泡排序是稳定排序吗？为什么？”答案很简单：是稳定的。因为我们在交换时只处理arr[j] > arr[j + 1]的情况，相等的元素不会被交换位置，所以相同值的元素在排序前后的相对次序不会改变。

时间复杂度这里也要能一口报清楚：最好情况O(n)