秀云南"27王道课后代码题2.2.3（二、1~9）"这个编号，估计每个刷王道的考研人都不会陌生。它就是王道数据结构第二章线性表配套课后习题里，顺序表这一小节最后那道综合应用题的1到9小题。别小看这九道题，顺序表这个章节几乎所有能考的核心算法，都被这九道题给串起来了：按值删、区间删、去重、合并、换位、折半查找加插入、循环移位，每一道都是408真题和各大自命题院校反复改编的素材来源。
这九道题我做了一遍又一遍，每次刷都会有新收获。今天不整虚的，直接按题号把这些题的核心思路、标准代码、复杂度和容易踩的坑全部分享出来，给正在啃这块硬骨头的同学一份能直接照做的参考。不管你是刚开始复习的零基础选手，还是已经进入强化阶段想回头查漏补缺的人，这篇内容都能帮你在顺序表算法这块少走点弯路。
1. 题目整体定位与命题规律分析
1.1 这9道题在考纲中的位置与价值
先把这个编号拆开说清楚。王道数据结构每一章末尾都有题库，2.2.3对应的就是第二章线性表中"顺序表的定义、插入删除、查找"这个知识点群组的课后习题。题目编号里的"二、1~9"，指的就是第二部分综合应用题里的前九道代码题。
为什么这九道题地位这么高？因为408考试大纲对线性表的要求，集中体现在"顺序表上的查找、插入、删除、逆置、归并"这几个操作上，而这九道题恰好把顺序表的典型操作考了个遍。更重要的是，这几年408真题里的大题，明显有从王道课后题改编的习惯。比如2010年那道著名的"数组循环左移"，几乎就是这九道题里最后一题的换皮版；2023年的顺序表删除区间元素，也是把题目3和题目4换个说法而已。
所以这九道题不是做一遍就扔的普通练习题，而是应该反复揣摩、能默写标准答案的"母题"。我在复习时给自己定的标准是：拿到任意一道题，能不看答案说出算法思想、能写出完整代码、能讲清时间空间复杂度，这三样缺一不可。
1.2 题目之间的逻辑链条：从删除到重排，难度层层递进
很多人做这九道题的感觉是"东一榔头西一棒子"，做完就忘。实际上，这九道题的编排顺序是有内在逻辑的，按操作类型可以分成两大组。
第一组是删除类，对应题目1到5。从删除最小元素，到删除所有值为x的元素，再到删除区间[s,t]的元素（有序表和无序表各来一遍），最后是有序表去重。这一组练的是同一种核心能力：在连续存储结构上，如何用最少的移动次数完成删除，同时保持表内元素相对位置不变。
第二组是重排与查找插入类，对应题目6到9。先是两个有序表归并，然后是把一个数组中前后两段顺序表互换，再是在有序表中折半查找并插入，最后是数组循环左移。这一组练的是"逆置思想"和"折半查找"这两个进阶工具，它们共同的特点是都能把时间复杂度控制在O(n)甚至O(log n)。
这两组题从简单到复杂，从"裸考"删除操作到综合运用查找、移动、逆置、归并，恰好对应了从基础到强化、从模仿到设计的完整训练路径。把这条逻辑链捋顺了，刷题时就不会再觉得是一团散沙。
需要模型API调用？ 免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。
2. 顺序表删除类题目：最小元素、区间删除、有序去重（题1~5）
2.1 第1、2题：删除最小元素与按值删除
第一道题是经典的送分题：从顺序表中删除具有最小值的元素（假设唯一），由函数返回被删元素的值，空出的位置由最后一个元素填补。
一句话思路：先遍历一遍找到最小值和它的下标，然后用最后一个元素把它盖掉，表长减一。这里有个小前提，题目说了"空出的位置由最后一个元素填补"，这个条件给了我们很大的优化空间——不需要把最小值后面的所有元素都往前移，一次覆盖就搞定了。
c复制bool Del_Min(SqList &L, ElemType &value) {
if (L.length == 0)
return false; // 表空不能删除
value = L.data[0];
int pos = 0; // 记录最小元素下标
for (int i = 1; i < L.length; i++) {
if (L.data[i] < value) {
value = L.data[i];
pos = i;
}
}
L.data[pos] = L.data[L.length - 1]; // 最后一个元素填补
L.length--;
return true;
}
这段代码有三个容易出错的地方：一是忘记判断空表，空表时直接访问L.data[0]就非法了；二是value和pos的同步更新，只记其中一个都会出问题；三是最后那步覆盖操作，有人会写反成L.data[L.length - 1] = L.data[pos]，那就彻底错了。复杂度方面，一趟遍历，时间O(n)，空间O(1)，这是删除类算法的最低配。
第二道题升级了一点：删除顺序表中所有值等于x的元素，要求时间O(n)、空间O(1)。这道题就不能用"找一个删一个"的朴素思路了，因为每次删除都要移动大量元素，最坏会到O(n^2)。正确姿势是用保留法，也叫覆盖法：维护一个指针k，指向当前保留区的末尾，遍历整个表，遇到不等于x的元素就放到保留区，最后把length更新为k。
c复制void Del_All_X(SqList &L, ElemType x) {
int k = 0;
for (int i = 0; i < L.length; i++) {
if (L.data[i] != x) {
L.data[k++] = L.data[i];
}
}
L.length = k;
}
这个写法非常优雅，一趟遍历就把所有等于x的元素"过滤"掉了。理解它的关键是：k的增长速度一定小于等于i的增长速度，所以后面的赋值不会覆盖掉还没处理的数据。我在做题时就是把k当作"新表的写入位置"，i当作"旧表的读取位置"，一读一写，互不干扰。
2.2 第3、4题：有序/无序顺序表的区间删除
第三题是删除有序顺序表中值在给定区间[s, t]（s < t）之间的所有元素。这道题的核心在于利用"有序"这个性质：值在[s, t]区间的元素一定是连续的一段。
这么说吧，你在一排从小到大排列的整数里删掉落在某个区间的数，这些被删的数必然是挤在一起的一整段。所以算法可以这样做：先找到第一个大于等于s的元素位置i，再从i开始找到第一个大于t的元素位置j，那么i到j-1这一段就是我们要删除的。之后把j及其后面的所有元素整体往前搬到i开头的区域，表长更新为长度减去(j - i)。
c复制bool Del_S_T(SqList &L, ElemType s, ElemType t) {
if (s >= t || L.length == 0)
return false;
int i, j;
// 找第一个大于等于s的元素下标
for (i = 0; i < L.length && L.data[i] < s; i++);
if (i == L.length) // 所有元素都小于s，没有可删的
return false;
// 找第一个大于t的元素下标
for (j = i; j < L.length && L.data[j] <= t; j++);
// 从j开始往前搬
for (; j < L.length; i++, j++)
L.data[i] = L.data[j];
L.length = i;
return true;
}
这里有个细节，去掉覆盖后的表长应该是i，因为i恰好是"搬完后有效元素的个数"。做这道题时我最开始栽过一回，增删元素后忘了更新length，结果调试半天发现"删了但又好像没删"，其实就是length还停留在旧值。
第四题是不要求有序，直接删除顺序表中值在区间[s, t]之间的所有元素。有序的版本是靠"区间连续"来定位的，无序的版本就没这个便宜可占，得老老实实把每个元素都看一眼。代码跟第二题几乎一个模子，只是把判断条件从"等于x不删"改成"在区间内不删"。
c复制bool Del_S_T2(SqList &L, ElemType s, ElemType t) {
if (s >= t || L.length == 0)
return false;
int k = 0;
for (int i = 0; i < L.length; i++) {
if (L.data[i] < s || L.data[i] > t) {
L.data[k++] = L.data[i];
}
}
L.length = k;
return true;
}
第四题和第三题的对比特别有意思：同一个需求，有序表和无序表的解法完全不同。有序表的关键是区间连续，所以要先定位再批量搬移；无序表则每个元素都要判断一次。两者的时间都是O(n)，但因为有序表定位后只用做一次连续搬移，实际执行时的移动次数会更少。
2.3 第5题：有序顺序表去重
第五题要求从有序顺序表中删除所有值重复的元素，使表中所有元素值均不同。比如原表是1, 2, 2, 3, 3, 3, 5，删除后变成1, 2, 3, 5。
因为表是有序的，重复元素一定连续排列，所以可以沿用前面的保留法，只是这次"保留"的判断标准不是某个固定值，而是"跟上一个已保留的元素不同"。
c复制bool Delete_Same(SqList &L) {
if (L.length == 0)
return false;
int k = 0; // k指向当前最后一个保留元素
for (int i = 1; i < L.length; i++) {
if (L.data[i] != L.data[k]) {
L.data[++k] = L.data[i]; // 发现新元素，放到保留区
}
}
L.length = k + 1;
return true;
}
这段代码最妙的地方是L.data[k]永远指向"已保留区段的最后一个元素"，i在遍历时跟它比就行。注意是先++k再赋值，因为k当前的位置已经被占用了，要先把写入指针往后挪一格。最后length不是k而是k + 1，我见过好几个同学写成L.length = k，结果每次删除完表长都少一个。
这道题还能延伸出一个问题：如果表是无序的，怎么去重？那一般就得借助辅助空间（比如哈希表）来记录了，时间复杂度没变，空间复杂度会升到O(n)。这也是"有序性"带来的优势，在答题时如果题目没有明确说有序，千万别默认有序，那是两个完全不同的问题。
2.4 删除类题目的易错点与现场避坑记录
在把这五道题刷完两遍之后，我把删除类的共同易错点整理成了一份清单，按出现频率排列：
第一，忘了更新表长。不管是覆盖删还是保留法，L.length一定要同步改。王道书上所有代码都以更新length结尾，这就是在提醒你：这是顺序表和数组的本质区别之一，数组没有"长度"这个概念，顺序表有。
第二，空表判断。除了第二题无返回值可以不判（其实最好也判），其余绝大多数题目都要先判断length是否为零，再看s >= t这种输入合理性。别小看这一步，408阅卷时函数返回值的正确性也是得分点。
第三，覆盖顺序颠倒。删除类的"保留法"都是把后面的值赋给前面的位置，也就是L.data[k++] = L.data[i]，反过来写就把数据改坏了。
第四，循环越界。第三题的第一个循环结束后要检查i是不是已经到表尾，如果已经到表尾还继续往下搬，就会出现数组越界访问。
还有一条应试经验：做题时如果时间紧张，这类删除题可以直接套我上面这个"遍历+保留指针k+末尾更新length"的模板，九成以上的删除变体都能用它解决。模板本身不需要背，理解一次就能记住，它的本质就是用一个变量标记"新表的写入位置"，跟快慢指针是一回事。
3. 顺序表重排与查找类题目：合并、双逆置、折半插入、循环左移（题6~9）
3.1 第6题：两个有序顺序表合并的归并思想
第六题把难度往上提了一个台阶：将两个有序顺序表合并成一个新的有序顺序表，由函数返回结果。
这道题是归并排序的雏形，核心思想是"谁小谁先进"：用两个指针分别指向两个表的表头，每轮比较当前元素，把小的那个放入新表，对应指针后移；当某一个表遍历完，把另一个表的剩余元素全部接到新表后面。
c复制bool Merge(SqList A, SqList B, SqList &C) {
if (A.length + B.length > C.MaxSize)
return false; // 新表空间不够
int i = 0, j = 0, k = 0;
while (i < A.length && j < B.length) {
if (A.data[i] <= B.data[j])
C.data[k++] = A.data[i++];
else
C.data[k++] = B.data[j++];
}
while (i < A.length) // A还有剩余
C.data[k++] = A.data[i++];
while (j < B.length) // B还有剩余
C.data[k++] = B.data[j++];
C.length = k;
return true;
}
这道题需要注意的点有三处。一是等号的处理，我写的是A.data[i] <= B.data[j]，这样A中元素会先进入新表，保证算法的稳定性（虽然本题不要求）；二是空间判断，C作为新表，MaxSize必须足够大，很多同学漏掉这个判断直接越界，在考场上这种低级错误很致命；三是合并完成后C.length = k这一步，跟前面删除类一样，表长的维护永远是最后一道工序。
时间复杂度O(A.length + B.length)，空间O(1)（额外空间），这是归并操作的基本盘。如果将来复习归并排序时再回头看这道题，你会觉得像老朋友重逢一样亲切。
3.2 第7题：双逆置实现数组内两个顺序表位置互换
第七题是逆置思想的第一次亮相：已知在一维数组A[m + n]中依次存放两个线性表(a1, ..., am)和(b1, ..., bn)，编写一个函数，把这两个顺序表的位置互换，也就是变成(b1, ..., bn, a1, ..., am)。
我第一次做这道题时，第一反应是申请一个临时数组把一段先拷出来，但那样空间复杂度就是O(n)了。王道的标准解法非常漂亮，只做了三次逆置，空间O(1)就搞定了。
具体做法是：先对数组的0到m+n-1整个范围做一次逆置，此时数组变成了(bn, ..., b1, am, ..., a1)；然后把前n个元素（现在存的是bn到b1）逆置成b1到bn；再把后面m个元素（am到a1）逆置成a1到am。三次逆置之后，数组恰好变成(b1, ..., bn, a1, ..., am)。
c复制void Reverse(int A[], int left, int right) {
// 逆置A[left..right]
for (int i = left, j = right; i < j; i++, j--) {
int temp = A[i];
A[i] = A[j];
A[j] = temp;
}
}
void Exchange(int A[], int m, int n) {
Reverse(A, 0, m + n - 1); // 整体逆置
Reverse(A, 0, n - 1); // 逆置前n个
Reverse(A, n, m + n - 1); // 逆置后m个
}
理解这个方案的关键在于"逆置的逆置等于还原"：某个区间被逆置两次后恢复原序。整体逆置把两段都颠倒了顺序，再把每段各自逆置回来，就相当于让两段在数组里互换了位置。这个思想特别重要，因为第八题、第九题全都要用到它。
3.3 第8题：递增有序表折半查找与插入
第八题是个"复合题"：线性表(a1, a2, ..., an)中的元素递增有序且按顺序存储，设计一个算法，用最少的时间在表中查找数值为x的元素。若找到，则将其与后继元素位置相交换；若找不到，则将其插入表中，并使表中元素仍递增有序。
看到"递增有序"和"最少时间"，第一反应就应该是折半查找，时间复杂度O(log n)。直接从头到尾线性扫的话，虽然也能过，但显然没有利用有序性，不是最优解，在考场上会被扣分的。
c复制void SearchExchangeInsert(int A[], int n, int x) {
int low = 0, high = n - 1, mid;
while (low <= high) {
mid = (low + high) / 2;
if (A[mid] == x)
break;
else if (A[mid] < x)
low = mid + 1;
else
high = mid - 1;
}
if (low <= high) { // 找到了
if (mid + 1 < n) { // 不是最后一个元素才能交换
int temp = A[mid];
A[mid] = A[mid + 1];
A[mid + 1] = temp;
}
} else {
// 没找到，插入位置是low
for (int i = n - 1; i > high; i--)
A[i + 1] = A[i];
A[high + 1] = x;
}
}
这里最关键的细节是判定"找到"的标准。折半查找结束有两种可能：一是low > high退出循环，说明没找到；二是break退出，说明找到了。所以用low <= high来判断当前是哪种情况。但要注意，如果是找到后break退出，low和high的关系可能是low <= high的任意一种，mid就是元素下标。
如果没找到，插入位置一定是low。因为此时low = high + 1，可以说插入位置是low，也可以说是high + 1。后面搬移元素必须从最后一个元素开始从后往前搬，如果从前往后搬，前面的元素会把后面的还没搬的元素覆盖掉，顺序就乱了。
这道题还有个隐含要求容易被忽略：数组A要有足够的空间容纳插入后的新元素。实际做题时王道的默认条件是空间够，不需要额外判断。如果要在函数的代码里体现这一点，可以把函数设计成传入引用型的n并在返回时更新表长，这个细节面试或笔试时是一个很好的加分点。
3.4 第9题：循环左移的"三次逆置法"及其等价变形
第九题是这九道题里的压轴题，也是最应该反复琢磨的一道：设将n个整数存放到一维数组R中，设计一个在时间和空间两方面都尽可能高效的算法，将R中保存的序列循环左移p（0 < p < n）个位置，即将R中的(X0, ..., Xn-1)变换为(Xp, ..., Xn-1, X0, ..., Xp-1)。
这道题的历史地位非常高，因为2010年408统考的算法大题几乎就是它的原题。题面里明确写了"时间空间两方面都尽可能高效"，这就是在暗示你要做到时间O(n)、空间O(1)，而不是用一个辅助数组生生复制。
解法依然是逆置法，跟第七题是同胞兄弟。循环左移p位等价于三步：
c复制void LeftShift(int R[], int n, int p) {
if (p > 0 && p < n) {
Reverse(R, 0, p - 1); // 逆置前p个
Reverse(R, p, n - 1); // 逆置后n-p个
Reverse(R, 0, n - 1); // 整体逆置
}
}
推导一下：一个序列X0, X1, ..., Xp-1, Xp, ..., Xn-1，先逆置前p个，变成Xp-1, ..., X0；再逆置后n-p个，变成Xn-1, ..., Xp；此时整个数组是Xp-1, ..., X0, Xn-1, ..., Xp，看起来好像更乱了；但紧接着整体逆置，正好把每一段二次逆置，变成Xp, ..., Xn-1, X0, ..., Xp-1，恰好是左移p位的结果。
还要注意p是对n取模的。题目要求0 < p < n，如果题面改成p可能大于n，就先做p = p % n，因为循环左移p位和左移p mod n位效果一样。另外如果想让代码支持循环右移q位，等价于左移n - q位，或者做"先整体逆置，再逆置前q个，再逆置后n-q个"的三次逆置，逻辑对称，但别记混。
最后提一下复杂度：三次逆置，每次都是O(n)级别，合起来O(n)；逆置只用了一个临时变量，空间O(1)。这就是标准答案要求的"时间空间尽可能高效"。
4. 复盘：算法设计思维与考场答题规范
4.1 从这九道题中提炼的通用解题范式
九道题刷完不能白刷，一定要回头总结共性。我复盘下来，发现顺序表算法题其实就四板斧。
第一板斧是保留法/覆盖法，用于各种删除场景。无论是按值删、按区间删、去重，还是更复杂的"删除所有奇数"之类的变体，统一思路都是维护一个保留区的写入指针k，遍历原表，符合"保留条件"的写进保留区，最后更新表长。第二题、第四题、第五题都是这个模板。
第二板斧是逆置法，用于各种换位和循环移位。第七题和第九题都是整体逆置加局部逆置的组合。只要题目出现"互换两段位置""循环左移""循环右移"这些关键词，优先想逆置，因为它空间O(1)的特性在考场上极其珍贵。
第三板斧是折半查找，用于有序表上的快速定位。有序表的查找插入题，时间要求往往很紧，O(log n)的折半是最优选择。它跟普通查找的差距在n很大的时候非常明显，考场上遇到"递增有序"四个字，脑子里第一反应就应该响起折半的警报。
第四板斧是归并，用于有序表合并。归并排序的前置技能点，写法固定：三个while循环，前两个互相比较，后两个处理剩余。掌握了这个模板，后面刷归并排序、合并K个有序链表之类的题目都会轻松很多。
4.2 王道代码题的考场答题模板
关于王道课后代码题怎么写才能在考场上拿高分，我有几点心得。
答题结构上，建议先写算法思想注释，再写代码，最后写复杂度分析。这道题所用的数据结构、核心思路、关键步骤，用两三行注释写清楚，方便阅卷老师快速定位给分点，也方便自己理清思路。
函数签名设计要注意匹配题目要求。题目说"函数返回被删元素的值"，就要用引用参数把值带出来，比如bool Del_Min(SqList &L, ElemType &value)；题目说"由函数返回结果顺序表"，就用引用参数传C表。顺序表的修改类操作，参数一律要用&引用，不然在函数里改的是副本，外面一点变化都没有。
入门级的错误是最可惜的：不写L.length--、不写C.length = k、函数返回值类型跟实际return对不上。这属于基础规范问题，平时刷题就要养成习惯，别等到考场上才想着"这次应该没事吧"。
4.3 常见问题与排查技巧实录
复习群里经常有人贴出代码说"运行结果不对又找不出原因"，我根据自己踩过的坑整理了一份顺序表代码题的快速排查清单：
第一个高频问题是表长没更新。表现是"删了元素但打印出来还在"，或者"合并结果表比预期长"。排查方法很简单：去看函数结束前有没有正确的length操作。删除类一般是L.length = k或L.length--，合并类是C.length = k。
第二个高频问题是边界条件写错。以第八题为例，如果没判断mid + 1 < n就执行交换，当x就是表中最后一个元素时，程序会把A[mid + 1]越界访问。区间删除题更容易中招，s和t的合法性、区间到底包不包含端点（是s <= x <= t还是s <= x < t），这些细节读题时就要确定清楚。
第三个问题是写循环时把i和j搞混。比如第三题搬移元素时误把i写成j，最后length也写错。遇到这种问题我有个笨办法：找一组小数据，比如A = {1, 2, 3, 4, 5}，自己拿纸笔画一遍，每一步画出现在数组长什么样，哪个位置被覆盖了，立刻就能发现问题。
第四个问题是函数传参忘加引用。这个错误编译器通常不会报错，程序也能运行，但结果就是"函数执行完，主函数里啥都没变"。调试时看到这种诡异的情况，先检查一下形参是不是传值而不是传引用。
还有一条调试技巧想多说一句：写顺序表代码题时，可以在关键位置加打印语句，比如删除前后分别打印整个表和length。等程序跑通了再把打印删掉。这种调试方式虽然原始，但对找边界错误特别管用，好过对着屏幕干瞪眼。
5. 一点关于刷题节奏的题外话
这九道题刷完之后，最好做一个后续动作：把每题改成"链表版本"再做一遍。王道教材在顺序表习题之后紧接着就是链表的相似题目，比如删除链表中的重复元素、合并两个有序链表、链表逆置等，你会发现思路几乎是平移的，只是访问方式从"下标"变成了"指针"。这种对比练习对建立起"不同存储结构影响算法设计"这一核心观念特别有帮助。
我个人做题的顺序习惯是第一遍不参考任何答案，自己硬写，写不出来就翻书看那一道题的思路，然后合上书重新写。第二遍重点做标记，把第一次写错的题目标出来。到第三遍就只做标记过的题，逐题默写完整代码。这个方法看起来很笨，但对我而言比直接抄答案有效得多。这九道题我前前后后写了好多遍，每写一遍都会有新的理解：一开始只是背模板，后来慢慢理解了为什么保留法要这么写，为什么三次逆置能达到换位效果。这些理解，才是刷王道课后题最值钱的东西。