面向零基础学生的具身化排序教学法

1. 项目概述：一场面向编程初学者的真实排序教学现场

哈尔滨学院夏令营day2-1：“排序上”——这名字听起来平平无奇，但如果你在现场听过那节45分钟的课，就会明白它为什么在学生笔记里被反复圈出、标红、加感叹号。这不是PPT上“冒泡排序：O(n²)时间复杂度”的干瘪定义，而是老师把一摞打乱顺序的学号卡片拍在讲台上，让学生用最原始的手动方式重新排好队；是当有人提出“每次找最小值换到开头”时，全班突然安静三秒后爆发出“哦——原来选择排序是这么来的！”；是用Scratch拖拽积木块实现交换逻辑时，那个卡在“临时变量”环节、反复重试七次才成功的小姑娘最后举手说：“我懂了，不是数要动，是‘位置’在动。”

这个标题背后，是一套经过十年高校编程启蒙教学反复打磨的“具身化算法教学法”。它不教代码语法优先，而先建立动作直觉：比较、交换、移动、归位——这些物理动作与内存地址、数组索引、指针跳转之间，存在一条肉眼可见的映射通道。我参与过三届该夏令营的助教工作，亲眼见过零基础高中生用纸笔模拟归并排序的分治过程，画满整张A3纸后脱口而出：“原来‘拆’是递归，‘合’是双指针！”这种认知跃迁，远比背诵十遍时间复杂度公式来得扎实。

核心关键词“排序”在此处绝非抽象概念，而是可触摸、可协作、可纠错的具体任务。从冒泡排序中相邻元素的“推搡式”移动，到插入排序里新元素“插队”的生活类比，再到归并排序“分而治之”的团队协作隐喻——所有算法都被还原为人类解决现实秩序问题的本能策略。它面向的不是准备ACM竞赛的尖子生，而是第一次听说“数组”这个词、连for循环括号都常写错的初中升高中学生。因此，本篇内容将完全剥离竞赛向优化、工程级封装、性能压测等高阶内容，聚焦于：如何让一个从未写过代码的孩子，在两小时内亲手“造出”四种基础排序，并能指着自己画的流程图，向同伴解释清楚“为什么插入排序在小数据时比冒泡快”。

你不需要有编程经验，只需要带一支笔、一张纸、和一点对“把乱的东西理整齐”这件事的好奇心。接下来的内容，就是那天课堂的完整复刻——包括黑板上的粉笔痕迹、学生提问的典型误区、以及老师故意留下的三个“陷阱题”。

2. 教学设计底层逻辑：为什么必须从“手动模拟”开始？

2.1 算法教学的三大认知断层与破解路径

几乎所有初学者在接触排序算法时，都会遭遇三道隐形墙：

第一道墙叫“动作失联”。学生能背下冒泡排序的伪代码：

for i from 0 to n-2: for j from 0 to n-2-i: if a[j] > a[j+1]: swap(a[j], a[j+1])

但当被问及“第3轮外层循环时，内层j最多走到哪个索引？”，87%的学生会愣住。问题不在于记不住，而在于代码中的i、j、n-2-i这些符号，与他们脑中“正在发生什么”的画面完全脱节。就像教人骑自行车只讲齿轮传动比，却不让他摸车把。

第二道墙叫“交换幻觉”。学生普遍认为“swap”是一个原子操作，像魔法一样瞬间完成两个值的互换。他们无法想象内存中实际发生的三步：把a[j]暂存到临时空间→把a[j+1]写入a[j]→再把临时值写入a[j+1]。这种幻觉直接导致后续学习指针、引用、深浅拷贝时全线崩溃。

第三道墙叫“分治恐惧”。面对归并排序的递归调用，学生第一反应是“函数调自己？那岂不是无限套娃？”他们缺乏对“调用栈”这一抽象容器的具象感知，更无法理解“拆到不能再拆”与“合到不能再合”之间的对称美感。

我们的破解方案，就是用物理世界强行焊接这三道断层：

• 动作失联 → 手动模拟：发给学生9张写有随机数字（如37, 12, 89, 5, 66, 23, 41, 74, 9）的卡片，要求两人一组，仅用“比较两张卡片大小”和“交换两张卡片位置”两个指令，完成排序。过程中禁止使用纸笔记录，必须靠大脑记住当前状态。当学生因记错中间结果而卡住时，老师立刻引入“索引标记”——用胶带在桌面贴出0~8九个位置编号，把抽象索引变成可触摸的物理坐标。

• 交换幻觉 → 三格纸板实验：给每组发一块硬纸板，划出左、中、右三个格子，分别标为“左值”、“临时”、“右值”。操作规则极其严苛：① 每次只能移动一张卡片；② 卡片离格必须有去处（不能悬空）；③ “临时”格永远只能存一张卡。当学生试图直接把右值塞进左格导致卡片掉落时，他们瞬间理解了“为什么需要第三个容器”。

• 分治恐惧 → 折纸分治法：发一张印有9个数字的长条纸，要求学生用折痕把它分成尽可能相等的两半。第一次折出4|5，第二次对左边4个再折（2|2），右边5个折成2|3……直到每段只剩1个数字。此时展开纸张，所有折痕构成一棵二叉树。老师指着树根问：“这棵树的叶子节点，对应的是什么？”学生答：“单个数字。”再问：“从叶子回到树根的路上，你在做什么？”学生恍然：“把两堆已经排好的小纸条，按顺序拼成一大条！”

这三步不是教学技巧，而是认知脚手架。它把计算机科学中最核心的抽象——状态、内存、递归——锚定在人类进化百万年形成的具身经验上：手的移动、空间的划分、序列的拼接。没有这层锚定，后续所有代码实现都是空中楼阁。

2.2 四种排序的选型逻辑：为什么是冒泡、选择、插入、归并？

夏令营刻意避开快速排序、堆排序等更“高效”的算法，原因非常务实：

• 冒泡排序：它是唯一一个完全符合人类直觉的排序。我们从小排队就习惯“相邻比较，谁大谁往后挪”，比如体育课按身高站队，老师喊“相邻同学比身高，高的站后面”，这就是天然的冒泡过程。它的低效性反而成为绝佳的教学杠杆——当学生手动模拟完9个数的冒泡，累得直喘气时，老师问：“如果让你重新排一次，有没有更省力的办法？”自然引出选择排序。

• 选择排序：作为冒泡的“暴力升级版”，它用“全局扫描找最小”替代“相邻推搡”，直观展示了“减少比较次数”的朴素优化思想。更重要的是，它的交换次数恒为n-1次（对n个元素），而冒泡最坏情况要交换O(n²)次。当学生用计数器统计两种算法的手动交换次数时，“选择排序更稳”这个结论无需解释。

• 插入排序：这是唯一一个与真实生活强关联的算法。“整理扑克牌”“图书馆上架新书”“按学号收作业”——所有这些场景，本质都是插入排序。我们不会把整摞作业本打乱重排，而是拿到一本新作业，从第一本开始逐个比较，找到合适位置插入。这种“增量式构建有序序列”的思维，是理解后续动态规划、在线算法的关键伏笔。

• 归并排序：它代表分治思想的首次完整亮相。之所以不选快排，是因为快排的“基准选择”和“分区操作”对初学者过于随机和抽象；而归并的“严格二分”和“有序合并”步骤清晰可数。更关键的是，归并排序的合并过程，完美复刻了人类协作场景：两组人各自把半堆杂乱的乐高零件按颜色排好，然后由第三人拿着两列已排序零件，同时从头开始比对，把更小的颜色块依次放入新盒子——这个“双指针合并”动作，学生看一遍就能模仿。

这四种算法构成一个认知梯度：从纯直觉（冒泡）→ 到主动优化（选择）→ 再到生活映射（插入）→ 最终抵达抽象范式（归并）。任何删减或替换，都会破坏这个精心设计的认知流。

2.3 时间分配的残酷真相：45分钟里，代码只占最后7分钟

很多人误以为编程夏令营就是敲代码，但真实课堂的时间分配令人惊讶：

• 前15分钟：手动模拟（占比33%）
  学生用卡片完成冒泡、选择、插入三种排序，每种限时3分钟。老师不干预操作，只记录各组完成时间和错误类型。这个阶段的目标不是“做对”，而是暴露认知盲区——比如有组在插入排序时，把新元素插到末尾而非中间，暴露了对“有序序列”概念的理解偏差。

• 中间18分钟：流程图共建（占比40%）
  全班围坐，老师用白板带领绘制三种算法的流程图。关键动作是“学生主笔，老师追问”。例如画冒泡流程图时，学生画出“比较a[j]和a[j+1]”，老师立刻问：“比较完之后呢？只有大于才交换吗？等于怎么办？”引导学生补全所有分支。这个过程产生的不是标准答案，而是集体认知共识。

• 最后12分钟：代码实现与验证（占比27%）
  此时才打开电脑。语言固定为Python（语法最接近自然语言），IDE限定为Thonny（专为教学设计，变量监视窗实时显示数组变化）。代码量严格控制：冒泡/选择/插入各15行以内，归并排序主函数+merge函数共30行。重点不是写全，而是调试——老师故意提供含一处bug的模板（如冒泡内层循环写成range(n)而非range(n-1-i)），让学生通过观察Thonny的变量监视窗定位错误。

这种分配比例揭示了一个反常识事实：对初学者而言，算法理解的深度，与代码行数成反比。当学生能徒手画出归并排序的递归树，并指着某一层说“这里两个子数组都已有序，所以合并时只需线性扫描”，他写出的10行代码，比死记硬背100行快排模板更有价值。

3. 核心教学环节详解：从卡片到代码的四步转化

3.1 冒泡排序：用“推搡游戏”建立循环嵌套直觉

手动模拟阶段，我们给每组发9张卡片（数字：37, 12, 89, 5, 66, 23, 41, 74, 9），要求按升序排列。规则只有一条：“每次只能比较相邻两张卡片，若左边大于右边，则交换位置。”

学生通常会这样操作：

• 第1轮：37↔12 → [12,37,89,5,66,23,41,74,9]
  37↔89（不换）→ [12,37,89,5,66,23,41,74,9]
  89↔5 → [12,37,5,89,66,23,41,74,9]
  ……持续到末尾，最大数89“冒泡”到最右。

此时老师暂停，提问：“这一轮，你们比较了多少次？交换了多少次？”学生数出8次比较，3次交换。接着问：“如果现在把89拿走，剩下8个数，下一轮要比较几次？”学生犹豫后答：“7次。”老师立刻在黑板写下：

第1轮：比较8次 → 最大值到位 第2轮：比较7次 → 次大值到位 第3轮：比较6次 → ……

自然导出外层循环次数：n-1轮，内层比较次数逐轮减1。

真正的教学爆点出现在“优化点破”环节。当学生完成全部9轮后，老师展示一个已部分有序的序列：[12, 5, 23, 37, 41, 66, 74, 89, 9]。问：“如果还按老方法跑9轮，最后一轮会发生什么？”学生模拟后发现：第8轮只比较了一次（74↔89），没交换；第9轮根本不用比——因为最大值已在末尾。此时引入“提前终止”概念：设置swapped = False标志，若某轮无交换，立即退出。这个优化不是为了性能，而是让学生理解“算法可以感知自身状态”，这是计算思维的萌芽。

代码实现时，Thonny的变量监视窗成为神助攻。当运行到内层循环j=0时，监视窗实时显示a[0]=12, a[1]=5；执行swap后，立刻变为a[0]=5, a[1]=12。学生亲眼看到内存地址里的值如何被搬运，彻底击碎“交换是魔法”的幻觉。

提示：手动模拟时，务必要求学生大声报出每次比较的索引和值，如“比较索引0和1：37和12，37大，交换！”。声音反馈强化了“索引-值”的绑定关系，这是后续理解数组下标越界的基石。

3.2 选择排序：用“选班长”类比破解“全局扫描”难点

选择排序的手动模拟，我们改用角色扮演：“现在要从9位候选人中选出班长、副班长、学习委员……共9个职位，规则是：每轮从剩余候选人中选出能力值最低者，任命为当前最高空缺职位。”

学生立刻进入状态：

• 第1轮：扫视全部9人，找出能力值5者，任命为班长（放位置0）
• 第2轮：扫视剩下8人（排除5），找出12者，任命为副班长（放位置1）
• ……直到第9轮，只剩一人，直接任命为最后职位。

这个类比精准击中选择排序的本质：它不关心局部秩序，只追求全局最优的逐次落实。当学生意识到“第k轮只决定第k个位置的值，且此后该位置永不改动”时，他们对“选择排序交换次数固定”就不再困惑。

流程图共建时，一个关键分歧点爆发：有学生坚持“找最小值后，应该把它和第一个位置交换”，另一组认为“应该和当前位置交换”。老师不评判，而是让他们用卡片实操两种方案。结果发现：前者需额外记录“当前起始位置”，后者则自然形成“已排序区/未排序区”的边界感。最终全班共识采用后者，并在流程图中用虚线明确划分两个区域。

代码实现时，我们刻意对比冒泡与选择的交换位置：

# 冒泡：总在相邻位置交换 if a[j] > a[j+1]: a[j], a[j+1] = a[j+1], a[j] # 选择：总在当前位置与最小值位置交换 min_idx = i for j in range(i+1, n): if a[j] < a[min_idx]: min_idx = j a[i], a[min_idx] = a[min_idx], a[i] # 关键：i是当前轮起点

学生通过Thonny单步调试，看到i如何从0递增到n-2，而min_idx在未排序区内跳跃，直观理解“外层i定义范围，内层j搜索范围”的嵌套逻辑。

注意：避免过早引入“哨兵”或“边界检查”。对初学者，range(i+1, n)比range(i, n)更安全，因为i+1明确表达了“从下一个开始找”，杜绝了j=i导致的自比较bug。

3.3 插入排序：用“扑克牌整理”打通增量构建思维

插入排序的手动模拟道具换成一副扑克牌（去掉大小王，用A=1, J=11, Q=12, K=13）。规则：“每次从牌堆抽一张，插入到手中已排好序的牌列中，使其仍保持升序。”

学生操作时暴露出经典误区：

• 误区1：抽出新牌后，直接插到末尾（如手中[3,7,9]，抽到5，插成[3,7,9,5]）
• 误区2：从左往右逐个比对，找到位置后，把右边所有牌整体右移（动作笨拙）
• 误区3：移动牌时，把已排序部分弄乱

老师不纠正，而是提问：“如果你是图书馆管理员，新到一批按ISBN排序的书，你会把整排书搬开再插一本吗？还是从右往左，腾出一个空位？”学生立刻领悟：插入排序的精髓是“腾位”而非“搬山”。

于是引入“空位法”：手中持[3,7,9]，抽到5。先在9位置腾出空位→7移到9位→3移到7位→空位留给5。这个动作完美对应代码中的key = a[j]和a[k+1] = a[k]。

流程图共建时，我们用不同颜色区分“已排序区”（绿色）和“待插入元素”（红色）。关键转折点是：当学生画出“比较a[j-1]与key”时，老师追问：“如果a[j-1] > key，下一步做什么？”学生答：“把a[j-1]移到a[j]”。再问：“那a[j-1]原来的位置，现在是什么？”学生思考后：“空的！”——这就是j不断递减的物理意义：在已排序区中，为key寻找并制造一个空位。

代码实现中，while j > 0 and a[j-1] > key:这一行是理解难点。Thonny调试时，我们暂停在j=3，监视窗显示a[2]=9, a[3]=5，学生看到a[2]>key成立，执行a[3]=a[2]后，a[3]变为9，而a[2]仍是9（未变）——这引发疑问：“a[2]没变，怎么腾出空位？”老师演示：下一轮j=2，比较a[1]=7与key=5，成立，执行a[2]=a[1]，此时a[2]变为7，a[1]仍是7……最终j=0时，a[0]被赋值为key。学生顿悟：空位是通过连续覆盖“制造”出来的，不是预先存在的。

3.4 归并排序：用“折纸分治”可视化递归与合并

归并排序是全场认知负荷最高的环节，我们拆解为两个独立实验：

实验一：折纸分治（20分钟）
发一张长18cm、印有9个数字（37,12,89,5,66,23,41,74,9）的纸条。要求：

1. 用折痕把纸条分成两半（允许不等分，但必须是整数个数字）→ 得到[37,12,89,5] | [66,23,41,74,9]
2. 对左半继续折：[37,12] | [89,5]
3. 对右半继续折：[66,23,41] | [74,9]
4. 直到每段只剩1个数字

展开纸条，所有折痕构成一棵树。老师标注：叶子节点=单个数字（已“有序”），内部节点=合并操作。此时提问：“如果现在要把[37,12]和[89,5]这两段已排序的纸条合并成一段，你怎么操作？”学生自然回答：“两边各拿一张，比大小，小的放进新纸条，再拿一张……”

实验二：双指针合并（15分钟）
发两列卡片：左列[12,37,5,89]（已按升序排好），右列[9,23,41,66,74]（已按升序排好）。要求用最少动作合并为一列升序。

学生尝试后发现最优策略：

• 左指针i=0（指向12），右指针j=0（指向9）
• 比较12>9 → 取9，j++
• 比较12<23 → 取12，i++
• 比较37>23 → 取23，j++
• ……直到某列取完，把另一列剩余全取

这个过程被实时画在黑板上，箭头清晰标出i、j的移动轨迹。学生看到“双指针”不是抽象概念，而是两个真实的手指在两列卡片上同步滑动。

代码实现时，我们把merge函数拆成三部分：

def merge(left, right): result = [] i = j = 0 # 主合并循环：两边都有元素 while i < len(left) and j < len(right): if left[i] <= right[j]: result.append(left[i]) i += 1 else: result.append(right[j]) j += 1 # 处理剩余：只有一边有元素 result.extend(left[i:]) result.extend(right[j:]) return result

Thonny调试时，重点观察i和j如何在while循环中交替递增，以及extend如何处理边界。当left=[12,37],right=[9,23]时，学生看到i=2, j=2后，left[i:]为空列表，right[j:]也为空，result=[9,12,23,37]——递归的“合”在此刻具象化。

实操心得：归并排序教学最大的坑，是学生把“分”和“合”割裂。必须强调：分的过程不产生有序序列，合的过程才真正排序。我们要求学生在折纸时，每折一次就问：“这段纸上的数字现在有序吗？”答案永远是否定的，直到最后合并完成。

4. 常见问题与现场排错实录：那些被粉笔灰掩盖的真相

4.1 手动模拟阶段的高频Bug与教学对策

在三年夏令营中，我们系统记录了学生手动模拟时的137次典型错误，按出现频率排序前五名如下：

这些Bug不是学生的失败，而是教学设计的路标。比如第1条，促使我们开发了“磁吸进度条”教具；第3条，催生了“左手key右手移”的肢体记忆训练。每一次现场纠错，都是对认知模型的一次校准。

4.2 代码实现阶段的致命陷阱与避坑指南

当学生终于坐到电脑前，Thonny界面亮起，新的挑战开始。以下是近三年收集的、导致超70%学生卡壳的5个代码陷阱：

陷阱1：冒泡排序的内层循环边界错误
典型错误代码：

for i in range(n): # 应为 range(n-1) for j in range(n): # 应为 range(n-1-i) if a[j] > a[j+1]: # j+1可能越界！ a[j], a[j+1] = a[j+1], a[j]

排错实录：学生运行时报IndexError: list index out of range。老师不直接指出，而是问：“当j等于多少时，j+1会超出列表？”学生算出j=n-1时j+1=n，而列表最大索引是n-1。再问：“内层循环j最大应该到几？”学生答n-2。老师顺势写出range(n-1)，并强调：“range(k)生成0到k-1，所以要让j最大为n-2，k必须是n-1。”

陷阱2：选择排序的最小值索引初始化错误
典型错误：

min_idx = 0 # 错！应为 i for j in range(i+1, n): if a[j] < a[min_idx]: min_idx = j a[i], a[min_idx] = a[min_idx], a[i]

排错实录：学生发现排序后数组错乱。Thonny调试显示，min_idx始终指向索引0，导致所有轮次都把最小值换到位置0。老师演示：当i=2时，未排序区是a[2:]，min_idx必须在a[2:]中找，所以初始值应为i而非0。

陷阱3：插入排序的while循环条件顺序颠倒
典型错误：

while a[j-1] > key and j > 0: # 错！应为 j > 0 and a[j-1] > key

排错实录：学生运行时报IndexError。老师解释：Python中and短路求值，若先判断a[j-1] > key，当j=0时j-1=-1，a[-1]访问最后一个元素，不报错但逻辑错误；而正确顺序下，j>0为假时，a[j-1]根本不会被计算。这是理解逻辑运算符执行顺序的绝佳案例。

陷阱4：归并排序的递归基条件遗漏
典型错误：

def merge_sort(a): if len(a) == 1: # 错！应为 <=1 return a mid = len(a)//2 left = merge_sort(a[:mid]) right = merge_sort(a[mid:]) return merge(left, right)

排错实录：学生输入空列表[]，程序无限递归崩溃。老师问：“空列表长度是0，len(a)==1为假，函数会继续切分，a[:0]和a[0:]都返回[]，陷入死循环。”补上<=1后，学生看到[]直接返回，理解了递归必须有“触底反弹”的基例。

陷阱5：所有算法中，修改原列表 vs 返回新列表的混淆
典型混乱：

# 冒泡排序函数返回None，但学生期望返回排序后列表 def bubble_sort(a): 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] # 忘记 return a # 调用时：sorted_a = bubble_sort(a) → sorted_a is None!

排错实录：学生打印sorted_a显示None，困惑不已。老师对比list.sort()（原地修改，返回None）和sorted()（返回新列表）的文档，强调：“Python中，改变原对象的方法通常返回None，这是设计哲学，不是bug。”并给出统一建议：教学阶段，所有排序函数都显式return a，避免初学者陷入返回值迷思。

4.3 学生提问TOP5与深度回应

在夏令营Q&A环节，以下5个问题出现频率最高，其背后是深刻的认知冲突：

Q1：“为什么归并排序要分两半，不能分三半或更多？”
回应：分三半理论上可行，但合并时需三指针比较，逻辑复杂度陡增。而二分后合并只需双指针，且“二”在计算机中具有天然优势（位运算、内存对齐）。更重要的是，分治的优雅在于对称性——二分是最小的、能体现“分-合”对称的单元。分三半破坏了这种对称，就像三角形稳定但不如正方形易铺满平面。

Q2：“插入排序看起来最慢，为什么还要学？”
回应：速度不是唯一维度。插入排序的适应性（adaptive）是核心价值：当输入近乎有序时，它接近O(n)；而冒泡即使优化也需O(n²)。更关键的是，它是理解“在线算法”的入口——你能一边接收新数据，一边动态维护有序序列，这是数据库索引、实时推荐系统的底层逻辑。

Q3：“选择排序交换次数少，是不是最省内存？”
回应：交换次数少 ≠ 内存占用少。所有这四种算法都是原地排序（in-place），额外空间复杂度O(1)。选择排序的优势是写操作少，这对闪存设备（如SSD）寿命有实际意义——因为闪存的擦写次数有限，减少写操作能延长硬件寿命。这连接了算法理论与硬件物理。

Q4：“冒泡排序真的没用吗？我听说Linux内核还在用？”
回应：Linux内核确实在极少数场景（如早期启动阶段的简单链表排序）用冒泡，原因恰恰是它的极端简单性：代码短、无递归、无额外内存分配、边界条件极少。在内存紧张、编译器不可靠的嵌入式环境，简单性就是鲁棒性。这打破了“高效=好”的迷思。

Q5：“学这些排序，以后写业务代码会用到吗？”
回应：直接手写排序的概率趋近于零——现代语言库的sort函数已高度优化。但排序思维无处不在：Excel按IP地址排序，本质是字符串的字典序比较；MySQL的ORDER BY，背后是B+树索引的遍历顺序；Tableau的图表排序，依赖前端JavaScript的localeCompare()；甚至你给微信好友列表设“最近联系人”排序，也是基于时间戳的插入排序变体。学排序，是学一种“秩序构建”的元能力。

5. 教学延伸与真实世界映射：当排序走出课堂

5.1 从课堂卡片到生产环境：排序需求的演进光谱

夏令营的9张卡片排序，看似简单，实则是整个数字世界秩序构建的微缩模型。我们带学生做了三次“尺度跃迁”练习，感受同一原理在不同层级的变形：

跃迁1：从数字到字符串——IP地址排序
给学生一组IP地址：["192.168.1.10", "10.0.0.1", "172.16.0.5", "192.168.1.2"]。问：“按字符串排序，结果是什么？”学生得出["10.0.0.1", "172.16.0.5", "192.168.1.10", "192.168.1.2"]，发现"192.168.1.10"排在"192.168.1.2"前面——因为字符串比较是逐字符，'1'<'2'，所以"10"<'2'。这引出**自然排序（natural sort）**概念：真实世界中，我们期望"image2.jpg"排在"image10.jpg"之前，而非之后。解决方案是提取数字片段并数值比较，这正是归并排序中“自定义比较函数”的典型应用。

跃迁2：从单维到多维——学生成绩综合排序
数据表含姓名、语文、数学、英语成绩。要求：先按总分降序，总分相同时按数学降序，数学再相同时按姓名升序。学生立刻意识到：