董云舟1. 从牌桌上的直觉说起：为什么入门排序先讲插入排序
今天聊排序。排序算法是计算机科学里最基础的一类问题，也是每个学算法的人绕不开的第一道坎。带集训这几天，我见过不少新手一上来就啃快排、归并，结果被递归和分治折腾得晕头转向，连基础的时间复杂度分析都没弄明白。其实，入门排序有一套更合理的顺序，插入排序就是我通常选择的第一个正式排序算法。
为什么是插入排序？因为它和人的直觉天然贴合。你想想打扑克牌的时候，摸到一张新牌，你会怎么处理？从右往左看手里已经排好序的牌，找到比它小的那张，然后插到那张牌后面。这就是插入排序的核心思想——把新元素插入到已经有序的序列中正确的位置。这个过程不需要什么高深的数据结构知识，也不涉及递归思想，只需要一次单层循环嵌套一次循环，就能把问题讲清楚。
这一篇我们就把插入排序讲透，包括最朴素的直接插入排序、基于查找优化的折半插入排序，以及我实际写代码时踩过的坑和长期积累的性能直觉。内容会偏实操一些，覆盖到时间复杂度推导、稳定性分析、边界条件处理，以及插入排序在真实工程场景中的定位。
不管你是正在准备面试的求职者、刚接触数据结构的本科生，还是工作中想补一补算法基础的后端开发，这篇文章应该都能给你提供一些用得上东西。建议你准备好编辑器，跟着代码敲一遍，再自己做几个小实验，比单纯读完文字效果好得多。
需要模型API调用？ 免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。
2. 直接插入排序：最朴素的实现与完整的复杂度推演
2.1 三句话讲清楚算法流程
直接插入排序的思路极其简单，就三步：
- 从第二个元素开始，逐个拿出来，称为“当前待插入元素”。
- 在已排序的序列中，从后往前扫描，找到第一个比当前元素小的位置。
- 把当前元素插到这个位置后面，之前的所有元素整体后移一位。
为什么要从第二个元素开始？因为第一个元素天然是长度为1的有序序列，不需要处理。每次插入一个元素，有序序列长度加1，当最后一个元素被插入后，整个数组就有序了。
我用一个具体例子推演一遍。假设数组是 [5, 2, 4, 6, 1, 3]：
- 第一轮，处理
a[1]=2，已排序部分只有[5]，2比5小，所以2插入到5前面，数组变成[2, 5, 4, 6, 1, 3]。 - 第二轮，处理
a[2]=4，已排序部分是[2, 5]，4比5小但比2大，插入到2和5之间，数组变成[2, 4, 5, 6, 1, 3]。 - 第三轮，处理
a[3]=6，6已经是最大的，不需要移动，数组不变[2, 4, 5, 6, 1, 3]。 - 第四轮，处理
a[4]=1，1是当前最小的，一路挪到最前面，数组变成[1, 2, 4, 5, 6, 3]。 - 第五轮，处理
a[5]=3，3插入到2和4之间，最终得到[1, 2, 3, 4, 5, 6]。
注意第四轮这里，1要一路穿过5个元素，后面5次移动全部发生。这个过程中你就能直观感受到：插入排序的性能高度依赖数据初始状态的有序程度。
2.2 最稳定的实现：C语言版直接插入排序
理论再清楚，落地到代码才是最关键的。这是我最常用的一个实现版本，直接看代码：
c复制void insertion_sort(int arr[], int n) {
for (int i = 1; i < n; i++) {
int key = arr[i];
int j = i - 1;
while (j >= 0 && arr[j] > key) {
arr[j + 1] = arr[j];
j--;
}
arr[j + 1] = key;
}
}
代码只有几行，但每一行的位置都有讲究。key 必须先保存下来，因为后续后移元素会覆盖 arr[i] 原本的值，如果不提前保存，数据就丢了。j 从 i-1 开始，表示从已排序部分的最后一个元素往前查。while 循环条件 arr[j] > key 是关键——它是严格大于，不是大于等于，这个细节直接决定了排序的稳定性，后面我会专门展开讲。
循环结束后，j 指向的位置是第一个比 key 小的元素，所以插入位置是 j + 1。为什么？因为循环退出的原因有两种：要么 j 走到了 -1，说明 key 比已排序部分所有元素都小，插入位置是数组头部；要么 arr[j] 小于等于 key，此时 key 应该插在 arr[j] 后面。这两种情况统一用 arr[j + 1] = key 都正确。
我见过不少初学者在这个位置纠结，甚至有人会把插入位置记成 arr[j]，一旦记错，整个排序结果就是错的。一个不容易忘记忆的技巧：while 里最后一次移动把元素挪到了 arr[j+1]，那么等循环结束，空出来的那个位置也一定是 arr[j+1]，在这里赋值准没错。
如果你用的是 Python，对应实现是这个样子：
python复制def insertion_sort(arr):
for i in range(1, len(arr)):
key = arr[i]
j = i - 1
while j >= 0 and arr[j] > key:
arr[j + 1] = arr[j]
j -= 1
arr[j + 1] = key
逻辑完全一致。while 循环体里的三步——比较、后移、下标递减，就是插入排序的“最内层节奏”。后面讲复杂度的时候你会发现，整个算法的性能瓶颈就藏在这个循环里。
2.3 时间复杂度推导：为什么最坏情况是 O(n^2)
这段是重点，也是新手最容易囫囵吞枣的地方。我们分三种情况来推时间复杂度：
最好情况：数据已经有序。
每一轮只需要做一次比较，发现 arr[j] <= key，循环立刻结束，不需要任何移动。外层循环执行 n-1 次，总比较次数约为 n-1，总移动次数为 0。因此最好情况时间复杂度是 O(n)。
这就解释了为什么插入排序对“近乎有序”的数据表现极好。举个例子，比如一个几十万条记录的日志数组，只有少数几条顺序不对，插入排序能在极短时间内整理完，而快速排序在这种场景下反而可能因为递归和分区开销显得笨重。
最坏情况：数据完全逆序。
每一轮，key 都要跟已排序部分的所有元素比较一遍，然后全部往后移动。第一轮比较1次，第二轮比较2次，……，第 n-1 轮比较 n-1 次，总比较次数是 1 + 2 + ... + (n-1) = n(n-1)/2。移动次数同样是这个量级。因此最坏情况时间复杂度是 O(n^2)。
更直观一点：对一个长度为 10000 的逆序数组，插入排序大约要执行 5000 万次比较和移动操作。这个数字在单核 CPU 上大约需要几十毫秒到一两百毫秒，看起来还行？那换成 100 万呢？那就是 5000 亿次操作，时间直接飙升到几十秒，完全不可接受。
平均情况：数据随机排列。
平均情况下，每一轮里 key 大约需要比较并移动已排序部分的一半元素，所以总操作数也是 n²/4 这个量级，时间复杂度依然是 O(n^2)。
综合来看：直接插入排序的时间复杂度是 O(n²)，最好 O(n)，最坏 O(n²)。这个结论的意义在于，它清楚地告诉我们在什么场景下使用插入排序是明智的，什么场景下是在浪费时间。
2.4 稳定性分析：为什么 > 而不是 >=
判断一个排序算法是否稳定，核心看一点：值相等的元素在排序前后的相对顺序是否保持不变。
插入排序的 while 条件是 arr[j] > key，只有当已排序元素严格大于待插入元素时才后移。如果 arr[j] == key，循环直接停止，key 被插入到这些相等元素的后面。也就是说，后出现的相等元素，永远排在先出现的相等元素后面，相对顺序得到保持，因此插入排序是稳定的。
你可能会问：稳定性有什么用？实际场景中很常见。比如你有一个表格先按“时间”排好序，现在想按“用户ID”排序，同时保留时间维度的先后顺序，那你就需要一个稳定排序。如果用的是不稳定的排序算法，第一次排序的顺序就被破坏了。这就是为什么大量语言内置排序（比如 Python 的 sort、C++ 的 stable_sort）都刻意保证稳定性。
如果把条件写成 arr[j] >= key，相等元素就会被后移，后出现的元素被插到前面，相对顺序翻转，排序就变不稳定了。这个细节值得每次写插入排序时都下意识检查一遍。
3. 折半插入排序：用二分查找干掉一半的比较
3.1 一个合理的性能瓶颈反思
仔细看直接插入排序的整个过程，每个新元素都要在“已排序部分”里搜索插入位置，然后移动元素。这个搜索过程是线性查找——从后往前一个一个比。但问题来了：已排序部分本身是有序的，对于一个有序序列的查找，我们明明有更高效的手段，那就是二分查找，能把比较次数从 O(n) 降到 O(logn)。
这就是折半插入排序的出发点。思路没有任何玄机：先用二分查找找到待插入位置的索引，再统一移动元素，最后插入。
这里有个地方需要提醒初学者：二分查找优化的是“查找位置”这一步，但元素的后移操作依然要一个一个搬。所以折半插入排序的时间复杂度仍然是 O(n²)。它真正的收益是减少了比较次数，从原来的 O(n²) 降到了 O(nlogn) 级别，但移动次数没变，依然是 O(n²)。
3.2 折半查找和插入位置怎么对接
折半插入排序的难点不在二分查找本身，而在于二分查找结束后，left 和 right 指针到底指向哪里，插入位置到底是什么。这里的边界处理比直接插入排序复杂得多。
我先给结论：使用标准二分模板，当 left > right 时，插入位置就是 left。我见过很多人在这一步被绕晕，就干脆用 low <= high 的模板来保证最终位置正确。具体看代码。
3.3 代码实现与边界位置的深层解释
c复制void binary_insertion_sort(int arr[], int n) {
for (int i = 1; i < n; i++) {
int key = arr[i];
int left = 0, right = i - 1;
while (left <= right) {
int mid = left + (right - left) / 2;
if (arr[mid] <= key) {
left = mid + 1;
} else {
right = mid - 1;
}
}
// 此时 left 就是 key 的插入位置
for (int j = i - 1; j >= left; j--) {
arr[j + 1] = arr[j];
}
arr[left] = key;
}
}
这里面最关键的是二分查找部分。为什么是 arr[mid] <= key 时往右走？因为我们要找的是“第一个大于 key 的位置”。当 arr[mid] <= key 时，说明 mid 及其左边所有元素都小于等于 key，插入位置一定在 mid 右边，所以 left = mid + 1。反之 arr[mid] > key，插入位置可能在 mid 或 mid 左边，我们让 right = mid - 1，继续缩小范围。
循环结束后，left 指向的位置就是“第一个大于 key 的元素所在位置”，也是 key 该插入的位置。所有等于 key 的元素都在它前面，所以这个算法也是稳定的。当有多个相同元素时，新元素会被插入到已有相同元素的后面，相对顺序不变。
用一个小例子验证边界：数组 [1, 3, 5, 7]，待插入 key=4：
left=0, right=3, mid=1，arr[1]=3 <= 4，left=2left=2, right=3, mid=2，arr[2]=5 > 4，right=1- 循环结束，
left=2，确实应该插在3和5之间。
再看 key=0：中间无论怎么二分，最终 left 会走到0，插入到数组头部。再看 key=9：最终 left 会走到4，插入到数组末尾。三个边界情况都验证无误。
3.4 折半插入排序到底提升了什么
把直接插入排序和折半插入排序放一起对比，有个很有意思的分析角度：
| 指标 | 直接插入排序 | 折半插入排序 |
|---|---|---|
| 比较次数（平均） | O(n²) | O(nlogn) |
| 移动次数（平均） | O(n²) | O(n²) |
| 最好情况 | O(n) | O(nlogn) |
| 稳定性 | 稳定 | 稳定 |
| 额外空间 | O(1) | O(1) |
从这个表就能看出，折半插入优化的是比较开销，不是移动开销。在比较操作成本高的场景下（比如数组中存放的是大结构体、字符串，每次比较都代价昂贵），折半插入排序可以带来明显的性能提升。
但要注意，绝大多数情况下，移动操作的成本并不比比较便宜——尤其当元素是结构体时，移动同样需要拷贝一整块内存。所以如果把性能期待放在“O(n²) 变成 O(nlogn)”这个层面，那就理解错了，折半插入排序不是用来突破平方级瓶颈的。
4. 工程向优化：哨兵、交换策略与局部性原理
4.1 哨兵位优化：把边界判断从循环里抽出去
插入排序最内层循环有两个判断条件：j >= 0 和 arr[j] > key。在大量数据的排序中，j >= 0 这个边界判断每次都执行，会带来性能损耗。一个经典优化手段是“哨兵位”。
思路是这样的：既然我们每轮都会把 key 插入到 arr[0] 或更后面的位置，那为什么不直接把 arr[0] 当作哨兵，用它来充当循环终止的标志？这样内层循环就只需要判断 arr[j] > key 一个条件了。
具体做法：每一轮插入前，先把 key 存到 arr[0] 位置，然后在循环里不断移动元素，直到遇到一个不大于 key 的元素，由于 arr[0] = key，循环一定会在 j=0 时停住，不会越界。这样省掉了 j >= 0 的判断。
c复制void insertion_sort_sentinel(int arr[], int n) {
for (int i = 2; i < n; i++) {
int key = arr[i];
arr[0] = key;
int j = i - 1;
while (arr[j] > key) {
arr[j + 1] = arr[j];
j--;
}
arr[j + 1] = key;
}
}
注意这里下标从2开始，因为 arr[0] 被用作哨兵位，不参与实际数据存储。这种写法的代价是：需要额外一个数组位置，或者要求原始数组预留一个空位。在嵌入式或高性能场景中，这种少一个判断的优化是有意义的。但日常工作中，代码可读性往往更重要，我个人建议先写标准版，确实遇到性能瓶颈再考虑这一层优化。
4.2 用交换代替移动？一个不划算的买卖
有些教程实现插入排序用的是交换操作，代码长这样：
c复制void insertion_sort_swap(int arr[], int n) {
for (int i = 1; i < n; i++) {
for (int j = i; j > 0 && arr[j] < arr[j - 1]; j--) {
swap(&arr[j], &arr[j - 1]);
}
}
}
这个版本更简洁，对于教学理解“把元素往前冒泡”的过程很有帮助，但它做的是交换而不是移动。一次交换等于三次赋值，而标准插入排序的后移是一次赋值。也就是说，交换版在最坏情况下的赋值操作次数是标准版的三倍。数组长度大了之后，这个差距会放大。
所以我的建议很明确：只为了学习逻辑可以用交换版，实际写代码建议用标准的“保存key + 后移”版。
4.3 缓存局部性：插入排序在小数组上能打过快排？
聊一个我特别想分享的工程观察。很多人误以为插入排序只有一个缺点：慢。但实际上，它在处理“小规模数据”时，效率并不输给快速排序，很多时候甚至更快。
原因之一是缓存局部性。插入排序的元素访问模式非常整齐：待插入元素固定存在寄存器/栈上，后续操作是一个连续的后移过程——挨个把相邻元素往后搬。这种访问模式对CPU缓存非常友好，数据都在附近的内存区域里，缓存命中率高。而快速排序是跳跃式访问数组，在数组很大时会造成较多次缓存未命中，代价比理论比较次数显示的更大。
另外一个原因是常数因子小。插入排序的循环体非常简单，每次迭代只有一次比较、一次赋值、一次自减。而快排的循环体要处理分区逻辑，常数因子大得多。当 n 很小（比如小于 50）时，O(n²) 的优势和劣势都被 n 的数值压平了，这时候常数因子成了主导变量。插入排序胜出。
这一点在高级排序算法实现中直接应用了：很多工业级的快排实现，会在递归到小数组（比如长度小于16或32）时，切换成插入排序完成剩下的排序。比如 C++ STL 里的 sort 就用到了这种“混合策略”。这就是插入排序在现代工程中最真实的地位。
5. 现场实录：常见问题与排查技巧
5.1 死循环：j 的更新和循环条件写拧了
我见过最多的错误是下面这种写法：
c复制while (j >= 0 && arr[j] > key) {
arr[j + 1] = arr[j];
// 忘了 j--;
}
一旦 j 不更新，循环永远在同一位置打转，形成死循环。排查方式很简单：在循环体里临时加一条打印语句，输出每一轮的 j 和 arr[j]，基本一眼就能看出问题。如果数据量比较大，可以在本地用很小的数组（长度 5）测试，打印每一轮完整数组，观察变化。这种低级错误谁都会犯，不需要紧张，但养成“写完排序立刻拿小数组跑一遍”的习惯，能省下不少调试时间。
5.2 边界错位：arr[j+1] 写成 arr[j]
这是另一个很常见的错误。后移过程应该把 arr[j] 搬到 j+1 的位置，但方向搞反就成了往左搬，数据顺序直接乱掉。更隐蔽的错误是把插入位置写成 arr[j]，而不是 arr[j+1]，这样每次都会覆盖掉一个原本不该覆盖的元素，排序结果一片混乱。
排查这类问题的一个有效技巧：从最小规模 n=2 开始测，两个元素的数组如果都排不对，那一定是逻辑层面的问题。逐步加大规模，观察哪一轮开始出错，定位到具体的插入位置上，问题通常就清楚了。
5.3 折半边界：left 和 right 的最终含义
折半插入排序里最容易卡住的就是边界。建议背下这个结论：while (left <= right) 的循环结束后，left 就是插入位置。不需要再纠结 right 指向哪里。如果你改成 while (left < right)，代码也能跑，但插入位置可能是 left 或 left+1，需要额外判断，更容易出错。为了可读性和正确性，建议统一使用 <= 模板。
我做一个补充验证给你看：假设有数组 [2, 4, 6]，插入 key=4（重复值）：
left=0, right=2, mid=1，arr[1]=4 <= 4，left=2left=2, right=2, mid=2，arr[2]=6 > 4，right=1- 循环结束，
left=2，插入到arr[2]，也就是原数组中4的后面、6的前面。
相等元素的相对顺序没有被打乱，排序稳定，边界也正确。
5.4 数据规模意识：别用插入排序处理 10 万级逆序数据
我见过有人把插入排序当成万能钥匙，不管数据多大直接扔进去跑，结果200万条逆序数据跑了十几秒。这不怪算法，是选型问题。插入排序适合的是小规模数据、或者大规模但近乎有序的数据。
如果你真的要处理大规模逆序数据，至少得切换到归并排序或快速排序。一个简单的经验判断标准：数组长度小于 50，或者数据已经基本有序（逆序对很少）时，插入排序是优秀的选择；否则，别浪费时间，直接上 O(nlogn) 的算法。
6. 我自己踩过的一些坑，以及推荐的学习路径
很多年前我第一次写插入排序，把 key 保存这件事忘了，直接用 arr[i] 参与比较，结果后移操作把待插入值覆盖了，整个排序结果乱七八糟。从那以后我养成了一个习惯：所有涉及元素移动的算法，先确认“被覆盖的值是否已经被保存”，再动循环。这个习惯对后续学习希尔排序、堆排序同样受益。
还有一次我在折半插入排序时，把二分条件写成了 arr[mid] < key，导致相等元素的插入位置跑到了已有相等元素的前面，排序结果不稳定。当时排查了很久才意识到问题出在一个符号上。这个教训让我意识到，稳定性的保证不是理所当然的，而是代码里每个细节共同作用的结果。
如果你想系统地把插入排序彻底吃透，我建议按这个顺序推进：
- 先不看任何资料，自己用扑克牌手动模拟一遍插入排序，感知“取牌、找位置、移动、插入”这个过程。
- 手写直接插入排序，分别用数组长度为 0、1、2、5、10 的边界用例验证正确性。
- 对比标准版和交换版本的赋值次数差异，写一个小计数器，实测 1000 个逆序元素的运行时间，你会发现差距是肉眼可见的。
- 改成折半插入排序，多造几组重复数据的用例，重点验证排序稳定性。
- 如果你还有精力，可以继续学希尔排序——它其实就是“分组的插入排序”，理解了插入排序，希尔排序的核心思路就通了一半。
排序算法这件事，看起来简单，但真正写好、写稳、还能根据场景选对算法，需要积累的基础比想象中多得多。插入排序作为第一课，值得花一天时间敲透。第05天的内容到这里就差不多了，下一篇我们会继续沿着排序这条线往下走，先预告一下：下一站是希尔排序，也就是插入排序的“升级版”，它的跳跃式分组思想会给你带来新的启发。