蓝桥杯必背：三大手写排序模板（快排/归并/桶排序）详解-代码聚汇网

蓝桥杯必背：三大手写排序模板（快排/归并/桶排序）详解

FFFire小火·2026-08-31·阅读 22 GEO检测（免费）

蓝桥杯排序模板快速排序

|难度：普通|阅读约 14 分钟

1. 为什么蓝桥杯要背手写排序模板：就算有现成API也不能直接躺平

先聊一个很多备赛同学都会问的问题：蓝桥杯又不是ACM，Java有 Arrays.sort()，C++有 sort()，Python有 sorted()，为什么还要花时间手写快速排序、归并排序和桶排序？这不是脱了裤子放屁吗？

这个问题我当年备赛的时候也纠结过，直到真正上了考场才明白。先说结论：蓝桥杯省赛的填空题和部分编程大题，确实可以直接调API，但竞赛的分数差距从来不在"能不能排序"，而在"排序之外你能多做什么"。

拿归并排序举例，Arrays.sort() 能帮你排好序，但它不会告诉你数组里有多少个逆序对。而"求逆序对数量"这个考点，蓝桥杯国赛和省赛都出过，标准解法就是归并排序的分治过程里顺手统计。你调API，排序是排完了，但逆序对一个都数不出来——这时候手写模板的价值就体现出来了。

另外还有一个非常现实的原因：蓝桥杯的评测机和平时写业务代码不一样，数据规模大了以后，API排序的底层实现不一定是你想要的。比如Java的 Arrays.sort() 对基本类型用的是双轴快速排序，对对象类型用的是TimSort，C++的 sort() 在数据量小的时候会退化成插入排序。这些底层策略本身没错，但你要想针对特定数据做优化，比如对一个几乎有序的数组做排序，手写插入排序的改良版反而更快。模板的意义不是替代API，而是让你在API之外有第二套、第三套手段。

更关键的是，手写排序是理解算法复杂度的最佳途径。很多人背了"快排平均O(n log n)"这句话，但不知道为什么快排在有序数组上会退化到O(n²)。当你亲手写出快排的partition代码，看着那两个指针在数组上移动，你会瞬间理解为什么枢轴选择那么重要。这种理解，是套API永远学不来的。

所以这篇文章不是让你放弃API，而是给你一套可以应对蓝桥杯各种变形考法的手写排序模板。一共三个：快速排序、归并排序、桶排序。每个我都会给出可以直接背诵的核心代码，同时把"为什么这样写"讲透。等你背熟了，遇到逆序对、第K大、区间排序这类变形题，你脑海里会自然浮现这些模板，然后在考场上比其他同学少花一半时间。

需要模型API调用？免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。

2. 快速排序的三个致命细节：从模板到翻车现场

快速排序大概是所有排序算法里"看起来最简单、写起来最容易翻车"的一个。网上随便一搜能搜到十几种写法，但很多写法在蓝桥杯的评测数据下会超时或者栈溢出。我这里给出一套经过大量测试、适合竞赛场景的模板，然后重点讲三个容易翻车的细节。

2.1 竞赛级快排模板（Java/C++双版本）

先看Java版本：

java复制public static void quickSort(int[] arr, int left, int right) {
    if (left >= right) return;
    int i = left, j = right;
    int pivot = arr[(left + right) >>> 1]; // 取中点作为枢轴，避免有序数组退化
    while (i <= j) {
        while (arr[i] < pivot) i++;
        while (arr[j] > pivot) j--;
        if (i <= j) {
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
            i++;
            j--;
        }
    }
    quickSort(arr, left, j);
    quickSort(arr, i, right);
}

再看C++版本：

cpp复制void quickSort(int arr[], int left, int right) {
    if (left >= right) return;
    int i = left, j = right;
    int pivot = arr[(left + right) / 2];
    while (i <= j) {
        while (arr[i] < pivot) i++;
        while (arr[j] > pivot) j--;
        if (i <= j) {
            swap(arr[i], arr[j]);
            i++;
            j--;
        }
    }
    quickSort(arr, left, j);
    quickSort(arr, i, right);
}

这里用的是双指针双向扫描的写法，不是很多教材上那种单向扫描的Lomuto分区。为什么竞赛都用双向扫描？因为Lomuto分区每次partition只交换一个元素，遇到大量重复元素时性能很差；双向扫描遇到等于pivot的元素会停下来交换，可以自动处理重复元素，实测在蓝桥杯那种包含大量重复数据的测试用例下更稳。

2.2 致命细节一：枢轴选不好，快排就是慢排

这是快排最容易踩的坑。如果每次都用 arr[left] 作为枢轴，而数组本身已经有序（比如题目输入一个升序数组），那么每次partition后数组并没有被平分，左边的递归区间是空的，右边是n-1个元素。这样递归深度会变成n，时间复杂度退化到O(n²)，蓝桥杯的数据量到了10^5以上就会超时。

解决手段有两个：

取中点作为枢轴：pivot = arr[(left + right) >>> 1]，这是性价比最高的写法，一行代码避免大部分退化情况。
随机选枢轴：pivot = arr[new Random().nextInt(right - left + 1) + left]，理论上最稳，但构造Random对象有额外开销，数据量不大时反而拖慢速度。

我的建议是模板里直接用中点法。蓝桥杯的出题人不会刻意构造让中点法失效的数据，但"数组有序"这种自然情况是很常见的，中点法恰好能覆盖。

2.3 致命细节二：递归边界判断是 `>=` 而不是 `>`

if (left >= right) return; 这里的等号非常关键。如果你写成 left == right，那么在循环结束后可能出现 left > right 的情况，导致无限递归直接栈溢出。

我见过很多同学死记模板，但问他们为什么是 >= 答不上来。这里解释一下：当 i 和 j 交叉后（即 i > j），我们递归调用 quickSort(arr, left, j) 和 quickSort(arr, i, right)，此时 j 可能小于 left，i 可能大于 right。比如数组只有两个元素 [2, 1]，left=0, right=1，pivot取 arr[0]，一轮循环后 j=0, i=1，递归调用 quickSort(arr, 0, 0) 和 quickSort(arr, 1, 1)，但这是 j == left 的情况，刚好不会出问题。可如果你当初取的是 left 做枢轴且数组是 [1, 2]，一轮循环后 j=-1, i=0，此时调用 quickSort(arr, 0, -1)，如果边界条件是 ==，就会陷入死循环。所以记住，快排的边界条件用 >= 是保命的写法。

2.4 致命细节三：内层while要用 `<` 而不是 `<=`

两个内层 while (arr[i] < pivot) 和 while (arr[j] > pivot)，用的是严格小于/严格大于。如果改成 <= 和 >=，虽然表面看起来没错，但会导致i和j一路走到数组尽头，破坏分区平衡。

为什么？因为遇到等于pivot的元素，<= 会继续前进，而 < 会停下。停下的意义在于：等于pivot的元素会被交换到两边，这样递归时两边都不会聚集大量等于pivot的元素。如果不停下，等于pivot的元素全部堆积在同一侧，分区就会失衡。这个问题在重复元素多的测试用例里非常致命，极容易超时。

3. 归并排序不只是排序：逆序对才是真正的考点

如果说快速排序的核心是"分"，那归并排序的核心就是"治"。归并排序的思路特别适合用来求解"逆序对"这类计数问题，这也是蓝桥杯等竞赛里最常考的归并变形。所以这一节我会先给你一个标准的归并排序模板，然后重点说清楚：怎么在归并的过程中顺带数出逆序对的数量。

3.1 标准归并排序模板

java复制public static void mergeSort(int[] arr, int left, int right) {
    if (left >= right) return;
    int mid = (left + right) >>> 1;
    mergeSort(arr, left, mid);
    mergeSort(arr, mid + 1, right);
    merge(arr, left, mid, right);
}

public static void merge(int[] arr, int left, int mid, int right) {
    int[] temp = new int[right - left + 1];
    int i = left, j = mid + 1, k = 0;
    while (i <= mid && j <= right) {
        if (arr[i] <= arr[j]) {
            temp[k++] = arr[i++];
        } else {
            temp[k++] = arr[j++];
        }
    }
    while (i <= mid) temp[k++] = arr[i++];
    while (j <= right) temp[k++] = arr[j++];
    for (int p = 0; p < temp.length; p++) {
        arr[left + p] = temp[p];
    }
}

C++版本几乎没有差别，只是把 temp 数组声明方式换成 vector<int> temp(right - left + 1) 或者定长全局数组。

这个模板有几个固定的设计点值得注意：

temp 数组是每次merge时新创建的，还是作为全局/成员变量复用？我建议竞赛场景下用全局数组，因为 new int[right-left+1] 在递归过程中会反复创建大量小数组，垃圾回收压力大，数据达到10^6时明显拖慢速度。最稳的写法是在 mergeSort 外申明一个 int[] temp = new int[arr.length]，然后在merge里用下标复制，避免反复分配。但为了模板简洁，上面给的是局部创建版本，适合数据量10^5以内的题目。如果你要冲10^6以上，把temp提到外面就行。
合并时 arr[i] <= arr[j] 的小于等于号要写对。如果写成 <（严格小于），当两个元素相等时，你会先把右侧的元素放进temp，这不会破坏排序正确性，但会破坏归并排序的稳定性。更重要的是，下一节讲的逆序对统计，依赖的就是"相等元素不计数"这个逻辑，写错等于号会导致计数成倍错误。

3.2 如何在归并过程中统计逆序对

逆序对的定义很简单：对于数组 a，如果 i < j 且 a[i] > a[j]，那么 (i, j) 是一个逆序对。朴素解法是双重循环，O(n²)，数据量一万就吃不消了。而归并排序天然适合这件事，因为归并的merge阶段，左右两个子数组都已有序，此时统计逆序对只需要O(n)的额外扫描。

核心逻辑是这样：在merge时，当右侧数组的 arr[j] 小于左侧数组的 arr[i] 时，说明左侧从 i 到 mid 的所有元素都大于 arr[j]（因为左半边是有序的），所以一次可以数出来 mid - i + 1 个逆序对。

代码改造如下，只需要在merge里加三行：

java复制long count = 0; // 注意用long，逆序对数量可能超过int范围

public static void merge(int[] arr, int left, int mid, int right) {
    int[] temp = new int[right - left + 1];
    int i = left, j = mid + 1, k = 0;
    while (i <= mid && j <= right) {
        if (arr[i] <= arr[j]) {
            temp[k++] = arr[i++];
        } else {
            count += (mid - i + 1); // 核心：一次统计多个逆序对
            temp[k++] = arr[j++];
        }
    }
    while (i <= mid) temp[k++] = arr[i++];
    while (j <= right) temp[k++] = arr[j++];
    for (int p = 0; p < temp.length; p++) {
        arr[left + p] = temp[p];
    }
}

为什么是 mid - i + 1？因为左半边从 i 到 mid 的所有元素都排在 arr[j] 前面（它们都在左半边，下标小于右半边的 j），而且因为左半边有序，这些元素都大于 arr[j]。一次就能把所有和 arr[j] 构成逆序对的元素全部数出来，这就是归并分治的效率来源。

蓝桥杯里求逆序对的题，数据规模通常在10^5左右，逆序对数量最大可以达到 n*(n-1)/2，10^5级别就是接近5×10^9，远超int范围，所以计数变量必须用long。这个细节很多人栽过，记住就行。

3.3 归并排序的持续优化思路

归并排序虽然稳定，但它有一个明显短板：需要一个额外的O(n)空间。竞赛中如果题目明确说了"空间限制很小"，或者你不想额外开数组，那就得换思路。好在蓝桥杯大部分归并考题都不卡空间，卡的是时间。

另一个优化思路是小区间内使用插入排序。因为归并排序递归到底部的过程中，对于很短的小数组（比如长度小于16），递归和合并的开销大于直接插入排序。优化方法是设一个阈值，当 right - left <= 15 时直接调插入排序，然后再向上归并。这个优化在数据量达到10^6时能明显提速，不过蓝桥杯省赛一般不会这么极限，感兴趣的话可以作为进阶练习。

4. 桶排序：以空间换时间的一招制敌

快速排序和归并排序都是基于比较的排序，最坏情况的理论下界是O(n log n)。但桶排序完全不同，它不是通过比较元素大小来排序，而是通过元素的值直接映射到"桶"里，再用桶的顺序替代比较顺序。这种"空间换时间"的思想，在数据值域有限的时候非常可怕，能把排序复杂度降到接近O(n)。

4.1 竞赛级桶排序模板

先来一段标准的桶排序代码（以数据范围0到100000为例）：

java复制public static void bucketSort(int[] arr) {
    int max = 100000; // 根据题目数据范围确定
    int[] bucket = new int[max + 1];
    for (int num : arr) {
        bucket[num]++;
    }
    int index = 0;
    for (int i = 0; i <= max; i++) {
        while (bucket[i] > 0) {
            arr[index++] = i;
            bucket[i]--;
        }
    }
}

这段代码看起来简单到令人发指，但它就是桶排序最本真的形式——计数排序。它不再需要元素间互相比较，而是把每个数出现的次数记在一个"桶"里，然后按桶的下标从小到大把元素倒出来，天然有序。

如果数据范围不是从0开始的连续整数，比如数据在1000到2000之间，可以直接做偏移：bucket[num - min]++，最后输出时再加回min。这个处理在竞赛里很常见，避免白开一大段用不到的空间。

C++版本也很好写，无非是把 new int[max+1] 换成定长数组或 vector：

cpp复制const int MAXN = 100001;
int bucket[MAXN];

void bucketSort(int arr[], int n) {
    for (int i = 0; i < n; i++) {
        bucket[arr[i]]++;
    }
    int index = 0;
    for (int i = 0; i < MAXN; i++) {
        while (bucket[i]--) {
            arr[index++] = i;
        }
    }
}

4.2 桶排序的真正适用场景

很多同学学桶排序时觉得很鸡肋：数据范围稍微大一点，比如0到10^9，总不能开一个10^9的数组吧？这确实是桶排序最大的限制，但蓝桥杯里恰恰有大量适合桶排序的场景。

举几个典型例子：

成绩排名：成绩通常是0到100的整数，用桶排序就是开101个桶，扫一遍统计，再扫一遍输出，时间复杂度O(n)。
统计每个数出现的次数：这是桶排序最常被直接使用的地方。题目要你统计一组数里每个数出现了多少次，你开个桶数组，一次遍历往里加，再按顺序输出，这就完成了一次排序加统计。
去重：桶排序天然可以处理去重——只要输出时每个桶最多输出一次即可。
求第K小的数：如果值域不大，直接开的桶数组，从头往后累加计数，到第K个位置停住，那个下标就是第K小的数。

但要注意，桶排序不是一个通用的排序算法，它的复杂度取决于值域和桶数量的关系。如果你要排序的值域很大，比如10^9的整数，同时数据量只有10^5，那桶排序就很不划算。这时候应该回到快速排序或归并排序。

4.3 桶排序的进阶变形：分桶排序

如果数据范围大，但分布均匀，也有进阶做法——把数据划分到多个桶里，对每个桶分别排序，最后依次合并。这就是真正的"桶排序"，而不是计数排序。

举个例子，要对 [0, 10000) 范围内的1000个浮点数排序，可以开10个桶，每个桶覆盖一个长度为1000的区间。遍历数据，根据值放进对应的桶，每个桶内部再用快速排序或插入排序，最后按桶的顺序合并。这种分桶思想的平均复杂度可以做到O(n)，而且比直接计数排序的空间开销小得多。

蓝桥杯里分桶排序的题目不多，但理解这个思路对做"大数据量 + 值域分散"的题目很有帮助。比如有些数据规模很大的题目，虽然不能直接开一亿的数组，但如果你能预判数据分布比较均匀，分桶加各桶排序的策略就能派上用场。

4.4 桶排序的稳定性讨论

桶排序的一个隐藏特性是它可以是稳定的——只要你用"计数 + 前缀和 + 倒序填回"的方式实现，也就是所谓的稳定计数排序。想知道怎么实现吗？核心是通过前置和计算每个元素的最终位置，然后倒着遍历原数组填入目标位置，这样就能保证相同元素的前后顺序不变。这个优化只在题目明确要求"稳定排序"时才需要，蓝桥杯大部分题目不考察这个点，但作为知识储备还是值得了解。真遇到题设里说"保持相同值的相对顺序不变"，你就知道该用稳定版计数排序而不是普通桶排序了。

5. 三种排序怎么选：别在考场上做算法纠结

有了三套模板之后，下一个问题是：拿到一道题，怎么判断该用哪个？这个判断如果在考场上临时做，特别耗费时间，所以我习惯每次做题前先在草稿上快速过一遍"选型三问"。

5.1 选型判断表

我把判断逻辑整理成一张表，做题时快速对照就行：

题目特征	推荐排序	原因
数据规模小（n < 1000），代码越简单越好	任意都行，甚至可以直接调API	性能差距可以忽略，重点是代码别写错
数据规模大（n ≥ 10^5），值域有限（比如0~10^6）	桶排序	O(n)复杂度，轻松跑完
数据规模大，值域分散（比如int范围）	快速排序	平均O(n log n)，常数小，代码简洁
需要统计逆序对、求区间顺序关系	归并排序	分治过程天然适合计数
要求排序稳定（相同元素保持原顺序）	归并排序或稳定计数排序	快速排序不稳定，桶排序需特殊实现才稳定
几乎有序的数组	插入排序或快速排序（注意选枢轴）	数据本身有序时，快排要选好枢轴避免退化

这个表格不是绝对的，但可以帮你快速排除错误选项。比如你看到题目给了"n ≤ 10^5，每个数都在0到10^5之间"这种条件，直接上桶排序，能把O(n log n)的排序优化到O(n)，后面做任何操作都游刃有余。

5.2 蓝桥杯真题里是怎么考的

搜索结果里反复出现"蓝桥杯真题"和"蓝桥杯历年真题"，这些真题里的排序题往往不是直接考排序，而是考"排序 + 其他操作"的组合。

举一个典型的模式：给一组数，求相邻两个数的最小差值。这题如果先排序再扫描一遍，相邻差值的最小值就是答案。数据量大时，快排是首选，但如果你发现值域小，桶排序更快，甚至可以直接在上面排序后顺手统计。

再举一个：给一个数组，判断是否存在重复元素。如果值域小到可以开桶数组，直接桶排序判断哪个桶计数超过1，一趟遍历搞定。如果值域大，可以先排序再检查相邻元素是否相等。

这些题目在蓝桥杯里非常常见，本质上都是"先排序，再做其它操作"。你只有在平时就把三个模板练熟，才能在考场上快速组合，而不是现场现想算法。

5.3 别忽略输入输出的细节

排序算法本身没问题，但竞赛里"输入输出"很容易成为隐藏的大坑。蓝桥杯的数据量一旦到10^6级别，用 Scanner 读入就会超时，必须用快速输入流。推荐两个小模板：

Java版本用 BufferedReader：

java复制BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String[] parts = br.readLine().split(" ");
int n = Integer.parseInt(parts[0]);
int[] arr = new int[n];
String[] nums = br.readLine().split(" ");
for (int i = 0; i < n; i++) {
    arr[i] = Integer.parseInt(nums[i]);
}

C++版本用 ios::sync_with_stdio(false)：

cpp复制ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<int> arr(n);
for (int i = 0; i < n; i++) cin >> arr[i];

这两行代码能大幅提升输入速度。很多同学排序算法写得好好的，结果因为Scanner太慢超时了，这种丢分最冤。所以我每次强调：算法模板要背，IO模板也要背，一个都不能少。

5.4 输出格式的隐藏坑

还有一个容易被忽略的点：蓝桥杯的输出格式要求非常严格，比如"每个数之间用一个空格分隔，行末不能有多余空格"。很多同学排序做对了，但输出多个空格或者少换行，直接扣分。

这里给一个安全的输出写法：

java复制StringBuilder sb = new StringBuilder();
for (int i = 0; i < n; i++) {
    if (i > 0) sb.append(" ");
    sb.append(arr[i]);
}
System.out.println(sb.toString());

C++则可以用 for (int i = 0; i < n; i++) cout << arr[i] << (i == n-1 ? '\n' : ' ');。这种细节平常练习时不注意，考场上就吃大亏。

6. 模板训练建议：从背代码到写代码的临界点

很多人的备赛方式是"背模板"，背得滚瓜烂熟，但一到考场上稍微换一下数据范围、换一下变形，就卡壳了。这说明模板没有真正变成自己的东西。我分享几条自己的训练方法，都是实际验证过有效的。

6.1 先盲写，再对照，最后手写

我建议第一个阶段是这样：把三个模板抄在纸上，然后合上，自己在编译器里敲一遍。不要看一眼敲一行，那样没有意义，要像考试一样"盲写"。写完以后跑几个测试用例，重点测边界情况：空数组、单元素数组、已经有序的数组、全部相同的数组、大逆序数组。

如果盲写跑不出来，说明你只是"眼睛会了"，赶紧回去重新理解代码的逻辑流程。快排的递归边界、归并的合并过程、桶排序的计数输出，每个环节都要在心里过一遍"数据是怎么流动的"。

我的经验是：能够手写一遍不出错，才算真正记住了一个模板。我在备赛期每天会抽10分钟把三个模板各写一遍，坚持两周以后，就算半夜被叫醒也能默写出来。

6.2 给每个模板配一道"代表作"

光会默写不够，要会"用"。我给每个模板都配了一道经典题：

快排的代表作：给一个无序数组排序，n = 10^5，要求时间控制在1秒内。
归并的代表作：求数组的逆序对数量，n = 10^5。
桶排序的代表作：统计一个0到10000范围内的数字出现次数，并输出排序后结果。

每道题不只要做出来，还要思考：如果改数据范围，我的代码会不会超时？如果改值域，桶排序还适用吗？这种"一题多问"的方法能帮你把模板和题目场景绑定在一起，比刷十道重复题有效得多。

6.3 把模板改造成自己的"万能版"

最后一步，也是最重要的一步，是把模板改造成适合自己习惯的版本。比如：

有些人习惯用随机枢轴，有些人习惯用中点枢轴，都可以，但一定要固定下来，不要每次临场改。
有些人喜欢递归写法，递归层次深了会有栈溢出风险；如果你心理上不舒服，可以尝试把快排改成非递归（用栈模拟）。但蓝桥杯一般不会把递归栈压爆，非递归属于进阶玩法。
归并排序的temp数组，你可以提前在全局申请好，也可以每次都new。我建议全局申请，省去内存分配的时间，代码改动也就多一行的事。

改造完以后，你的模板就成了"私有模板"，用起来比任何网上down下来的版本都顺手。因为你有意识地思考过每个变量的含义，每一行代码为什么要这么写，你才能在考场上遇到变形题时快速调整。

6.4 训练过程中踩过的一个真实坑

最后分享一个我实际训练中踩过的坑：归并排序的mid计算。我曾经写成 int mid = (left + right) / 2，看起来完全没问题，但在某些特殊情况下（比如left和right特别大时），(left + right) 可能溢出。虽然蓝桥杯的数组长度一般不会大到int溢出，但养成用 (left + right) >>> 1 的好习惯总没错。这个移位运算在Java中是无符号右移，C++里就是 left + (right - left) / 2 更安全。

这种细节点，平时根本不会注意，但真到比赛时，一个隐蔽的溢出会导致整个提交错误，而调试bug又特别浪费时间。所以我的原则是：模板里的每一行都必须是"为什么这么写"都能解释清楚的，不允许存在"不知道但能跑"的代码。凡是解释不了的，都要查清楚、弄明白，否则考场上它一定会以最诡异的方式坑你一次。

三套模板加上这篇实战拆解，够你应对蓝桥杯里绝大多数排序相关题目了。剩下的就是多写、多测、多反思。等你练到能在5分钟内默写出三套完整模板、并且知道每行代码的含义时，考场上遇到排序题，你已经赢在起跑线上了。