企业官网建设流程全解析

简介：面向数据结构初学者的顺序表核心操作通关资源，对应头歌平台“数据结构-顺序表的基本操作”第1至第6关。内容覆盖顺序表六种基本操作：插入、删除、按序号查找、按值查找、逆置与两个有序顺序表的合并。每关均提供完整可运行的C++代码与实现解析，例如在插入操作中讲解元素后移与合法位置校验，在删除操作中演示覆盖式前移，在有序表合并中运用双指针逐次挑选较小元素，重点阐明数组下标与表长变化等易错细节。资源包为1个docx文档，大小仅54KB，文件内容排版清晰，可直接复制运行，适合正在刷头歌实验、预习考研数据结构或准备期末上机的学生对照学习。目前已有16045人学习浏览，足以体现该资源对通关头歌作业的参考价值，循序渐进阅读即可顺利通过全部关卡并加深对顺序表底层逻辑的理解。

1. 头歌数据结构顺序表基本操作这 6 关，为什么看着简单却总在细节上翻车

如果你正在做头歌平台的数据结构实训，大概率会被顺序表的基本操作这 6 关卡住一段时间。每一关的代码量都不大，核心操作也就是初始化、查找、插入、删除这几件，但平台判定严格，循环边界差一个下标、判满判空的顺序写反、输出格式多了个空格，都可能让你在某一关反复提交。这个实训本质上是在锻炼你写“正确且规范”的顺序表代码，而不是仅仅“能跑”。我们能从这 6 关里学到的东西，其实比想象中多得多。

这篇笔记我不打算给你贴一份“标准答案”了事，而是把顺序表用 C 语言在头歌平台上的实现思路、每一关的考察点和常见丢分点一起梳理清楚。内容适合正在刷头歌实训的学生，也适合期末复习顺序表这章想快速找回手感的人。你会发现，只要把底层逻辑理清了，不管平台怎么换关卡，你都能很快写完通过。

2. 顺序表为什么是数据结构第一课：存储结构与接口设计的取舍

2.1 顺序表和数组不是一回事，头歌考的是“抽象”

很多人上手顺序表时觉得它就是个数组，写代码也确实用数组实现，但这个认知会害你在后面的关节上吃亏。数组是 C 语言层面的连续内存块，顺序表是在数组之上封装出来的一种线性表存储结构：它要求元素逻辑上相邻，物理存储上也相邻，并且通过一个变量记录当前有效元素个数，这个变量通常叫 length。长度和容量必须分开理解——容量（maxSize）是数组最多能放多少元素，长度（length）是当前实际放了几个。

头歌平台这 6 关的判定，会检查你是否正确使用了这些字段。比如判空是判断 length == 0 而不是判断数组某个位置是否为 0，判满则是 length == maxSize。这些细节理解不到位，后面的插入和删除几乎必错。

2.2 为什么不直接用数组，要绕一层结构体

用结构体包一层数组和长度字段，最大的价值在于接口统一。比如你写一个插入函数listInsert(SeqList *L, int pos, int elem)，调用方只需关心“在第几个位置插什么值”，不用知道内部是数组还是链表。这个抽象思想是数据结构课程的核心，头歌的顺序表实训就是在逼你把这个封装做对。

在选型上，顺序表适合“读多写少”或“元素规模预知”的场景，比如存储每天的股票收盘价、课程成绩表。它的优势是按下标访问是 O(1) 时间，缺点是插入和删除要移动大量元素，平均 O(n)。如果实训里告诉你元素最大个数不会超过某个值，用顺序表就是最合适的方案。

2.3 头歌实训的 6 关到底在考什么，先看整体地图

打开头歌平台这个实训，你会看到实训详情里把顺序表的基本操作拆成了若干个编程关卡。由于各学校配置的关卡名称可能略有差异，但根据最常见的实验模板，这 6 关的考察对象大致如下：

看懂这张地图你就能明白，每一关都不是孤立的。第 4 关插入写错，大概率是因为你会默认第 5 关的删除也要用同样方向的移动，从而把覆盖顺序搞反。我们在中间章节会逐关展开，不遗漏细节。

3. 从结构体定义到六大操作：顺序表核心代码逐个拆解

3.1 结构体定义与初始化：第一步决定后面所有关卡

在头歌的代码编辑器里，你通常会在头文件区域看到结构体定义，或者需要自己补全。最经典的定义方式如下：

#define MAXSIZE 100 typedef struct { int data[MAXSIZE]; // 存放元素的数组 int length; // 当前元素个数 } SeqList; // 初始化:把顺序表清空 void initList(SeqList *L) { L->length = 0; // 只需要把长度置 0 // data 数组不需要手动清 0，因为 length 已经规定了有效范围 }

这段代码的逻辑说明：initList只有一个赋值动作，就是把length设为 0。有人会问为什么不把data里每个元素都置 0，这里的要点是，顺序表的有效性由 length 界定，length 为 0 就表示没有任何元素，哪怕数组里残留着上次的数值也不影响读取。参数上，传入的是指向SeqList的指针，因为在 C 语言里结构体传值不会修改原变量，必须用指针才能让初始化生效。

3.2 遍历与输出：最容易忽视的输出格式要求

在第 2 关里，你通常需要把顺序表的每个元素打印出来。头歌平台对输出格式的判定比较严格，有的题目要求元素之间用空格分隔、末尾无多余空格，有的要求每行输出所有元素后换行。典型的实现如下：

void printList(SeqList *L) { if (L->length == 0) { return; // 空表不需要输出 } for (int i = 0; i < L->length; i++) { if (i > 0) { printf(" "); // 只在元素之间加空格，末尾没有 } printf("%d", L->data[i]); } printf("\n"); }

这里的逻辑核心是循环从 0 到L->length - 1，而不是到MAXSIZE - 1。用if (i > 0)来控制空格是应对“末尾不能有空格”这类判定的常见做法。如果你发现本地运行结果和平台期望一样，但提交就是格式错误，把每个printf的格式字符串逐一检查，特别是\n有没有多打、少打。

3.3 按值查找与按位查找：返回值的“潜规则”决定成败

第 3 关通常是按值查找：给你一个目标值，返回它第一次出现的下标，如果没找到就返回一个约定好的值。头歌的实验模板一般约定返回 -1，因为顺序表的下标从 0 开始，-1 不会和有效位置冲突。

// 按值查找，返回第一个匹配元素的下标，找不到返回 -1 int locateElem(SeqList *L, int target) { for (int i = 0; i < L->length; i++) { if (L->data[i] == target) { return i; } } return -1; }

这段代码的注意点是遍历时用的是< L->length而不是<= L->length，因为数组最后一个有效下标是 length - 1。很多人在这个地方写错，导致越界访问。按位查找相对更直接，给定位置 pos，判断位置合法性后直接返回L->data[pos - 1]，不过部分关卡不会单独让你写按位查找，而是把它藏在删除或综合操作中。

3.4 插入操作：从后往前移动元素，顺序不能换

插入是顺序表操作里的重头戏，第 4 关的完整实现如下：

// 在 pos 位置插入元素 elem，pos 从 1 开始计 int listInsert(SeqList *L, int pos, int elem) { if (L->length == MAXSIZE) { return 0; // 表满，插入失败 } if (pos < 1 || pos > L->length + 1) { return 0; // 位置不合法 } // 从最后一个元素开始，依次往后移一位 for (int i = L->length; i >= pos; i--) { L->data[i] = L->data[i - 1]; } L->data[pos - 1] = elem; // 在目标位置放入新元素 L->length++; return 1; }

这段代码最关键的边界是插入位置允许等于length + 1，表示在表尾追加元素，此时循环体一次都不执行。移动方向必须从后往前：如果从前往后移动，后面的元素还没被移走就会被前面的覆盖，导致数据丢失。参数pos是从 1 开始计的人位序，而数组下标从 0 开始，所以data[pos - 1]就是真正的插入点。判满和判位置合法性的先后顺序也很重要，平台有时候会用满表插入来测试你。

3.5 删除操作：从前往后覆盖，注意返回被删元素

第 5 关删除和插入正好相反，核心逻辑是找到要删除的位置后，从它后面一个元素开始往前覆盖，最后 length 减一。

// 删除 pos 位置的元素，并把删除的值通过 out 返回 int listDelete(SeqList *L, int pos, int *out) { if (L->length == 0) { return 0; // 空表不能删 } if (pos < 1 || pos > L->length) { return 0; // 位置不合法 } *out = L->data[pos - 1]; // 先把被删元素带出去 for (int i = pos; i < L->length; i++) { L->data[i - 1] = L->data[i]; // 后面的元素往前覆盖 } L->length--; return 1; }

这里的循环从pos开始，到length - 1结束，对应下标关系是data[i - 1] = data[i]。要特别注意的是，删除和插入的移动方向完全不同，这正是一开始那张地图里提到的坑。删除最后一个元素时，循环体不执行，只让 length 减 1，逻辑上那个位置就变成无效区了。通过指针参数out把被删除元素返回给调用方，是数据结构实验里的常见要求，有些关卡如果没有这个参数，你也要保持一致。

3.6 综合操作：把函数串起来，顺序表才能成为完整工具

第 6 关往往是综合题，常见的形式是“读取一组数据创建顺序表，然后连续执行若干次插入和删除，每执行一次输出一次当前表”。这种题目不考查你是否能写出更新颖的算法，而是考查多个操作拼接后的正确性。

int main() { SeqList list; initList(&list); // 假设题目要求先添加 5 个元素 for (int i = 1; i <= 5; i++) { listInsert(&list, i, i * 10); } printList(&list); // 删除第 2 个元素 int removed = 0; listDelete(&list, 2, &removed); printList(&list); return 0; }

综合操作最容易犯的错误是在 main 里直接操作list.length或list.data，绕过了你写好的接口。这样一旦接口内部逻辑有问题，main 里的表现就会更加混乱，而且平台会判定你没有正确使用封装。建议在主流程里只调用函数，不要直接访问结构体字段。

4. 逐个攻关头歌实训 1-6 关：典型代码填空点与平台判定规则

4.1 第 1 关：初始化函数里只能改 length，别画蛇添足

第 1 关的代码填空区域通常只留了initList函数体，例如给你一个空函数的开头，让你补全。这道题目的陷阱在于，有人为了“确保干净”，写了一个循环把 data 数组全部置 0。这个操作本身不报错，但会影响平台对代码风格的判定，更严重的是，如果题目设置里 maxSize 特别大，每次初始化都要跑一遍循环，后面综合关卡里频繁初始化会拖慢运行。正确做法是只写L->length = 0;。

这一关还会有一个小的子任务，比如初始化后判断是否为空表，并输出结果。判断空表记住用L->length == 0，不要用data[0] == 0这种蠢办法，因为表为空时 data[0] 残留值根本不可信。

4.2 第 2 关：遍历输出的空格和换行是重点失分项

第 2 关会让你的初始化函数接收若干输入数据，构建一个顺序表，然后输出全部元素。平台判题通常不是肉眼比对，而是把你的输出和一个标准输出文件做逐字符比较。因此，空格数量、换行位置都算作错误。常见的模板要求是“元素之间用一个空格分开，行尾无多余空格”。

如果你在自己的编译器上测试时没有严格检查行尾，在平台就会莫名其妙地报格式错误。经验做法是写完输出函数后，用三组数据自测：

• 空表，看是否只输出了一个换行。
• 单元素表，看是否没有开头或结尾空格。
• 多元素表，看元素间是否只有一个空格。

4.3 第 3 关：按值查找的返回值约定是隐藏考点

平台第 3 关一般会要求你补全locateElem或类似命名的函数。有的题目会把返回值约定写成“返回元素在表中的位序，从 1 开始”，有些写成“返回下标，从 0 开始”，还有的约定找不到时返回 0。你需要在读题时看清它的约定，否则就算逻辑正确也可能一直不通过。这里的建议是先把函数内部注释读一遍，注释里通常会写明“若不存在则返回 -1”之类的话，按照注释约定来实现最稳妥。

在函数实现层面，注意遍历时不要越过 length。如果你写成i <= L->length，恰好要找的值在最后一个有效位置，访问下标就是 length，已经越界，读到了一个不确定的值，这在平台的多组数据测试下可能隐藏得很深。

4.4 第 4 关：插入操作的位置合法性和判满顺序

第 4 关代码填空时，判定条件的顺序会影响边界测试结果。比如你先判断位置不合法再判断表满，如果表满且位置也不合法，返回失败结果是一样的；但反过来先判满再判位置，逻辑也成立。真正值得警惕的是移动元素时写成了for (int i = pos; i <= L->length; i++)，这会让最后一个元素被复制到 length 位置，虽然 length + 1 位置没有越界（数组容量是 MAXSIZE），但插入到中间位置时，会错误地把原有最后一个元素再复制一份。调试技巧是，在插入函数入口临时加一个打印，输出插入前后的 length 和元素列表，便于在本地复现问题。

4.5 第 5 关：删除元素后要不要把残留位置清空

删除函数里，把被删位置腾出来后，原来最后一个元素仍然留在数组末尾，但由于 length 已经减一，逻辑上它不属于这个表了。头歌平台一般不会要求你把这个残留值清零，但有些评分点是基于内存检测的，虽然概率不高，但为了稳妥，你也可以在 length 减一后，将data[length] = 0，防止某些评测系统对未初始化内存敏感。

删除的另一个坑是位置参数合法性判断写反。比如写成pos < 0，那删除第 1 个元素（pos=1）可以正常走，但删除 pos=0 时，按你的判定是合法的，实际却访问了下标 -1，直接越界。务必记住人位序和数组下标的换算关系。

4.6 第 6 关：多步操作时记得每次操作后更新状态

综合关卡的典型框架是：读入初始数据 → 按指令插入/删除 → 每次操作后调用 printList 输出。你要确认的是，每次插入或删除后，printList 读取的 length 已经同步更新。如果插入函数里忘了L->length++，第一次打印可能碰巧正确，第二次打印就会少元素或者输出残留值。

另一个常见问题是 main 里重复初始化同一个顺序表变量，比如调了一次 initList 后，又在循环里重新 init。这个操作会清空之前的所有修改，导致操作序列产生意外结果。所以先把整体流程在草稿纸上画一遍，确定”初始化只做一次“，再动笔写代码。

5. 避坑实录：头歌顺序表实训中大家反复踩的 5 个坑

5.1 本地运行正确，提交后却显示“答案错误”

这个现象在头歌平台上非常常见，原因往往不是算法错了，而是输出格式和题目要求不一致。我见过很多次有人把printf("%d ", data[i])写成了每个元素后都带空格，自己测试时看到末尾空格不以为意，平台却严格比对。解决方法是，先把题目描述里“输出格式”部分认真读一遍，对照着调整 printf，然后自测时用cat -A或者十六进制查看输出文件，确认行尾没有多余空格。

5.2 插入元素后，原最后一个元素被替换而不是后移

如果你在插入时循环写成for (int i = pos - 1; i < L->length; i++)，也就是从前往后覆盖，那么插入点之后的元素会逐个被前一个覆盖，数据直接丢失。现象就是本地调试时发现最后一个元素变成了新插入的元素。解决方法是记住口诀：插入前移后，删除后移前——插入元素时从最后一个元素开始往后挪，删除元素时从被删位置的下一个开始往前挪。

5.3 判满或判空条件写反，导致插入删除都失效

如果总是在插入时报“表满”或者删除时报“空表”，基本是条件表达式弄反了。比如把判满写成了if (L->length == 0)，那插入第一个元素时就会直接拒绝。这一类错误靠肉眼很难发现，建议在插入函数里加上临时打印printf("length=%d maxSize=%d\n", L->length, MAXSIZE);，对比实际值就能一眼看出来。判断条件牢记：只有length == MAXSIZE才满，length == 0才空。

5.4 按值查找时把位序和下标混淆

有些题要求返回位序，有些要求返回下标，两者差一个 1。如果函数注释里明确“返回第几个位置”，那么你需要在找到元素后返回i + 1，而不是i。实战中，很多人这一关不过就是因为返回错了值。更稳妥的办法是，实现完函数后单独写一个测试片段，把某个已知元素传入，打印返回值，再和题目预期对照一下，对不上就立即换返回方式。

5.5 综合题里连续操作后，顺序表“多出”或“丢失”元素

这个问题的根源通常是插入函数里没有 length 自增，或者删除函数里没有 length 自减。自增和自减看似不起眼，却在连续操作时直接影响后续所有遍历和查找的结果。排查方法是在每个函数调用后打印一次 length，如果某次该加没加、该减没减，立刻定位到那个函数。头歌平台不会告诉你哪一步状态错了，所以本地逐步打印是最高效的排错手段。

6. 让代码在本地反复验证：边界测试与动态扩容升级

数据结构的实验，不应该只满足于“交上去通过”。头歌平台的测试用例数量有限，覆盖不到所有边界情况，但这恰恰是你提升的机会。我通常会在本地额外准备一组边界用例，把顺序表的每个操作压到极限去跑。

重点测试以下几个场景：空表插入到位置 1、满表继续插入、删除第一个元素、删除最后一个元素、按值查找空表、按值查找末尾元素。这些用例能暴露绝大多数逻辑漏洞。比如空表插入时位置合法性判断是否允许 pos=1，满表插入时是否返回失败且 length 不变。当你把这几组用例在本地全部跑通，再提交到平台上就会顺利很多。

如果你有余力，不妨把静态数组的顺序表升级为动态扩容版本。核心改动是把结构体里的int data[MAXSIZE]换成int *data，把判满逻辑改为扩容。常见做法是当 length 等于容量时，申请一个两倍大的新数组，把旧数据复制过去再释放旧空间。这个操作在 C 语言里用 realloc 就能实现，不需要手写复制。动态版本能让你理解”容量和长度是两回事”这句话的含金量，也方便你应付期末上机考试里那些不限制固定容量的题目。

#include <stdlib.h> typedef struct { int *data; int length; int maxSize; } SeqList; void expand(SeqList *L) { int newSize = L->maxSize * 2; int *newData = (int *)malloc(newSize * sizeof(int)); for (int i = 0; i < L->length; i++) { newData[i] = L->data[i]; } free(L->data); L->data = newData; L->maxSize = newSize; }

这个扩容代码要注意realloc和手动malloc + free两种方案的取舍。我一般选择手动方式，因为它在出错时更容易定位，而且不依赖realloc在某些编译器下的行为差异。动态扩容虽然头歌这 6 关里不一定用得到，但你能写出来，就说明对顺序表的内存模型真的理解了。我自己在初学数据结构时，也是把静态版本彻底吃透后才开始写动态版本，两者结合后，再去学链表就会顺手很多。希望这篇笔记能帮你少走弯路，顺利通过这 6 关。

本文还有配套的精品资源，点击获取