计算机二级C语言考试，排序问题几乎是每年必出的大菜。尤其是选择排序，看着最简单，可一旦跟指针传参搅在一起，那就是另一回事了。我记得有一次刷真题，遇到一道“用选择排序法对数组升序排序，要求排序函数参数为指针”的题目，第一眼觉得稳了，结果动笔不到三分钟就卡住——交换俩数怎么都不生效，数组愣是没变，那一刻我真的差点被绕晕。后来花了一晚上把指针传参和选择排序的细节彻底理清，才发现这道题其实是个非常好的“试金石”，它考的不仅是你会不会背排序，更考你懂不懂C语言最核心的“值传递”机制。
今天就把这道题的完整拆解、易错点、排查过程，以及我总结的答题套路都写出来。准备参加计算机二级、或者刚学完指针想来点实战的读者，这篇文章可以让你少走很多弯路。
1. 真题长什么样：选择排序 + 指针传参的组合题
1.1 题目的典型考法
计算机二级C语言的程序填空题和改错题里，选择排序是个老熟脸。典型的出题方式有两种：
第一种是给你一个不完整的排序函数，让你填代码。比如：
void sort(int *p, int n) { // 空着的地方需要补充完整 }然后在主函数里定义一个数组，调用sort(arr, 10)，要求最后输出升序结果。
第二种是函数填空里已经给了排序算法主体，但把某个关键位置（比如交换语句、内层循环的下标）挖掉，考生要补全。这时候如果底层的指针传参概念不扎实，很容易填出一个“看起来挺对但运行结果一塌糊涂”的答案。
再常见一点的变形，是把排序函数声明成void sort(int a[], int n)，然后在函数内部用a[i]操作数组。这种写法其实是数组名作为指针退化的语法糖，a[]和*p在函数形参里是等价的。但题目一旦混用*p和a[i]，很多人的思维就乱了。
1.2 第一眼以为简单，动笔才发现处处是坑
我最初的想法非常天真：选择排序不就是每轮找最小值，然后交换吗？于是刷刷刷写了一个交换函数：
void swap(int x, int y) { int temp = x; x = y; y = temp; }然后在排序函数里用swap(p[i], p[min])去交换。结果一运行，原数组纹丝不动，输出还是原来的乱序。那一刻我整个人愣住了：循环没问题啊，min下标也找对了啊，怎么就不换呢？
这个问题在考生里太常见了。归根到底，就是在C语言里，函数参数是“值传递”，你在swap内部把x和y交换了，跟外面实参p[i]、p[min]没有半点关系。你以为你把两个位置的值换了，实际上只是把两份“复印件”换了，原件还是在原地。这就是后面要重点讲的指针传参的价值所在。
2. 先把选择排序的底子打牢：从数组下标版到指针版
2.1 选择排序的核心思路
选择排序的思路一句话总结：每一轮从待排序区间里挑出最小的元素，把它放到待排序区间的最前面。
具体来说，第一轮在n个元素里找出最小值，跟第0个元素交换；第二轮在剩下的n-1个元素里找出最小值，跟第1个元素交换；重复到只剩一个元素。这样共需要n-1轮，每轮找一次最小值下标，最后数组自然有序。
这里有一个提高效率的关键点：每一轮不需要真的“交换”很多次，只需要记录最小值下标，最后交换一次。初学者特别喜欢在比较的时候就交换，也就是每发现一个更小的值就立刻交换，这样虽然也能得到正确的升序结果，但比较次数会变成交换次数，效率变差，而且代码逻辑更容易出错。计算机二级的评分器有时候会检查算法核心，所以尽量用“记录下标+一轮一次交换”的标准写法。
2.2 数组下标版本的标准写法
先把最标准的下标版本写出来，这是后面理解指针版本的基础：
void sort(int a[], int n) { int i, j, min_idx, temp; for (i = 0; i < n - 1; i++) { min_idx = i; for (j = i + 1; j < n; j++) { if (a[j] < a[min_idx]) { min_idx = j; } } if (min_idx != i) { temp = a[i]; a[i] = a[min_idx]; a[min_idx] = temp; } } }注意内层循环的边界：j从i + 1开始，到n - 1结束。外层循环只需要到n - 2，因为当i等于n-1时只剩一个元素，不需要再排序。
很多人容易把内层循环写成j < n - 1，那就会漏掉最后一个元素的比较；或者把外层写成i < n，虽然多跑一轮也不会出错，但不够严谨。考试改错题里可能故意把这些边界写错，要特别敏感。
2.3 把下标版本改写成指针版本
题目要求的是void sort(int *p, int n)，那就要用到指针。先理解一个基本等价关系：在函数形参里，int *p和int a[]是等价的，都表示一个指向整型数组首元素的指针。所以函数体内部，你既可以继续用p[i]这种下标写法（指针可以用下标运算符），也可以用*(p+i)这种解引用写法。
指针版本的排序代码可以这样写：
void sort(int *p, int n) { int i, j, min_idx, temp; for (i = 0; i < n - 1; i++) { min_idx = i; for (j = i + 1; j < n; j++) { if (*(p + j) < *(p + min_idx)) { min_idx = j; } } if (min_idx != i) { temp = *(p + i); *(p + i) = *(p + min_idx); *(p + min_idx) = temp; } } }这里*(p + j)就是p[j]。写成指针形式，是为了让你更直观地理解：你拿到的是数组首元素的地址，这个地址指向的连续内存空间里存着一整排数据，通过首地址加偏移量就能访问每个元素。
我个人的建议是：如果你在考场上对指针形式不熟，完全可以继续在函数体内用p[i]，只要形参是int *p就能通过编译。但如果题目明确要求“必须使用指针”或者给了*(p + i)的提示，最好还是用指针形式，避免踩到语法理解上的坑。
3. 指针传参为什么是这道题的胜负手
3.1 值传递的“复印”机制
很多初学者会觉得：我把数组传给函数了，函数里面改数组，外面当然跟着变，这有什么好说的？确实，传数组名的时候，因为数组名会“退化”成指针，函数拿到的是地址，所以函数内通过地址修改数组元素，外面能看到变化。但如果你交换的是数组的两个元素，就不一样了。
关键在于：swap(p[i], p[min])这种调用，是把p[i]的值和p[min]的值当作参数传进去，而不是把这两个元素的地址传进去。函数内部形参x和y，就像复印出来的两份数据，无论怎么交换它们，原件都待在原地。这就是C语言“值传递”的本质。
打个比方：你让快递员去你家拿走两本书，你递给他的是两本书的书名，他拿着两个书名来回倒腾，但你家里的书动都没动。要让他真正调整书的位置，你得把门牌号告诉他。这里的“门牌号”就是变量的地址，也就是指针。
3.2 交换两个数必须传地址
正确的交换函数应该写成：
void swap(int *x, int *y) { int temp = *x; *x = *y; *y = temp; }调用时，必须传入两个变量的地址：
swap(&p[i], &p[min_idx]);这里&是取地址运算符，&p[i]就是数组第i个元素的内存地址。*x在swap内部就是“把x地址上的值取出来”，*x = *y就是“把y地址上的值写到x地址上”，这样原始数组的两个位置才真正被交换。
这道题的绕人之处就在这里。如果你只把形参写成int *p，但在交换的时候忘了在实参前加&，编译能通过，程序结果却完全不对，而且特别难排查，因为语法没问题，逻辑也没错，就是结果错了。
3.3 函数形参和实参的误解：数组名退化为指针的底层细节
再往深挖一层。很多人知道“数组名作为参数时会退化为指针”，但这个退化具体意味着什么，不一定拎得清。
在主函数里，int arr[10];中的arr是一个数组名，它代表整块连续内存的首地址。当你调用sort(arr, 10)时，实际上传递给sort的是arr的值，也就是首元素的地址，这个值被赋值给形参p。所以p和arr指向同一个位置，p[0]和arr[0]访问的是同一块内存。
正因为如此，在排序函数里通过p[i]修改元素，主函数的arr会跟着变化。这也是这道题唯一能让“数组值变掉”的机制。假如形参写成int p而不是int *p，那传的就是数组首元素的一个普通整数值，函数里完全访问不到后续元素，更谈不上排序。
搞清楚这一点，你就明白为什么sort的形参必须是指针，为什么交换元素时还要再取一次地址。这是两个层次的问题，混在一起就是“绕晕”的根源。
4. 我被绕晕的那段代码排查实录
4.1 错误代码现场：交换没有生效
我当时实际写的错误代码大概长这样：
#include <stdio.h> void sort(int *p, int n) { int i, j, min_idx; for (i = 0; i < n - 1; i++) { min_idx = i; for (j = i + 1; j < n; j++) { if (p[j] < p[min_idx]) min_idx = j; } if (min_idx != i) { swap(p[i], p[min_idx]); // 问题出在这一行 } } } void swap(int x, int y) { int temp = x; x = y; y = temp; }注意，我在这里用swap之前都没有声明原型，在C89标准里编译器可能会警告。真到了二级考试的环境，很多题目默认允许隐式声明，但这种写法非常危险。先说核心问题：swap(p[i], p[min_idx])传的是值，所以数组根本没换。
我一开始完全没往传参方向想，还觉得是不是我的sort函数跟主函数里的数组名不匹配。于是我在sort函数里加了一行printf，打印每次交换前的p[i]和p[min_idx]，以及在swap函数里打印交换后的x和y。
4.2 排查链路：printf打印全程追踪
我首先在swap函数最后加：
printf("swap后: x=%d y=%d\n", x, y);结果发现每次swap之后，x和y确实交换了。但回到sort函数，再打印p[i]和p[min_idx]，发现它们还是原来的值。这时我立刻意识到：swap里的x、y是复印件，跟外面的p[i]没关系。
为了进一步确认，我还在sort函数调用swap前后分别打印：
printf("调用前: p[%d]=%d p[%d]=%d\n", i, p[i], min_idx, p[min_idx]); swap(p[i], p[min_idx]); printf("调用后: p[%d]=%d p[%d]=%d\n", i, p[i], min_idx, p[min_idx]);输出里调用前和调用后完全一样。这基本实锤了是传参问题。但当时我还是不死心，又试了把swap改成接受指针：
void swap(int *x, int *y) { int temp = *x; *x = *y; *y = temp; }然后调用swap(&p[i], &p[min_idx])，数组立刻就正常排序了。整个过程也就十分钟，但那种“马上找到原因”的爽快感让我记到现在。
4.3 根因分析：swap传参的三种写法对比
这里把三种常见写法放在一起对比，你就能一目了然地看出为什么有的对、有的错：
| 写法 | 调用方式 | 结果 | 原因 |
|---|---|---|---|
void swap(int x, int y) | swap(p[i], p[min_idx]) | 数组不变 | 值传递，形参是实参的拷贝 |
void swap(int *x, int *y) | swap(p[i], p[min_idx]) | 编译警告或错误 | 形参需要地址，实参却给的是值，类型不匹配 |
void swap(int *x, int *y) | swap(&p[i], &p[min_idx]) | 数组正确排序 | 传递的是实参的地址，通过地址修改原值 |
还有一种容易犯的错：swap函数写成int *x, int *y，但函数体内交换时写成int temp = x; x = y; y = temp;，这是把指针本身交换了，两个指针指向的目标没变。这样也不会生效。必须使用解引用*x、*y操作目标内存。
4.4 修正后的完整正确代码
最后把这个真题场景下最稳妥的完整代码写出来，可以直接作为参考模板：
#include <stdio.h> void swap(int *x, int *y) { int temp = *x; *x = *y; *y = temp; } void sort(int *p, int n) { int i, j, min_idx; for (i = 0; i < n - 1; i++) { min_idx = i; for (j = i + 1; j < n; j++) { if (*(p + j) < *(p + min_idx)) min_idx = j; } if (min_idx != i) swap(&p[i], &p[min_idx]); } } int main() { int arr[10] = {34, 12, 56, 78, 23, 9, 45, 67, 1, 88}; sort(arr, 10); for (int i = 0; i < 10; i++) printf("%d ", arr[i]); return 0; }这里if (min_idx != i)可以省略，就算相等，交换同一个位置也不会出错，但加上去可以少做一次无意义的操作，在程序填空里也更符合标准答案。
5. 真题变式与弯道超车技巧
5.1 同类型变式：冒泡排序、字符串排序、鞍点问题
选择排序加指针传参这个知识点，在二级考试里还有不少亲戚。
第一个变式是冒泡排序。如果把冒泡排序函数写成void bubble(int *p, int n)，内部同样用指针遍历数组，交换两个相邻元素时也要用地址，否则会犯和选择排序一模一样的毛病。很多考生能把冒泡的循环写得滚瓜烂熟，却在交换那一步翻车，这就很可惜。
第二个变式是字符串排序。题目可能给出char *names[5]这样的字符指针数组，要求按字典序排序。这时排序的对象不再是整数，而是字符串指针，交换的是char *类型的变量，必须用char *temp配合二级指针或者正确指针交换，否则会跳进更深的坑。二级考试一般不会考到二维指针，但会考char str[5][20]二维字符数组的排序，每个字符串是一行，可以通过strcpy整体交换字符串内容。这类题本质上也是“数组元素交换”，只不过元素是字符串数组，思考路径是一样的。
第三个变式是计算鞍点问题。题目要求在一个5×5矩阵中找某个元素，它既是所在行的最小值，又是所在列的最大值。这看起来跟选择排序无关，但同样考验双重循环里下标变量的控制。选择排序的内层循环是j = i + 1，鞍点的循环是遍历行、遍历列，一旦下标写错，整个判断就乱套。这种题和排序题的共同点是：逻辑简单，但下标边界极其容易出错。我建议在草稿纸上先把循环起始和终止条件写清楚再动代码。
5.2 如何一眼识别指针传参陷阱
考场上时间紧，怎么快速判断交换语句该写成什么样子？我的经验是分三步走：
第一步，看函数形参的类型。如果排序函数形参是int *p，那么数组元素本身是int类型，交换两个元素时，实参必须给出“元素的地址”，也就是&p[i]、&p[min_idx]。如果你看到题目提供的交换函数形参是int *，而交换调用写的是p[i]，基本可以断定这里有陷阱。
第二步，看swap函数内是否用了解引用。一个正确的指针交换函数内部必然存在*x = *y这类语句。如果swap内部直接写x = y，那就是在交换地址，不是交换值。
第三步，验证边界。n为1时，外层循环i < n - 1不执行，所以没有任何操作，也算是完好；n为0时，n - 1是-1，循环不执行，只要不访问数组就不出错。但考试给的数组一般最少也有5个元素，不用太焦虑。
5.3 个人总结的实战答题套路
这么多年做真题和模拟题，我总结出一套对付“排序+指针”填空的思路，分享给你。
不管题目是填空还是改错，先把算法的骨架写出来：外层循环控制轮数，内层循环找最值下标，最后交换。然后检查形参和实参的类型是否匹配。特别关注交换那行：如果自己写交换函数，务必保证形参是指针，实参是地址。如果题目已经给了固定的函数头，比如void swap(int *a, int *b)，你写调用时就在两个参数前加&。
还有一个习惯帮我避过无数坑：每写完一个函数，先用一个只有三个元素的数组去验。比如int test[3] = {3, 1, 2};，排序后如果能输出1 2 3，基本没问题。三个元素容易目测验证，而且能覆盖内外层循环和交换逻辑。手算也是好办法：第一轮min_idx应该等于1，交换后数组变成1 3 2，第二轮再变成1 2 3。每一步都跟代码走一遍，错误立刻现形。
另外，考前的机试环境里，编译器不会像Dev-C++那么“温柔”，很多省略函数声明的情况会直接报warning甚至错误。建议在任何使用了自定义函数的文件里，把函数定义放在调用之前，或者在开头声明函数原型。比如void swap(int *x, int *y);，这样能省下不少在改错题里找语法错误的工夫。
最后再分享一个小技巧，是踩过多次坑之后练出来的：我写这类排序题，会先在草稿纸上写一遍“数组下标版”，确认逻辑无误；然后机械地把a[i]改成*(p + i)，把交换两个数组元素的调用改成swap(&p[i], &p[min_idx])。这一步一步来的好处是，算法逻辑和指针语法被拆成两个独立环节，每一环都不容易出错。做完之后再问自己三个问题：形参是不是指针？swap的实参是不是地址？swap内部解引用了吗？三个问题都答“是”，这道题的分数基本就稳了。
