C语言单向链表教师信息管理系统：增删改查与内存排查实战

机房实训周，屏幕上摆着同一个题目：用单向链表做一个教师信息管理系统。我见过太多份这样的代码——功能菜单列得整整齐齐，一按删除就段错误；或者逻辑全塞在 main 里，八百行一条道走到黑；也有同学把链表硬生生写成了数组，节点全在栈上分配，看着是链表的模样，其实就是个顺序表。这个题目看着像个普通的课程作业，实际上把指针、动态内存、结构体、字符串处理、文件读写、交互循环这几样东西全串在了一起，是少有能同时暴露基础薄弱点和工程习惯的项目。这篇内容面向刚学完数据结构、正被实训周追着跑的同学，也面向工作几年、想回头把指针和内存这些底子重新捋一遍的人。我会把教师信息管理系统的需求拆解、单向链表的选型理由、结构体设计、增删改查排序的实现细节、文件持久化、常见崩溃的排查路径，一并写清楚，代码以 C 语言为例，思路对 C++、Java、Python 同样适用。

1. 需求拆解与方案选型：先想清楚再敲键盘

1.1 教师信息管理系统到底要管哪几件事

很多人拿到题目的第一反应是打开编辑器直接写菜单，结果写到第三个功能就发现结构不对，回头重来。我的习惯是先花二十分钟把需求列成一张表，把"必须有"和"加分项"分开，这样后面写代码时目标非常清楚，也不容易在验收时被问住。

教师信息管理系统的核心业务，本质是对一条"教师记录"做四类操作：录入、查询、修改、删除，外加一个整体性的展示和统计。围绕这个核心，功能清单大致是下面这些：

教师记录的字段设计也有讲究，不能想当然。我一般会给出这样一组字段：工号、姓名、性别、出生年份、职称、学历、所属院系、主讲课程、月工资、入职年份。其中工号是唯一主键，这一条必须在需求阶段就定死，因为后面所有的查找、删除、修改、查重都依赖它。职称用枚举值（助教、讲师、副教授、教授），学历同理，这样排序和统计时不用做字符串比较，省掉一堆麻烦。

这里有个容易被忽略的点：字段的数量要克制。有同学一口气设计了二十个字段，结果录入一个教师要在键盘上敲两分钟，测试的时候自己都受不了。实训场景下，八到十个字段刚刚好，既能体现结构体的组织能力，又不至于让测试变成体力活。

1.2 数组、顺序表和单向链表，到底该选哪个

这道题最值得聊的地方，恰恰是"为什么非要用链表"。说句实话，如果从纯工程角度看，教师信息这种数据量在几百到几千之间、变动也不频繁的场景，顺序表（动态数组）才是更合适的选择——随机访问 O(1)，内存连续对缓存友好，排序直接用库函数，代码量能少一半。

那为什么实训还要指定单向链表？因为教学目标和工程目标是两回事。链表的价值不在于它比数组快，而在于它逼着你把下面这些事想明白：

• 指针到底指向哪里，p = p->next这一行执行后p变了什么；
• 节点在堆上分配，谁负责释放，什么时候释放；
• 删除一个节点时，为什么必须先拿到它的前驱；
• 空表、只有一个节点、删头节点、删尾节点，这些边界怎么统一处理。

这些能力在数组里是练不出来的。所以我的建议是：老老实实按链表做，但在文档或答辩里主动说清楚"这个场景其实顺序表更优，选链表是为了练指针"。这句话说出来，指导老师对你的印象会立刻不一样，因为它证明你不是照着题目抄，而是真的想过。

把三种结构放在一起对比会更清楚：

从表里能看出来，链表真正赢的地方是"容量无上限"和"已知位置时插入删除 O(1)"。教师信息管理系统的数据量不大，所以这两条优势其实体现不出来，取巧的地方在于：链表天然支持动态增长，不需要预先估算教师人数，这一点在答辩时是可以讲的。

1.3 单向链表的代价：三个必须提前接受的现实

选定链表之后，有三个坑是绕不过去的，提前知道能省下大量调试时间。

第一个是不能反向遍历。想找"某位教师的前一个人是谁"，单向链表只能从头再走一遍。这就是为什么删除操作必须写成"查找前驱 + 断链"两步，而不是"找到目标直接删"。有人图省事写了个prev全局变量记录上一次访问的节点，结果在链表中途被修改后立刻出错。

第二个是排序麻烦。数组排序一行qsort搞定，链表排序要么交换节点里的数据（简单但数据大时开销高），要么真的去改指针（正统但容易断链）。这两种做法我后面都会给代码。

第三个是调试困难。数组越界至少还能看到一片连续内存，链表断了就是空指针或者野指针，程序要么直接崩，要么悄无声息地打印出一堆垃圾值。所以从写第一行代码开始，就要养成写"打印链表"函数的习惯，随时能把整条链的内容和地址打出来对照。

提示：链表出问题时，先别急着单步调试，先把整条链的节点地址、next 指向、数据内容打印一遍。九成的断链、环、野指针问题，看一眼地址就露馅了。

2. 结构体设计：字段、节点与表头组织方式

2.1 字段类型的选择，每一个都有理由

字段设计看起来是小事，实际上每个类型选择背后都对应着后面某个操作会不会出问题。我逐个说。

工号用char id[12]而不是int。原因很实际：真实工号经常带前导零（比如0012345），用 int 存会把零吃掉，显示的时候还得补零；有的工号还带字母或短横线。用字符串存，查重直接strcmp，显示直接printf("%s")，没有类型转换的麻烦。长度给 12 是留了余量，够用又不浪费。

姓名用char name[32]。中文姓名在 UTF-8 下一个字占三字节，32 字节足够容纳十个字，还有少数民族姓名和复姓的余量。用char name[32]而不是char *name，是因为定长数组不用管内存分配，拷贝时strcpy一句就完事，指针则要额外 malloc 和 free，在实训这种规模下是自找麻烦。

性别用char gender，存'M'或'F'。别用字符串存"男""女"，一个字节能解决的事不要用三个字节，而且比较的时候if (t->gender == 'M')比strcmp清爽得多。

职称和学历用int枚举。这是整个设计里最能体现水平的一处：用整数存，排序时直接比大小，统计时直接当数组下标用。比如职称 1 到 4 代表助教到教授，那么"统计各职称人数"就变成count[t->title]++，一行搞定。如果用字符串存，你得写一串strcmp，还容易拼错。

工资用double。虽然浮点数有精度问题，但工资字段只用于显示和排序，不做累加对账，用 double 完全够。真要做财务级别的精确计算，应该用"分"为单位的整数，这一点可以在文档里提一句，显得你考虑过。

年份用int。出生年份和入职年份都只需要年份粒度，用 int 存1985比存"1985-06-12"简单得多。年龄可以现算，不用存。

把这些拼起来，记录结构体长这样：

typedef struct { char id[12]; /* 工号，唯一主键 */ char name[32]; /* 姓名 */ char gender; /* 'M' 或 'F' */ int birth_year; /* 出生年份 */ int title; /* 职称 1助教 2讲师 3副教授 4教授 */ int degree; /* 学历 1专科 2本科 3硕士 4博士 */ char dept[32]; /* 所属院系 */ char course[32]; /* 主讲课程 */ double salary; /* 月工资 */ int hire_year; /* 入职年份 */ } Teacher;

2.2 带头结点还是不带头结点，这是个关键决策

节点结构体很简单，就是数据加一个 next 指针：

typedef struct Node { Teacher data; struct Node *next; } Node;

真正要决策的是：链表要不要一个"头结点"（dummy head，也叫哨兵结点）。这是新手最纠结、也最影响代码整洁度的选择。

不带头结点的做法是head直接指向第一个真实教师节点。空表时head == NULL。问题在于：插入第一个节点、删除第一个节点这两种情况，都需要单独写一段特判，因为此时head本身要变。一个典型的删除函数会写成这样：先判断"要删的是不是第一个"，是就head = head->next，不是才走常规的前驱删除。代码立刻分叉，边界测试翻倍。

带头结点的做法是固定分配一个不存数据的节点，head永远指向它，第一个真实教师存在head->next。空表的判断变成head->next == NULL。好处是：

• 插入永远发生在某个节点的后面，不需要特判；
• 删除永远可以找到前驱（就是head本身），不需要特判；
• head指针本身在整个程序生命周期内不变，不用到处传Node **。

我个人的做法是一律带头结点，理由就一句话：边界情况少了，代码路径统一了，测试用例能少写一半。代价是多占一个节点的内存（sizeof(Node)，几十字节），以及初始化时要多分配一次，这个代价可以忽略。

注意：head是哨兵结点，它里面的data是垃圾值，任何遍历都必须从head->next开始。我在代码评审里见过不止一次把哨兵的数据当成第一个教师打印出来的，屏幕上赫然一行乱码姓名。

初始化函数因此只有三行：

Node *list_init(void) { Node *head = (Node *)malloc(sizeof(Node)); if (head == NULL) { fprintf(stderr, "内存分配失败\n"); return NULL; } head->next = NULL; return head; }

malloc的返回值必须检查。这是实训里最容易被扣分、也最容易被忽略的一行。虽然在本机测试时几乎不会失败，但检查它体现的是工程习惯，老师一眼就能看到。

2.3 内存布局与指针关系，用文字画一遍

链表在内存里是散落分布的，理解这一点对调试至关重要。假设依次录入了三位教师，内存里的关系大致是：

• 哨兵节点地址 0x1000，next指向 0x2000；
• 节点 A（张三）在 0x2000，next指向 0x2100；
• 节点 B（李四）在 0x2100，next指向 0x2200；
• 节点 C（王五）在 0x2200，next为 NULL。

这几个地址不连续，是malloc在堆上挑的空位。所以任何"用head + i的方式去访问第 i 个节点"的想法都是错的，链表只能靠next一步一步跳。

遍历的标准写法一定要背下来：

for (Node *p = head->next; p != NULL; p = p->next) { /* 处理 p->data */ }

这里有个细节：循环条件写p != NULL还是p->next != NULL，决定了循环体里能不能安全访问p->data和处理最后一个节点。前者是"遍历所有真实节点"，后者在删除、插入场景里更常用。我在代码里统一用前者，需要前驱时再额外维护一个prev指针，语义更清晰。

3. 核心操作的实现细节与高频坑点

3.1 建表：为什么坚持用尾插法

建表有两种方式：头插和尾插。头插是一行代码的事，新节点直接插在哨兵后面：

/* 头插，会导致逆序 */ n->next = head->next; head->next = n;

问题在于，头插会让链表顺序和你录入的顺序完全相反。你录入张三、李四、王五，显示出来是王五、李四、张三。用户体验极差，而且测试数据一多，根本对不上号。

尾插法多维护一个尾指针，但保持录入顺序。如果每次都从头遍历找尾巴，插入 n 个节点的时间就是 O(n²)，看着数据少无所谓，但这个习惯不好。正确做法是用一个尾指针tail记住最后一个节点：

Node *tail = head; while (tail->next != NULL) tail = tail->next; /* 只在建表开始时找一次 */ /* 之后每次插入 */ Node *n = (Node *)malloc(sizeof(Node)); n->data = tch; n->next = NULL; tail->next = n; tail = n;

这样每次插入都是 O(1)。这个小技巧能在答辩时加分，因为它证明你知道"链表本身不慢，慢的是每次都从头遍历"。

录入时还要做两件事：工号查重和输入校验。查重就是在插入前遍历一遍，strcmp到相同工号就拒绝。输入校验关注的是别让用户输入超长的东西把数组冲掉——scanf("%11s", tch.id)里的11就是给id[12]留出结束符的位置。不加这个宽度限制，输入一个二十字符的工号就能把后面的字段覆盖掉，这种 bug 极难查。

3.2 查找：为什么"找前驱"比"找自己"更重要

按工号查找，标准实现返回节点指针，找不到返回 NULL：

Node *find_by_id(Node *head, const char *id) { for (Node *p = head->next; p != NULL; p = p->next) { if (strcmp(p->data.id, id) == 0) return p; } return NULL; }

这个函数能解决查询和修改，但解决不了删除。因为删除需要的是前驱节点。所以我通常再写一个返回前驱的函数，或者干脆把查找改成返回前驱：

Node *find_prev_by_id(Node *head, const char *id) { for (Node *p = head; p->next != NULL; p = p->next) { if (strcmp(p->next->data.id, id) == 0) return p; } return NULL; }

注意循环的起点是head而不是head->next，判断的是p->next->data.id。这个写法的妙处是：如果第一个真实节点就是目标，p就是head，返回它完全正确，不需要任何特判。这就是带头结点带来的好处。

按姓名模糊查询用的是strstr：

if (strstr(p->data.name, keyword) != NULL) { /* 命中 */ }

strstr返回子串首次出现的位置，找不到返回 NULL。查"张"能把"张三""张小雨""欧阳张"都捞出来。需要注意的是，它按字节比较，如果关键字是半个汉字（比如只输入了一个汉字的第一个字节），可能匹配到乱码，实际使用中输入完整汉字就没问题。

3.3 删除节点：断链顺序和 free 时机

删除是单向链表最容易出事的操作，我把完整流程和每一步的理由写清楚：

int delete_by_id(Node *head, const char *id) { Node *prev = find_prev_by_id(head, id); if (prev == NULL) return 0; /* 没找到 */ Node *victim = prev->next; /* 1. 先记住要被删的节点 */ prev->next = victim->next; /* 2. 让前驱跳过它，链表已连续 */ free(victim); /* 3. 再释放内存 */ return 1; }

这三步的顺序不能乱换。如果先free(victim)再去读victim->next，读的就是已经还给堆管理器的内存，属于典型的 use-after-free，有时候能跑通，有时候打印出垃圾值，有时候直接崩——这种"薛定谔的 bug"最折磨人。正确顺序是：先保存信息，再改链，最后释放。

还有两个细节：

• free之后把指针置 NULL。free(victim); victim = NULL;是防御性写法。虽然在这个函数里victim马上就出作用域了，但在其他场景（比如把节点摘下来还要复用的场景），一个悬空指针就是定时炸弹。
• 删除不释放Teacher里的数据。因为Teacher里的字符串都是定长数组，不是单独 malloc 的指针，所以free(node)会把整块内存连同数据一起释放，不需要额外处理。如果哪一天把char name[32]改成了char *name，删除函数就必须先free(n->data.name)，否则就是内存泄漏。这一点一定要想清楚，别记混。

删除还有一个变体需求：清空整条链。写法是遍历一遍逐个释放，最后把head->next置 NULL。注意不能一边free一边p = p->next，因为p->next已经随free失效了，必须先把 next 存到临时变量里：

Node *p = head->next; while (p != NULL) { Node *next = p->next; /* 先存下一个 */ free(p); p = next; } head->next = NULL;

3.4 修改与排序：链表排序的两种做法及取舍

修改比较简单，先查到节点，然后逐个字段重新输入即可。有一个原则要遵守：工号不允许修改。因为工号是主键，改了之后所有靠工号建立的关系都失效了。实现上就是不提供改工号的入口，或者在修改函数里跳过它。

排序才是真正有意思的部分。链表排序有两种思路：

思路一：交换数据，不动指针。用冒泡或选择排序，比较p->data和q->data，需要交换时用一个临时Teacher变量做整体赋值。代码短，好懂：

for (Node *p = head->next; p != NULL; p = p->next) { for (Node *q = p->next; q != NULL; q = q->next) { if (p->data.salary < q->data.salary) { Teacher tmp = p->data; p->data = q->data; q->data = tmp; } } }

缺点是每次交换都要拷贝整个结构体。sizeof(Teacher)大概一百多字节，数据量大了以后开销不小。

思路二：改指针，不动数据。这才是链表排序的"正统"做法。实现上通常用插入排序：把原链拆成一条有序链，然后逐个把节点按顺序插进去。

Node *sort_by_salary(Node *head) { if (head->next == NULL || head->next->next == NULL) return head; Node *sorted = head->next; /* 已排序部分的第一个节点 */ Node *cur = sorted->next; /* 待插入的节点 */ sorted->next = NULL; /* 先把已排序链截断 */ while (cur != NULL) { Node *next = cur->next; /* 保存下一个待处理节点 */ if (cur->data.salary >= sorted->data.salary) { cur->next = sorted; /* 比第一个还大，插到最前 */ sorted = cur; } else { Node *p = sorted; while (p->next != NULL && p->next->data.salary > cur->data.salary) p = p->next; cur->next = p->next; p->next = cur; } cur = next; } head->next = sorted; return head; }

这段代码的关键点有两个：一是进入循环前先把cur->next存下来，因为cur马上要被挂到别的链上，原来的 next 就丢了；二是排序完成后要把head->next重新指向排序结果的第一个节点，不然哨兵还指着老位置，整条链就断了。

两种做法我都建议写一遍，然后在注释里说明各自适用场景。这个对比如果能在答辩时讲出来，是很加分的。

3.5 文件持久化：文本还是二进制

程序一退出数据就没了，这是最不能接受的。持久化选择无非两种：文本和二进制。

文本格式（一行一条记录，字段用逗号或制表符分隔）的好处是人眼可读、可以手动改、方便调试。写文件时用fprintf逐个字段输出，读的时候用fgets读一行再sscanf解析。缺点是解析容易出错，尤其是字段里含分隔符的时候（教师姓名里当然不会有逗号，但随着字段变多，这个风险会上升）。

二进制格式（fwrite整块结构体）的好处是快、简单、不需要解析。缺点也很明显：不可读，而且结构体在内存里有对齐填充，不同编译器、不同平台的填充规则可能不同，换台机器读出来就可能是乱码。这一点很多教程不写，但它确实是二进制持久化的经典陷阱。

我的建议是：实训阶段一律用文本格式。理由不是它更优，而是它出错时你能一眼看出来。文件里那一行内容不对，你能立刻定位到是哪个字段写错了；二进制文件出问题，你只能干瞪眼。

写文件的核心代码：

int save_to_file(Node *head, const char *path) { FILE *fp = fopen(path, "w"); if (fp == NULL) return 0; for (Node *p = head->next; p != NULL; p = p->next) { fprintf(fp, "%s,%s,%c,%d,%d,%d,%s,%s,%.2f,%d\n", p->data.id, p->data.name, p->data.gender, p->data.birth_year, p->data.title, p->data.degree, p->data.dept, p->data.course, p->data.salary, p->data.hire_year); } fclose(fp); return 1; }

读文件时要处理一个经典陷阱：feof的判断时机。很多人的写法是这样：

/* 错误示范 */ while (!feof(fp)) { fscanf(...); /* 最后一次循环会多读一次，产生一条重复记录 */ }

feof只有在读了文件末尾之后才会返回真，所以这个循环会多执行一次，最后一条记录会被重复插入。正确做法是判断读取函数的返回值：

char line[256]; while (fgets(line, sizeof(line), fp) != NULL) { line[strcspn(line, "\r\n")] = '\0'; /* 去掉行尾换行符 */ if (line[0] == '\0') continue; /* 跳过空行 */ Teacher t; if (sscanf(line, "%11[^,],%31[^,],%c,%d,%d,%d,%31[^,],%31[^,],%lf,%d", t.id, t.name, &t.gender, &t.birth_year, &t.title, &t.degree, t.dept, t.course, &t.salary, &t.hire_year) == 10) { insert_teacher(head, t); /* 字段完整才插入 */ } }

sscanf的返回值是成功赋值的字段个数，等于 10 说明这一行完整解析成功。这个判断能挡掉文件被手动改坏、或者某行写了一半的情况。%[^,]是读取到逗号为止的字符串，配合宽度限制%11[^,]就能防止缓冲区溢出。

4. 完整实现流程与关键环节落地

4.1 工程结构：别把所有东西堆进 main

单文件能不能写完？能，八百行左右。但那样写出来的东西自己都不想看第二遍，更别提答辩时被追问"你的删除函数在哪"。我的做法是至少分出三层：

分层带来的最大好处是：改菜单不会碰坏链表逻辑，改链表不会影响文件格式。实训验收时，老师问"删除函数在哪"，你直接打开teacher.c指给他看，专业感立刻就有了。

头文件里别忘了写#ifndef TEACHER_H / #define TEACHER_H / #endif这套防重复包含的守卫。虽然这个项目只有一个头文件，但写上不费事，是个好习惯。

4.2 主菜单与输入校验：别让程序卡死在一个字母上

菜单本身简单，printf打几行，scanf读一个数字，switch分发。但这里面藏着一个实训里极其常见、又极其难自己发现的坑：

/* 有问题的写法 */ int choice; scanf("%d", &choice);

如果用户输入的是一个字母（比如手滑按了q），scanf会返回 0，这个字母会留在输入缓冲区里，下一轮循环再读，还是它，再失败，再留——于是程序进入死循环，屏幕上疯狂刷菜单，用户只能强杀进程。这个现象在机房演示时出现一次，就够丢人了。

正确的做法是把返回值和缓冲区清理都做上：

int read_choice(void) { int choice; if (scanf("%d", &choice) != 1) { /* 清空这一行的剩余内容 */ int c; while ((c = getchar()) != '\n' && c != EOF) { } return -1; } /* 成功读入后也要清掉行尾换行符 */ int c; while ((c = getchar()) != '\n' && c != EOF) { } return choice; }

调用方把-1当作非法输入处理，提示一句"请输入 0-8 之间的数字"然后继续循环。这样一来，无论用户怎么乱按，程序都不会卡死。

输入字符串时还有两个高频问题：

• 姓名带空格。scanf("%s")遇到空格就停，输入"欧阳 明"只会读到"欧阳"。需要用fgets或者scanf("%31[^\n]")读整行，然后再去掉行尾换行。
• 连续读取时跳过输入。上一个scanf("%d")留下了一个换行符，下一个scanf("%s")会把它当空字符串读走，导致"姓名还没让我输就跳过去了"。解决办法就是在每次读字符串前清一次缓冲区，或者统一用fgets读所有输入。

中文对齐问题也值得单独说一句。printf("%-10s", name)在纯英文下能左对齐，但中文在 UTF-8 里一个字占三字节，-10补的是字节不是显示宽度，中文姓名一混进来，表格立刻歪掉。实训阶段可以接受轻微不齐，如果真想对齐，要么用wcwidth这类宽字符处理，要么干脆放弃表格格式，改成一行一个字段的竖排显示。我个人的选择是后者，省事且不出错。

4.3 一个可以直接跑起来的最小骨架

把上面的东西串起来，主函数大致是这样：

int main(void) { Node *head = list_init(); if (head == NULL) return 1; load_from_file(head, "teachers.txt"); /* 启动即加载，文件不存在就跳过 */ int running = 1; while (running) { show_menu(); int choice = read_choice(); switch (choice) { case 1: do_add(head); break; case 2: do_delete(head); break; case 3: do_modify(head); break; case 4: do_query(head); break; case 5: show_all(head); break; case 6: do_sort(head); break; case 7: do_stats(head); break; case 8: save_to_file(head, "teachers.txt"); break; case 0: save_to_file(head, "teachers.txt"); /* 退出前自动保存 */ running = 0; break; default: printf("无效选择，请重新输入\n"); break; } } destroy_list(head); /* 释放所有节点 */ return 0; }

这里有两个设计选择值得说明。一是启动自动加载、退出自动保存，用户不需要额外记住"要先按 8 保存"，避免了"辛苦录了十条，直接关窗口全丢了"的惨剧。二是退出前一定调destroy_list，虽然操作系统会回收进程内存，但代码里显式释放是习惯问题。用valgrind跑一遍如果显示All heap blocks were freed，那种感觉是很爽的，答辩时也可以主动演示。

4.4 测试用例设计：边界才是重点

写完代码只是开始，测试才是发现问题的地方。我一般会准备下面这组用例，按顺序跑一遍：

第 4 条和第 10 条是最能区分"能跑"和"写对了"的。删头节点如果不用哨兵，就得写特判，很容易漏；文件解析如果不校验返回值，一个坏行就能让整条链多出一条垃圾数据。

5. 常见问题排查速查表与实训心得

5.1 高频崩溃的定位方法

链表程序的崩溃有个规律：九成的段错误来自三种情况——访问了 NULL 的->next、访问了已经free的内存、数组越界把相邻的指针字段冲掉了。按这个顺序排查，效率最高。

先看崩溃时的调用栈，定位到具体哪一行。如果是p->next报错，那基本就是p是 NULL，往前找是哪一步让p变成了 NULL——常见的是遍历时漏了p != NULL的判断，或者删除操作把p自己删掉了还继续用。如果是free报错（double free or corruption），那就是同一块内存被释放了两次，通常是删除函数被调用了两次，或者清空链表时没有及时把head->next置空。

我整理了一张速查表，覆盖了这几届实训里见到的大部分问题：

这张表我建议直接抄进实训报告的"问题与解决"章节。里面每一条都是真实会遇到的，而且都给出了排查路径，比写"通过本次实训我提高了编程能力"这种话有用一百倍。

5.2 答辩时最容易被追问的几个点

实训验收往往有个环节是老师随机提问，答不上来会被认为"代码不是自己写的"。根据经验，被问得最多的是下面这几个，提前准备好答案：

问：为什么用链表不用数组？标准答法是分两层：业务层面，教师人数不确定，链表天然支持动态增长，不需要预估容量；教学层面，链表能练习指针操作、动态内存管理和边界处理。然后主动补一句"如果数据量固定且以查询为主，顺序表其实更合适"，这样显得你理解取舍，而不是背答案。

问：删除一个节点为什么必须找前驱？因为单向链表只有向后的指针，没有向前的。要让链表保持连续，必须让目标节点的前一个节点的next跳过目标。找不到前驱就没法改链。顺势可以提一句"双向链表就不需要，这也是双向链表多一个指针域换来的便利"。

问：头结点有什么用？统一了插入和删除的代码路径，尤其是删除第一个节点时不需要特判head的变化，因为head永远是哨兵，永远不会被删。

问：时间复杂度是多少？按工号查找 O(n)，插入如果已知位置 O(1)、从头找位置 O(n)，删除是"查找 O(n) + 断链 O(1)"，整体 O(n)。排序用插入排序是 O(n²)，如果换成归并排序能到 O(n log n)，但代码复杂度高不少。

问：内存泄漏怎么检测？答 valgrind（Linux）或者编译器的 AddressSanitizer，命令行加-fsanitize=address就能跑。能说出这个，说明你真的动手测过。

问：如果工号重复了怎么办？录入前遍历查重，strcmp命中就拒绝并提示。这是主键唯一性的保证。

5.3 从"能交作业"到"拿得出手"的几个加法

如果时间还宽裕，加几个小功能能让这个项目从及格线跳到优秀档，而且实现成本都不高：

按职称统计人数和平均工资。遍历一遍，用count[5]和sum[5]两个数组按职称下标累加，最后打印。十行代码，但演示效果很好，因为它证明你能把枚举值当数组下标用。

按院系筛选并分页显示。每页十条，按键翻页。这个功能练的是"遍历 + 计数 + 交互"，比单纯的显示全部有意思。

导出为 CSV 并用表格软件打开。其实保存函数稍改一下分隔符就是 CSV 了，但如果你能在演示时把导出的文件用表格软件打开，视觉冲击力比在黑窗口里看强十倍。

链表反转。把所有教师按录入的逆序显示。这是链表最经典的面试题之一，写法是三指针迭代：

Node *reverse(Node *head) { Node *prev = NULL; Node *cur = head->next; while (cur != NULL) { Node *next = cur->next; cur->next = prev; prev = cur; cur = next; } head->next = prev; return head; }

这段代码短，但每一行都要想清楚。能手写出来，说明你对指针的理解到位了。

用 Makefile 管理编译。三条规则，make一下全编译，make clean清理产物。这个算不上功能，但专业感拉满，答辩时老师看到工程目录里有 Makefile，评价会不一样。

我把话说回最开始那个观察：这个题目真正有价值的地方，不是"实现了几个功能"，而是它逼着你把指针、内存、边界、输入输出这几件基本功重新过一遍。功能可以少，但每一条链都要连得对，每一块内存都要释放得干净，每一个非法输入都要接得住。做到这三点，这份代码就不只是作业了，它是你后面写任何带动态结构程序的地基。我在实际带人时发现，凡是这个题目能自己从头写一遍、不抄不拼的人，后面学树、学图、学任何带指针的数据结构，都会顺很多；而那些靠复制粘贴过关的，往往在二叉树那章原地卡住。慢一点没关系，把这条单向链表真正吃透，比赶完三个实训题目都值。