浙江高考VB排序系列：冒泡与选择排序代码实现及应试技巧

1. 从一道排序题说起：为什么VB排序值得单独拎出来讲

每年到了技术科目备考的冲刺阶段，总有一批同学在排序算法这块反复栽跟头。选择题里问“冒泡排序第三轮结束后序列长什么样”，填空题里给一段残缺代码让你补全循环边界，上机操作题更狠，直接让你手写一个完整的排序过程并输出每一轮结果。我带过几届学生，发现一个规律：排序题丢分的人，往往不是不懂算法思想，而是栽在VB这门语言的实现细节上。数组下标从0还是从1开始、循环变量在内外层怎么配合、什么时候交换、什么时候只做比较不做交换，这些细节一旦搞混，整道题就全盘皆输。

“浙江高考VB之排序系列”这个标题，说白了就是围绕技术科目选考中VB排序相关题型做的一套系统梳理。它要解决的核心问题很明确：把冒泡排序和选择排序这两种高频考点的代码实现、执行过程、变式考法讲透，让考生能在考场上快速识别题型、准确写出代码、稳定拿到分数。适合谁来参考？一是正在备考技术科目选考的高中生，二是需要快速回顾VB排序知识点的复读生，三是想帮学生梳理考点的技术老师。哪怕你之前VB基础一般，只要跟着把几种经典写法和常见坑过一遍，排序题这块基本能稳住。

我下面要聊的，不是教科书式的算法定义，而是从实际做题和教学反馈中总结出来的可操作、可复现、能直接抄作业的VB排序实战经验。包括代码怎么写、循环怎么设、每一轮怎么推、遇到变式怎么拆，以及那些只有踩过坑才知道的细节。

2. 排序题在技术科目里的真实分量与考查逻辑

2.1 为什么命题组偏爱排序这个考点

排序算法在技术科目里的地位，有点像数学里的函数——它是很多后续内容的基础，同时本身又有足够的深度可以出题。命题组喜欢排序，原因有几个。第一，排序过程有明确的中间状态，每一轮结束后数组都会发生变化，这就给选择题和填空题提供了天然的素材。第二，排序代码长度适中，既不会短到一眼看穿，也不会长到写不完，刚好能考查循环嵌套、条件判断、数组操作这几个核心能力。第三，排序有多种变式，正序倒序、从大到小从小到大、冒泡选择交替出现，可以反复出题而不重复。

从历年真题来看，排序相关题目的分值占比相当稳定。选择题里通常有1到2道，填空题里可能有一道代码补全，上机操作题里排序更是常客。加起来，排序这块的分值能占到整个技术科目编程部分的相当比例。换句话说，排序题拿不稳，编程部分就很难拿到高分。

2.2 冒泡排序和选择排序的考查侧重点差异

很多同学把冒泡和选择混在一起记，觉得都是双重循环、都是比较交换，差不多。但实际上，这两种排序在考查侧重点上有明显差异，做题时如果分不清，很容易用错方法。

冒泡排序的核心特征是相邻比较、逐步把最大或最小元素“冒”到一端。它的中间状态很有规律：每一轮结束后，未排序部分的边界会缩小一个位置。命题组喜欢考“第N轮结束后数组的排列情况”，因为冒泡的中间状态是可以精确推导的。

选择排序的核心特征是每轮找到最小或最大元素，然后与指定位置交换。它的中间状态特点是：每一轮只发生一次交换（或者零次），但比较次数是固定的。命题组喜欢考“交换次数”或者“比较次数”，因为选择排序的交换次数与初始序列有关，而比较次数是固定的。

注意：做题时先判断题目描述的是哪种排序。如果题目说“相邻两个元素比较”，那就是冒泡；如果说“找出最小元素然后交换”，那就是选择。这个判断错了，后面全错。

2.3 从考纲要求反推备考重点

技术科目考纲对排序的要求，概括起来就是三个层次。第一层是理解算法思想，能用自己的话说清楚冒泡和选择是怎么工作的。第二层是能读懂代码，给一段VB排序代码，能说出每一句在干什么，能判断循环边界是否正确。第三层是能写出代码，给定排序需求，能独立写出完整的VB实现，包括数组声明、循环结构、交换逻辑和输出。

备考的重点应该放在第二层和第三层。因为第一层太基础，命题组不会直接考“请描述冒泡排序的思想”这种题，而是把它融入到代码阅读和代码编写中。所以，光背概念没用，必须动手写代码、手动推过程。我建议每个同学至少把冒泡和选择的完整代码默写三遍，直到不看任何参考就能写出来。

3. 冒泡排序的VB实现：从代码框架到逐轮推演

3.1 标准冒泡排序代码的逐句拆解

先看一段标准的VB冒泡排序代码，把数组从小到大排序：

Dim a(1 To 10) As Integer Dim i As Integer, j As Integer, t As Integer ' 假设数组a已经赋好初值 For i = 1 To 9 For j = 1 To 10 - i If a(j) > a(j + 1) Then t = a(j) a(j) = a(j + 1) a(j + 1) = t End If Next j Next i

这段代码虽然短，但每一句都有讲究。外层循环For i = 1 To 9控制的是排序的轮数。10个元素的数组，最多需要9轮就能排好。为什么是9不是10？因为每一轮会把一个元素放到最终位置，当9个元素都到位了，剩下的那个自然也就到位了。

内层循环For j = 1 To 10 - i控制的是每一轮比较的次数。第一轮i=1，j从1到9，比较a(1)和a(2)、a(2)和a(3)一直到a(9)和a(10)，共9次。第二轮i=2，j从1到8，共8次。每轮比较次数递减1，因为每轮结束后，末尾就多了一个已经排好的元素，不需要再比较了。

条件判断If a(j) > a(j + 1)决定是升序还是降序。如果写成<，就是从大到小排序。交换部分用临时变量t完成三个赋值，这是VB里交换两个变量的标准写法，不能省略任何一步。

提示：数组下标从1开始时，a(j)和a(j+1)的边界要特别注意。当j取到10-i时，j+1最大是11-i，在第一轮i=1时最大是10，刚好不越界。如果内层循环写成For j = 1 To 10，就会在j=10时访问a(11)，导致下标越界错误。

3.2 手动推演每一轮的变化过程

光看代码不够，必须能手动推出每一轮结束后数组的状态。假设初始数组是[5, 3, 8, 1, 9, 2, 7, 4, 6, 0]，我们推一下冒泡排序的前三轮。

第一轮i=1，j从1到9。比较过程如下：5和3比，交换，数组变[3, 5, 8, 1, 9, 2, 7, 4, 6, 0]；5和8比，不交换；8和1比，交换，变[3, 5, 1, 8, 9, 2, 7, 4, 6, 0]；8和9比，不交换；9和2比，交换，变[3, 5, 1, 8, 2, 9, 7, 4, 6, 0]；9和7比，交换，变[3, 5, 1, 8, 2, 7, 9, 4, 6, 0]；9和4比，交换，变[3, 5, 1, 8, 2, 7, 4, 9, 6, 0]；9和6比，交换，变[3, 5, 1, 8, 2, 7, 4, 6, 9, 0]；9和0比，交换，变[3, 5, 1, 8, 2, 7, 4, 6, 0, 9]。第一轮结束，最大的9被冒到了最后。

第二轮i=2，j从1到8。此时数组是[3, 5, 1, 8, 2, 7, 4, 6, 0, 9]。3和5比不交换；5和1比交换，变[3, 1, 5, 8, 2, 7, 4, 6, 0, 9]；5和8比不交换；8和2比交换，变[3, 1, 5, 2, 8, 7, 4, 6, 0, 9]；8和7比交换，变[3, 1, 5, 2, 7, 8, 4, 6, 0, 9]；8和4比交换，变[3, 1, 5, 2, 7, 4, 8, 6, 0, 9]；8和6比交换，变[3, 1, 5, 2, 7, 4, 6, 8, 0, 9]；8和0比交换，变[3, 1, 5, 2, 7, 4, 6, 0, 8, 9]。第二轮结束，第二大的8被冒到了倒数第二位。

第三轮i=3，j从1到7。数组是[3, 1, 5, 2, 7, 4, 6, 0, 8, 9]。3和1比交换，变[1, 3, 5, 2, 7, 4, 6, 0, 8, 9]；3和5比不交换；5和2比交换，变[1, 3, 2, 5, 7, 4, 6, 0, 8, 9]；5和7比不交换；7和4比交换，变[1, 3, 2, 5, 4, 7, 6, 0, 8, 9]；7和6比交换，变[1, 3, 2, 5, 4, 6, 7, 0, 8, 9]；7和0比交换，变[1, 3, 2, 5, 4, 6, 0, 7, 8, 9]。第三轮结束，7被放到了倒数第三位。

这种手动推演的能力，是应对选择题和填空题的基本功。建议至少拿五组不同的初始序列练手，每组推三轮以上，直到能在两分钟内准确写出任意一轮结束后的数组状态。

3.3 冒泡排序的常见变式与应对策略

冒泡排序在考试中不会永远以标准形式出现，常见的变式有几种。第一种是改变排序方向，从大到小排序，只需要把If a(j) > a(j + 1)改成If a(j) < a(j + 1)。第二种是改变循环边界，比如内层循环写成For j = 10 To i + 1 Step -1，从后往前比较，效果是一样的，但中间状态不同。第三种是增加标志位优化，如果某一轮没有发生任何交换，说明已经有序，可以提前结束。

标志位优化的代码长这样：

Dim flag As Boolean For i = 1 To 9 flag = False For j = 1 To 10 - i If a(j) > a(j + 1) Then t = a(j): a(j) = a(j + 1): a(j + 1) = t flag = True End If Next j If Not flag Then Exit For Next i

这种优化版本在考试中出现的频率不低，尤其是填空题里让你补全flag的判断逻辑。关键点是：flag在每一轮开始前要重置为False，发生交换后设为True，一轮结束后检查flag，如果还是False就退出外层循环。

注意：有些题目会问“优化后的冒泡排序最多比较多少次”，答案是原始的比较次数，因为优化只减少轮数，不改变每轮的比较次数。但“最少比较多少次”就取决于初始序列，如果初始就有序，只需要一轮比较n-1次就结束。

4. 选择排序的VB实现：交换逻辑与边界处理

4.1 标准选择排序代码的结构分析

选择排序的VB实现如下：

Dim a(1 To 10) As Integer Dim i As Integer, j As Integer, t As Integer, k As Integer ' 假设数组a已经赋好初值 For i = 1 To 9 k = i For j = i + 1 To 10 If a(j) < a(k) Then k = j Next j If k <> i Then t = a(i): a(i) = a(k): a(k) = t End If Next i

这段代码和冒泡最大的区别在于：内层循环只负责找最小元素的下标，不进行交换。变量k用来记录当前找到的最小元素的位置，初始设为i。内层循环从i+1开始，遍历到数组末尾，每次发现更小的元素就更新k。内层循环结束后，如果k不等于i，说明找到了比a(i)更小的元素，交换a(i)和a(k)。

外层循环For i = 1 To 9表示需要进行9轮选择。每一轮确定一个位置上的最终元素。第一轮确定a(1)的最小值，第二轮确定a(2)的最小值，以此类推。

提示：If k <> i Then这个判断不能省。如果k等于i，说明a(i)本身就是剩余部分中最小的，不需要交换。虽然不判断也不会出错（自己和自己交换结果一样），但考试中如果题目问“交换次数”，这个判断会影响结果。有判断时，交换次数可能少于n-1；没判断时，交换次数固定是n-1。

4.2 选择排序每轮的比较与交换次数

选择排序的一个显著特点是：比较次数固定，交换次数不固定。对于n个元素，第一轮比较n-1次，第二轮比较n-2次，一直到最后一轮比较1次，总比较次数是n(n-1)/2。这个数字是固定的，不管初始序列是什么。

交换次数则取决于初始序列。最好情况是初始已经有序，每次k都等于i，交换0次。最坏情况是初始完全逆序，每次都需要交换，交换n-1次。考试中经常考“给定初始序列，选择排序需要交换几次”，这时候就要逐轮判断。

举个例子，初始数组[5, 3, 8, 1, 9, 2, 7, 4, 6, 0]。第一轮i=1，k初始为1，a(1)=5。j从2到10，a(2)=3小于5，k=2；a(3)=8不小于3；a(4)=1小于3，k=4；后面没有比1更小的了。k=4不等于i=1，交换a(1)和a(4)，数组变[1, 3, 8, 5, 9, 2, 7, 4, 6, 0]，交换1次。

第二轮i=2，k初始为2，a(2)=3。j从3到10，a(3)=8不小于3；a(4)=5不小于3；a(5)=9不小于3；a(6)=2小于3，k=6；a(7)=7不小于2；a(8)=4不小于2；a(9)=6不小于2；a(10)=0小于2，k=10。k=10不等于i=2，交换a(2)和a(10)，数组变[1, 0, 8, 5, 9, 2, 7, 4, 6, 3]，交换1次。

第三轮i=3，k初始为3，a(3)=8。j从4到10，a(4)=5小于8，k=4；a(5)=9不小于5；a(6)=2小于5，k=6；a(7)=7不小于2；a(8)=4不小于2；a(9)=6不小于2；a(10)=3不小于2。k=6不等于i=3，交换a(3)和a(6)，数组变[1, 0, 2, 5, 9, 8, 7, 4, 6, 3]，交换1次。

三轮下来交换了3次。这种逐轮推演的能力，和冒泡一样重要。

4.3 选择排序的变式：从大到小与双向选择

选择排序的变式主要有两种。第一种是从大到小排序，只需要把If a(j) < a(k)改成If a(j) > a(k)，找最大元素放到前面。第二种是双向选择排序，每一轮同时找最小和最大元素，分别放到两端。这种变式在考试中偶尔出现，代码会复杂一些，但核心逻辑不变。

双向选择排序的代码框架：

Dim left As Integer, right As Integer left = 1: right = 10 Do While left < right Dim minIdx As Integer, maxIdx As Integer minIdx = left: maxIdx = left For j = left To right If a(j) < a(minIdx) Then minIdx = j If a(j) > a(maxIdx) Then maxIdx = j Next j ' 交换最小元素到left位置 t = a(left): a(left) = a(minIdx): a(minIdx) = t ' 注意：如果最大元素原本在left位置，交换后位置变了 If maxIdx = left Then maxIdx = minIdx ' 交换最大元素到right位置 t = a(right): a(right) = a(maxIdx): a(maxIdx) = t left = left + 1 right = right - 1 Loop

这段代码里有一个非常容易出错的点：如果最大元素原本在left位置，第一次交换后它被换到了minIdx位置，所以需要更新maxIdx。这个细节在考试中经常作为陷阱出现，很多同学写代码时忽略了这个判断，导致结果错误。

注意：双向选择排序的循环条件left < right，当left等于right时说明中间只剩一个元素，不需要再排序。如果写成left <= right，当left等于right时会多执行一轮，虽然结果可能正确，但效率降低，而且可能引发不必要的交换。

5. 排序题的通用解题框架与考场实战技巧

5.1 快速识别题型的三步判断法

拿到一道排序题，第一步是判断排序类型。看题目描述里有没有“相邻”“冒泡”“依次比较”这些词，有就是冒泡；看有没有“最小”“最大”“选择”“交换到指定位置”这些词，有就是选择。如果题目直接给代码让你补全，那就看代码结构：有k变量记录下标的，是选择排序；直接比较a(j)和a(j+1)的，是冒泡排序。

第二步是判断排序方向。看题目要求是从小到大还是从大到小，然后确定条件判断里的符号。升序用>（冒泡）或<（选择），降序反过来。

第三步是确定循环边界。冒泡的外层是1 To n-1，内层是1 To n-i。选择的外层是1 To n-1，内层是i+1 To n。如果题目给的代码边界和标准不一样，要仔细分析它的意图，可能是从后往前排，也可能是其他变式。

这三步判断法看起来简单，但在考场上能帮你快速定位解题方向，避免在错误的方向上浪费时间。

5.2 代码补全题的填空技巧

代码补全题是排序题里最容易丢分的题型，因为一个空填错，可能后面的空也跟着错。填空的技巧有几个。第一，先看空的位置在循环的哪一层。如果是外层循环的边界，通常和数组长度有关；如果是内层循环的边界，通常和外层变量有关。第二，看空的前后变量。如果空前面出现了k，那大概率是选择排序，空里可能填k = j或者k = i。第三，用特殊值验证。填完空后，假设数组长度为3，手动跑一遍，看逻辑是否通顺。

举个例子，题目给了一段冒泡排序代码，外层循环是For i = 1 To 4，数组长度是5，内层循环的空是For j = 1 To ___。根据冒泡的规律，内层应该是5 - i。验证一下：i=1时j到4，比较4次；i=4时j到1，比较1次。总共4轮，符合n-1=4。填5 - i正确。

提示：如果题目里的数组下标从0开始，所有边界都要相应调整。比如数组是a(0 To 4)，冒泡的内层循环可能是For j = 0 To 3 - i。做题时一定要先确认下标范围。

5.3 上机操作题的完整实现流程

上机操作题要求写完整的VB程序，包括界面设计和代码编写。排序部分通常占主要分值，但界面和输入输出也不能忽略。完整的实现流程是：先声明数组和变量，再读取输入数据到数组，然后执行排序，最后输出结果。

输入部分可以用文本框逐行输入，也可以用InputBox循环输入。输出部分可以用ListBox显示每一轮的结果，也可以用Print直接输出到窗体。如果题目要求“输出每一轮排序后的结果”，那就需要在排序的每一轮结束后加一个输出语句。

For i = 1 To 9 For j = 1 To 10 - i If a(j) > a(j + 1) Then t = a(j): a(j) = a(j + 1): a(j + 1) = t End If Next j ' 输出第i轮结果 For m = 1 To 10 Print a(m); Next m Print Next i

这段代码在每一轮冒泡结束后输出整个数组，方便观察中间状态。考试中如果题目没有明确要求输出中间轮次，可以只输出最终结果，节省时间。

5.4 时间分配与检查策略

排序题在试卷中的位置不同，时间分配也不同。选择题里的排序题，控制在1到2分钟内解决。填空题里的排序题，控制在3到5分钟。上机操作题里的排序部分，控制在10到15分钟。如果超过这个时间还没做出来，先跳过，做完其他题再回来。

检查策略方面，重点检查循环边界和条件判断。循环边界错了，整个排序结果就错了。条件判断错了，排序方向就反了。另外，如果题目要求输出中间状态，检查输出语句的位置是否正确，是在内层循环里还是外层循环里。

注意：上机操作题保存前一定要运行一遍，用题目给的示例数据测试。如果示例数据的结果和预期一致，基本没问题。如果时间允许，再用手动推演验证一轮中间状态。

6. 那些年踩过的坑：排序题常见错误与排查实录

6.1 循环边界错误导致的下标越界

下标越界是VB排序题里最高频的错误。典型场景是数组声明为a(1 To 10)，但循环写成了For j = 1 To 10，然后在循环体里访问a(j + 1)，当j=10时访问a(11)，直接报错“下标越界”。

这个错误的根源是没有把循环边界和数组边界对齐。冒泡排序的内层循环，j的最大值应该是n - i，这样j + 1的最大值是n - i + 1，在第一轮i=1时是n，刚好不越界。如果写成n，就多了一次。

排查方法很简单：在循环体里加一个Print语句，输出j和j+1的值，运行一次就能看到越界的位置。或者直接手动计算：当i=1时，j最大是多少，j+1是多少，是否超过数组上界。

提示：VB默认的数组下标从0开始，但很多教材和考试里用Option Base 1把默认下标改成1。做题时先看代码开头有没有Option Base 1，没有的话数组下标从0开始，所有边界都要减1。

6.2 交换逻辑写反或遗漏临时变量

交换两个变量的值，必须用临时变量，而且三个赋值的顺序不能错。正确的写法是：

t = a(j) a(j) = a(j + 1) a(j + 1) = t

如果写成：

a(j) = a(j + 1) a(j + 1) = a(j)

那就错了，因为第一步赋值后a(j)的值已经被覆盖，第二步赋值相当于把a(j+1)的值又赋给了自己，两个元素变成一样的了。

还有一种错误是临时变量声明了但没用，或者用了两个临时变量。VB里交换两个变量只需要一个临时变量，多声明不会报错，但逻辑上没必要。

排查方法：在交换前后各加一个Print语句，输出交换前后的值。如果交换后两个值相等，说明交换逻辑写错了。

6.3 选择排序中k变量初始化的时机

选择排序里，k变量用来记录最小元素的下标。它的初始化时机很关键：必须在每一轮外层循环开始时初始化为i，而不是在循环外初始化一次。

错误写法：

k = 1 For i = 1 To 9 For j = i + 1 To 10 If a(j) < a(k) Then k = j Next j ' 交换... Next i

这种写法里，k只在循环外初始化了一次，第二轮开始时k还是上一轮的值，导致找最小元素的范围出错。正确写法是把k = i放在外层循环内部，每一轮都重新初始化。

排查方法：在每一轮外层循环开始时输出k的值，如果k不是等于i，说明初始化位置错了。

6.4 排序方向与条件符号的对应关系

升序和降序的条件符号容易搞混。记住一个口诀：冒泡升序用大于，选择升序用小于。为什么？因为冒泡是相邻比较，如果前一个大于后一个就交换，大的往后走，最终升序。选择是找最小元素，如果当前元素小于记录的最小元素就更新，最终把最小的放到前面，也是升序。

降序反过来：冒泡降序用小于，选择降序用大于。

如果题目要求“从大到小排序”，冒泡的条件是If a(j) < a(j + 1) Then，选择的条件是If a(j) > a(k) Then。

注意：有些题目会故意把条件符号写反，然后问你“这段代码实现的是升序还是降序”。这时候不要凭感觉，手动推两个元素就能判断。比如数组[1, 2]，如果条件成立就交换，交换后变成[2, 1]，说明是降序。

6.5 常见问题速查表

这张表里的问题，基本覆盖了排序题90%以上的错误场景。考前过一遍，考场上遇到类似现象能快速定位。

7. 从应试到理解：排序思想的实际价值延伸

7.1 排序算法背后的计算思维

抛开考试不谈，排序算法本身承载的计算思维是很有价值的。冒泡排序体现的是“局部调整、逐步优化”的思路：不追求一步到位，而是通过反复的相邻比较和交换，让整个序列慢慢变得有序。这种思路在解决很多实际问题时都有影子，比如逐步优化一个方案、迭代改进一个设计。

选择排序体现的是“全局扫描、一次定位”的思路：每一轮都完整扫描剩余部分，找到极值后再做决定。这种思路适合那些“需要全局信息才能做决策”的场景，比如从一堆候选方案中选出最优的。

这两种思路没有优劣之分，只是适用场景不同。考试考的是你能不能根据问题特征选择合适的算法，以及能不能用VB准确实现。

7.2 排序代码的调试与验证方法

写排序代码时，调试和验证的方法很重要。我常用的方法是小数据量手动推演加Print输出。先用3到5个元素的小数组，手动推演每一轮的结果，然后运行代码，用Print输出每一轮的实际结果，对比是否一致。如果不一致，就缩小范围，看是哪一轮开始出现偏差，然后检查那一轮的循环边界和条件判断。

另一种方法是用极端数据测试。比如完全逆序的数组、完全有序的数组、所有元素相同的数组。这些极端情况能暴露很多边界问题。完全逆序时交换次数最多，完全有序时如果用了标志位优化会提前结束，所有元素相同时排序结果应该不变。

提示：VB里可以用Debug.Print在立即窗口输出调试信息，不干扰窗体上的正常输出。调试排序代码时，把每一轮的中间状态用Debug.Print输出，方便对比。

7.3 从VB排序到其他语言的迁移

VB排序的代码逻辑，迁移到其他语言时，核心结构是一样的，只是语法不同。比如Python里冒泡排序：

for i in range(len(a) - 1): for j in range(len(a) - 1 - i): if a[j] > a[j + 1]: a[j], a[j + 1] = a[j + 1], a[j]

选择排序：

for i in range(len(a) - 1): k = i for j in range(i + 1, len(a)): if a[j] < a[k]: k = j if k != i: a[i], a[k] = a[k], a[i]

对比一下就能发现，循环的边界逻辑完全一致，只是Python的range不包含上界，所以写起来更简洁。交换在Python里可以用元组解包一行完成，不需要临时变量。

理解了VB排序的底层逻辑，换任何语言都能快速写出对应的实现。这也是为什么技术科目要考排序——它考的不是VB语法本身，而是你对算法逻辑的理解和表达能力。

7.4 给备考同学的几条实在建议

最后分享几条我在教学和备考中总结的实在建议。第一，不要只背代码，要手动推演。拿一张草稿纸，画一个表格，每一轮每一列写清楚数组的状态，推上十组数据，比看十遍代码都管用。第二，把冒泡和选择的代码默写到肌肉记忆。考试时间紧张，没有时间让你慢慢回忆循环边界，必须做到提笔就写、写完就对。第三，整理自己的错题本。每次做错的排序题，记下错误原因和正确解法，考前翻一遍，避免重复踩坑。第四，上机操作时先写框架再填细节。先把外层循环、内层循环、条件判断的框架搭好，再往里填具体的变量和语句，这样不容易漏掉关键步骤。

排序题说到底就是一层窗户纸，捅破了就发现翻来覆去就那几个套路。把冒泡和选择的代码写熟、把中间状态推熟、把常见坑记住，这块分数基本就稳了。我在实际教学中发现，那些排序题拿满分的同学，不是智商比别人高，而是动手练得比别人多。你花两个小时把十组数据推一遍，比看一整天视频课都有效。