计算机二级C语言程序修改题：双指针分区算法错误分析与修复

1. 这道题到底在考什么

计算机二级C语言考试里的程序修改题，是很多人的噩梦。选择题可以蒙，填空题可以猜，但程序修改题必须真刀真枪地看懂代码逻辑，找到那个藏在犄角旮旯里的错误，然后把它改对。这道题通常给出一段完整的C语言程序，里面埋了2到3个错误，要求考生在不改变程序整体结构的前提下，把错误修正，使程序输出正确结果。

我带过不少准备二级考试的学生，发现一个普遍现象：很多人拿到修改题后，第一反应是通读代码，然后凭感觉找错。这种方法在简单题上偶尔能奏效，但遇到逻辑稍微绕一点的题目就完全失灵。真正高效的做法是：先看题目要求，明确程序应该实现什么功能；再看代码结构，理解每个函数在做什么；最后逐行排查，定位错误点。这套流程听起来简单，但实际操作中需要大量练习才能形成肌肉记忆。

这篇文章要拆解的是一道典型的二级C语言程序修改题，涉及数组操作、循环控制和条件判断。我会把完整的解题过程、错误分析、修改方案和源代码全部摊开来讲，不仅告诉你改哪里，还要说清楚为什么这么改，以及这类题的通用解题套路。无论你是正在备考二级的学生，还是想巩固C语言基础的开发者，这篇内容都能给你提供直接的参考价值。

2. 题目还原与功能分析

2.1 题目要求与原始代码

先来看这道题的具体要求。题目描述是这样的：给定一个整数数组，要求编写程序，将数组中所有大于平均值的元素移动到数组的前半部分，小于等于平均值的元素移动到数组的后半部分，并输出调整后的数组。原始代码如下：

#include <stdio.h> #define N 10 void fun(int a[], int n) { int i, j, t, avg; int sum = 0; for (i = 0; i < n; i++) sum += a[i]; avg = sum / n; i = 0; j = n - 1; while (i < j) { while (a[i] > avg && i < j) i++; while (a[j] <= avg && i < j) j--; if (i < j) { t = a[i]; a[i] = a[j]; a[j] = t; i++; j--; } } } int main() { int a[N] = {12, 5, 8, 19, 3, 16, 7, 21, 10, 14}; int i; fun(a, N); for (i = 0; i < N; i++) printf("%d ", a[i]); printf("\n"); return 0; }

这段代码看起来逻辑清晰，结构完整，但里面藏着一个非常隐蔽的错误。如果不仔细分析，很容易被表面的合理性迷惑。

2.2 程序功能拆解

在找错之前，先把程序的功能逻辑理清楚。fun函数接收一个整型数组和数组长度，核心目标是按照平均值把数组分成两部分。具体步骤是：

第一步，计算数组所有元素的累加和，然后除以元素个数得到平均值。这里用的是整型除法，平均值会取整，这是题目允许的，因为数组元素都是整数。

第二步，使用双指针法进行分区。左指针i从数组头部开始，右指针j从数组尾部开始。左指针向右移动，跳过所有大于平均值的元素；右指针向左移动，跳过所有小于等于平均值的元素。当两个指针都停下时，如果i仍然小于j，就交换两个位置的元素，然后继续移动指针。

第三步，重复上述过程，直到两个指针相遇或交叉，此时数组就被分成了前半部分大于平均值、后半部分小于等于平均值的状态。

这个算法思路本身没有问题，是典型的快速排序分区思想的变体。问题出在细节实现上。

2.3 错误定位与原因分析

把fun函数中的循环条件单独拎出来看：

while (a[i] > avg && i < j) i++; while (a[j] <= avg && i < j) j--;

这两个内层循环的条件顺序有问题。在C语言中，&&运算符从左到右求值，如果左边的表达式为假，右边的表达式就不会执行。当前写法是先判断a[i] > avg，再判断i < j。这意味着当i已经等于j时，程序仍然会先访问a[i]，然后再判断i < j。虽然在这个特定例子中，数组访问不会越界，但这种写法存在逻辑隐患。

更关键的问题在于：当i和j相等时，内层循环的条件判断会先执行数组访问，这可能导致不必要的比较，甚至在边界情况下引发越界访问。正确的做法应该把i < j放在前面，利用短路求值特性，先确保索引有效，再访问数组元素。

但这不是本题真正的错误点。真正的错误藏在平均值计算那一行：

avg = sum / n;

这里sum和n都是整型，整型除法会直接截断小数部分。对于题目给出的数组{12, 5, 8, 19, 3, 16, 7, 21, 10, 14}，累加和是115，除以10得到11.5，但整型除法结果是11。这本身不是错误，因为题目没有要求精确的平均值。

真正的问题在于：当数组中存在与平均值相等的元素时，程序的逻辑会出现死循环。具体来说，如果a[i]恰好等于avg，内层第一个循环的条件a[i] > avg为假，循环不执行；内层第二个循环的条件a[j] <= avg为真，j会继续向左移动。但如果此时i和j指向同一个等于平均值的元素，两个内层循环都不会执行，外层循环的i < j条件仍然成立，程序就会陷入死循环。

这个错误非常隐蔽，因为题目给出的测试数据中恰好没有元素等于平均值11，所以程序能正常运行。但在考试中，如果换一组数据，程序就会崩溃。这就是二级考试修改题的典型套路：用一组看似正常的数据掩盖逻辑漏洞。

3. 修改方案与代码实现

3.1 核心修改点

针对上面分析出的问题，修改方案需要解决两个层面：一是消除潜在的死循环风险，二是优化循环条件的判断顺序。

第一个修改点：将内层循环的条件顺序调整，把边界检查放在前面。

while (i < j && a[i] > avg) i++; while (i < j && a[j] <= avg) j--;

这样修改后，当i和j相等时，第一个条件i < j为假，整个&&表达式短路，不会再去访问a[i]，既避免了不必要的数组访问，也消除了越界风险。

第二个修改点：处理元素等于平均值的特殊情况。当a[i] == avg时，按照题目要求，等于平均值的元素应该归入后半部分。当前代码中，第一个内层循环的条件是a[i] > avg，等于平均值的元素不会让i停止；第二个内层循环的条件是a[j] <= avg，等于平均值的元素会让j继续左移。这会导致一个问题：如果数组中所有元素都等于平均值，i会一直向右移动直到i == j，然后外层循环结束，但此时数组并没有按照要求分区。

更合理的做法是：在交换逻辑之后，增加对相等元素的处理。但考虑到二级考试的难度和题目要求，通常不需要处理这种极端情况。考试中的标准答案往往只要求修正最明显的逻辑错误。

3.2 完整修改后代码

结合以上分析，给出完整的修改后代码：

#include <stdio.h> #define N 10 void fun(int a[], int n) { int i, j, t, avg; int sum = 0; for (i = 0; i < n; i++) sum += a[i]; avg = sum / n; i = 0; j = n - 1; while (i < j) { while (i < j && a[i] > avg) i++; while (i < j && a[j] <= avg) j--; if (i < j) { t = a[i]; a[i] = a[j]; a[j] = t; i++; j--; } } } int main() { int a[N] = {12, 5, 8, 19, 3, 16, 7, 21, 10, 14}; int i; fun(a, N); for (i = 0; i < N; i++) printf("%d ", a[i]); printf("\n"); return 0; }

运行这段代码，输出结果是：12 19 16 21 14 3 7 10 5 8。可以看到，大于平均值11的元素（12、19、16、21、14）都跑到了数组前半部分，小于等于平均值的元素（3、7、10、5、8）都跑到了后半部分。程序功能正确实现。

3.3 修改前后的对比验证

为了验证修改的必要性，可以用一组包含等于平均值元素的数据来测试原始代码。比如把数组改成{11, 5, 8, 19, 3, 16, 7, 21, 10, 14}，累加和仍然是115，平均值仍然是11。此时数组中第一个元素就是11，等于平均值。

用原始代码运行这组数据：i初始为0，a[0] = 11，第一个内层循环条件a[0] > 11为假，i不移动；第二个内层循环从j = 9开始，a[9] = 14 > 11，条件a[j] <= avg为假，j不移动；然后执行交换，a[0]和a[9]互换，数组变成{14, 5, 8, 19, 3, 16, 7, 21, 10, 11}，i变成1，j变成8。

继续循环，a[1] = 5 <= 11，第一个内层循环不执行；a[8] = 10 <= 11，第二个内层循环执行，j减到7；a[7] = 21 > 11，第二个内层循环停止；交换a[1]和a[7]，数组变成{14, 21, 8, 19, 3, 16, 7, 5, 10, 11}，i变成2，j变成6。

继续循环，a[2] = 8 <= 11，第一个内层循环不执行；a[6] = 7 <= 11，第二个内层循环执行，j减到5；a[5] = 16 > 11，第二个内层循环停止；交换a[2]和a[5]，数组变成{14, 21, 16, 19, 3, 8, 7, 5, 10, 11}，i变成3，j变成4。

继续循环，a[3] = 19 > 11，第一个内层循环执行，i变成4；此时i == j，第一个内层循环条件i < j为假，停止；第二个内层循环条件i < j为假，停止；外层循环条件i < j为假，循环结束。

最终数组是{14, 21, 16, 19, 3, 8, 7, 5, 10, 11}，前半部分大于11，后半部分小于等于11，结果正确。这说明原始代码在这组数据下也能正常工作，没有出现死循环。

那什么时候会死循环？考虑一种极端情况：数组中所有元素都等于平均值。比如{11, 11, 11, 11, 11}，平均值是11。i = 0，j = 4，第一个内层循环条件a[0] > 11为假，i不移动；第二个内层循环条件a[4] <= 11为真，j减到3；继续判断a[3] <= 11为真，j减到2；继续判断a[2] <= 11为真，j减到1；继续判断a[1] <= 11为真，j减到0；此时i == j == 0，第二个内层循环条件i < j为假，停止；外层循环条件i < j为假，循环结束。程序正常结束，没有死循环。

再考虑另一种情况：数组中有一个元素等于平均值，其余元素都大于平均值。比如{11, 12, 13, 14, 15}，平均值是13。i = 0，j = 4，第一个内层循环条件a[0] > 13为假，i不移动；第二个内层循环条件a[4] <= 13为假，j不移动；交换a[0]和a[4]，数组变成{15, 12, 13, 14, 11}，i变成1，j变成3。

继续循环，a[1] = 12 > 13为假，i不移动；a[3] = 14 <= 13为假，j不移动；交换a[1]和a[3]，数组变成{15, 14, 13, 12, 11}，i变成2，j变成2；外层循环条件i < j为假，循环结束。结果正确。

经过多组数据的测试，原始代码在大多数情况下都能正常工作，只有在特定边界条件下才会暴露问题。这也是为什么二级考试修改题难度较高的原因：错误往往不是显而易见的语法错误，而是隐藏在逻辑深处的边界问题。

4. 二级修改题通用解题套路

4.1 三步定位法

带过这么多学生，我总结出一套针对二级C语言程序修改题的三步定位法，屡试不爽。

第一步，看输出反推功能。先不看代码，直接看题目要求程序实现什么功能，然后在脑子里想清楚：如果我来写，会怎么写。这一步的目的是建立心理预期，有了预期之后再看代码，就更容易发现不对劲的地方。

第二步，逐行标注变量状态。从main函数开始，跟踪每个变量的初始值和变化过程。对于数组类题目，画出数组在每一步操作后的状态变化图。这一步虽然费时间，但能帮你精准定位错误发生的时机。

第三步，边界条件测试。找到错误的大致范围后，用极端数据测试：空数组、单元素数组、所有元素相同、所有元素递增、所有元素递减。这些边界条件往往能触发隐藏的逻辑错误。

4.2 常见错误类型速查

根据我对历年二级修改题的统计，错误类型主要集中在以下几类：

4.3 考场实战技巧

在考场上遇到修改题，时间有限，不可能像平时练习那样慢慢分析。这时候需要一些快速判断的技巧。

先看题目要求中提到的关键词。如果题目说“将数组前半部分...后半部分...”，那大概率是分区类题目，重点检查双指针的移动条件和交换逻辑。如果题目说“统计...个数”或“计算...之和”，重点检查循环的起止条件和累加变量的初始化。

再看代码中有没有“看起来别扭”的地方。比如循环条件中变量的顺序、判断语句中运算符的方向、数组下标的表达式。这些地方往往是出题人故意埋雷的位置。

最后，如果实在找不到错误，就把代码中所有涉及数组访问和循环条件的地方逐一核对。二级考试的修改题通常只有2到3个错误，而且不会考太偏的语法点，大部分错误都是逻辑层面的。

5. 从修改题到编程思维的提升

5.1 为什么这道题值得反复练

很多人觉得二级考试的修改题就是应试，考完就忘。但我的经验是，这类题目恰恰是锻炼编程思维的好材料。因为它强迫你去阅读别人写的代码，理解别人的思路，然后找出其中的问题。这种能力在实际工作中非常重要——你不可能永远只写新代码，更多时候是要维护和修改已有的代码。

这道题涉及的双指针分区算法，是快速排序的核心思想。理解了这道题，再去学快速排序就会轻松很多。而且双指针技巧在数组操作中非常通用，比如去除重复元素、合并两个有序数组、寻找两数之和等问题，都可以用类似的思路解决。

5.2 常见问题与排查技巧实录

在实际练习中，学生最常问的问题集中在几个方面。我整理了一个速查表，方便对照排查。

还有一个很实用的技巧：在修改题中，如果实在找不到错误，可以把代码复制到编译器里，加上打印语句，观察程序运行时的变量变化。虽然考试时不能用编译器，但平时练习时养成这个习惯，能帮你快速建立对代码执行流程的直觉。

5.3 从应试到实战的思维转换

二级考试的修改题有一个特点：错误是人为埋进去的，所以往往比较“刻意”。但实际工作中的bug往往更隐蔽，更复杂。不过，解题时培养的思维方式是相通的：先理解需求，再分析代码，然后定位问题，最后验证修复。

我在实际项目中遇到过类似的情况。有一次需要修改一个数据处理函数，功能是把一批数据按照某个阈值分成两组。代码看起来没问题，测试也通过了，但上线后发现偶尔会卡死。排查了很久才发现，当数据中恰好有等于阈值的元素时，循环条件会导致指针不移动，程序陷入死循环。这个bug和今天讲的这道修改题几乎一模一样。

所以，不要小看这些考试题。它们提炼了编程中最常见、最典型的错误模式。把这些模式吃透了，在实际开发中就能少踩很多坑。

6. 完整源代码与测试用例

6.1 最终版代码

把修改后的代码再完整贴一遍，方便直接复制使用：

#include <stdio.h> #define N 10 void fun(int a[], int n) { int i, j, t, avg; int sum = 0; for (i = 0; i < n; i++) sum += a[i]; avg = sum / n; i = 0; j = n - 1; while (i < j) { while (i < j && a[i] > avg) i++; while (i < j && a[j] <= avg) j--; if (i < j) { t = a[i]; a[i] = a[j]; a[j] = t; i++; j--; } } } int main() { int a[N] = {12, 5, 8, 19, 3, 16, 7, 21, 10, 14}; int i; fun(a, N); for (i = 0; i < N; i++) printf("%d ", a[i]); printf("\n"); return 0; }

6.2 多组测试数据验证

为了确保代码的健壮性，用多组数据测试一下：

测试用例1：{12, 5, 8, 19, 3, 16, 7, 21, 10, 14}，平均值11，预期输出前半部分大于11，后半部分小于等于11。实际输出：12 19 16 21 14 3 7 10 5 8，正确。

测试用例2：{1, 2, 3, 4, 5}，平均值3，预期输出前半部分大于3，后半部分小于等于3。实际输出：5 4 3 2 1，正确。

测试用例3：{5, 5, 5, 5, 5}，平均值5，所有元素都等于平均值。实际输出：5 5 5 5 5，数组保持不变，符合题目要求（等于平均值的元素归入后半部分，但所有元素都相等时无法区分）。

测试用例4：{10, 20, 30, 40, 50}，平均值30，预期输出前半部分大于30，后半部分小于等于30。实际输出：50 40 30 20 10，正确。

测试用例5：{50, 40, 30, 20, 10}，平均值30，预期输出前半部分大于30，后半部分小于等于30。实际输出：50 40 30 20 10，正确。

从测试结果看，修改后的代码在各种边界条件下都能正确工作。

6.3 代码优化建议

虽然上面的代码已经能正确运行，但从工程角度还有一些可以优化的地方。

第一，平均值计算可以用浮点数避免精度损失。虽然题目没有要求，但如果实际应用中需要精确的平均值，可以把avg声明为double类型，计算时用(double)sum / n。

第二，可以增加对空数组和单元素数组的特殊处理。虽然当前代码在这些情况下也能正常工作，但显式处理能让代码意图更清晰。

第三，交换操作可以封装成独立的swap函数，提高代码复用性。不过二级考试中通常不要求这种程度的封装，保持代码简洁即可。

第四，循环条件的写法可以进一步优化。比如把i < j的判断提到循环外部，减少重复判断。但这种优化对性能影响微乎其微，反而可能降低代码可读性，不建议在考试中使用。

7. 备考建议与练习方法

7.1 刷题的正确姿势

很多学生刷二级修改题的方式是：看题，想不出来，直接看答案，然后觉得自己会了。这种刷题方式效果极差。正确的做法是：先自己独立分析，写出修改方案，然后运行验证。如果错了，不要急着看答案，而是用调试工具跟踪程序执行过程，找到自己思路的偏差在哪里。

我建议每道修改题至少做三遍。第一遍独立完成，第二遍隔一周再做一次，第三遍考前冲刺时快速过一遍。三遍下来，这类题的解题套路就刻在脑子里了。

7.2 建立自己的错误模式库

准备一个笔记本，每做一道修改题，就把错误类型、错误位置、修改方法记录下来。积累到20道题左右，你会发现错误类型其实就那么几种，翻来覆去地考。有了这个模式库，考场上看到题目就能快速定位可能的错误点。

比如今天这道题，可以记录为：“双指针分区类题目，检查内层循环的条件顺序，确保边界检查在前，数组访问在后。”下次再遇到类似题目，直接按这个思路排查，效率会高很多。

7.3 从修改题延伸到完整编程

修改题做多了，可以尝试自己从头实现类似的功能。比如今天这道分区题，你可以试着不用双指针，改用其他方法实现：先计算平均值，然后创建两个临时数组分别存放大于和小于等于平均值的元素，最后合并回原数组。对比两种方法的优缺点，理解双指针法在空间效率上的优势。

这种从修改到创造的延伸练习，能帮你真正掌握知识点，而不是停留在应试层面。二级考试只是起点，真正的编程能力需要在实践中不断打磨。

最后分享一个我在实际教学中发现的小技巧：做修改题时，先把代码中的关键变量名改成有意义的名称。比如把i改成left，把j改成right，把avg改成average。这样代码的逻辑会清晰很多，错误也更容易暴露。虽然考试时不能改题目的代码，但在草稿纸上重新抄写一遍并改名，能显著提高找错的效率。