1. 单链表到底解决什么问题

我第一次系统整理单链表的应用时，脑子里最大一个疑问是：数组这么好用，连续内存、随机访问、遍历还快，为什么还要折腾链表？后来在实际写代码的过程中才逐渐想明白——链表的出现不是因为数组不好，而是因为有一类场景只靠数组做起来非常别扭。

先回顾一下单链表的基本形态：每个节点除了存储数据本身，还要存一个指向下一个节点的指针。你拿到的是头节点指针，然后通过 next 指针一个一个往后跳。从数据结构的角度看，单链表是线性表的链式存储实现，和顺序表（比如数组）正好形成互补。

它解决的核心问题可以归纳成三个方向。第一，存储空间不必连续。数组在内存里必须是一块连续空间，如果编译期开大小，小了不够用，大了浪费，而链表节点用多少申请多少，天然适应数据规模未知的场景。第二，在头部和中间进行插入、删除操作时，单链表只需要修改少量指针指向，不需要像数组那样把后续所有元素整体搬移。第三，在没有随机访问需求的场景下，链表的遍历访问能力完全够用。反过来，链表也有明显短板，比如无法 O(1) 下标定位，缓存命中率不如数组，所以链表的应用必须基于“需要频繁插入删除、数据规模动态变化、访问模式以顺序遍历为主”这样的前提来选型。

这篇文章不是单纯抄笔记，而是把我把单链表应用场景和实现细节整理成一套可以照着做的东西。适合刚学完链表基础操作、但还不太清楚链表“学了能干嘛”的同学，也适合准备面试、需要快速把链表常考场景过一遍的人。我会从应用场景讲起，然后逐步展开核心操作的实现、几种典型应用的完整案例、常见调试问题和经验教训。

2. 链表的存储结构与基本操作的底层逻辑

2.1 结构定义：节点是链表的积木

单链表最基础的结构体在 C 语言里长这样：

typedef int SLTDataType; // 方便以后换成其他类型 typedef struct SListNode { SLTDataType data; struct SListNode* next; } SListNode;

我刚开始写这个结构体时，有个习惯不太好——喜欢给 typedef 起一个很长的名字，然后在函数里到处用 SListNode*，代码看起来没问题，但可读性一般。后来我改成在需要强调“这是一个指针类型”的地方单独定义：

typedef struct SListNode SListNode;

注意，这里的 struct SListNode* next 不能用 SListNode* next 替代，因为 typedef 生效是在结构体定义结束之后，结构体内部引用自己的指针类型时，必须使用完整的 struct SListNode*。这种细节看起来小，但初学者经常踩坑，我自己也报过“unknown type name ‘SListNode’”的错误，根源就在这。

data 用什么类型取决于实际场景。教学代码常用 int，但如果链表要存学生姓名或字符串，应当直接换成 char* 或字符串数组。这里有一个需要提醒的点：如果 data 是指针类型，你要明确这个指针指向的内存归谁管。是指链表负责动态分配和释放，还是外部传入、链表只保存地址？我在后面的字符串链表案例中会专门展开，因为这里容易造成内存泄漏或重复释放。

2.2 头节点和头指针：一个关键概念差异

很多资料会强调头节点，但实际写代码时不统一。所谓头指针，是指向链表第一个节点的指针；头节点，则是带头链表中的第一个节点，它本身不存放有效数据，或者说它的 data 字段可以闲置。用头节点之后，在头部插入和删除不再需要特判头指针为空的情况，代码更统一。

但初阶阶段，我更推荐直接用头指针，不带头节点。理由很简单：带头的链表代码在某些操作上更方便，但理解成本更高，尤其在遍历和判空时容易绕晕。先掌握不带头节点的写法，再去看带头的实现，两种写法的差异会非常清晰。

不带头节点时，空链表直接用 NULL 表示，判断空就是if (plist == NULL)，遍历从头指针开始。插入头节点时，需要传入指针的地址，也就是二级指针，因为要在函数内部修改头指针本身。很多新手在这里会问我：“我传一级指针不也能修改节点的数据吗？”答案是节点里的 next 和数据修改可以通过一级指针完成，但让头指针指向新节点，必须传头指针的地址。

二级指针的例子我贴一段：

void SListPushFront(SListNode** pplist, SLTDataType x) { SListNode* newnode = (SListNode*)malloc(sizeof(SListNode)); if (newnode == NULL) { printf("malloc fail\n"); return; } newnode->data = x; newnode->next = *pplist; *pplist = newnode; }

注意最后一行*pplist = newnode，就是把新节点地址写入原来的头指针变量。如果你只传了SListNode* plist，函数内部修改这个形参对调用处的头指针没有任何影响。

2.3 单链表删除操作的核心：找到前驱节点

链表的删除和数组最大的不同在于，数组删除需要搬移数据，链表删除只需要修改指针。但单链表只能从某个节点访问到它的后继，却无法直接访问它的前驱。所以删除某个节点时，必须从头开始遍历，找到“目标节点的前一个节点”，也就是前驱节点，然后让前驱的 next 指向目标节点的后继。

删除头节点的情况特殊，头节点没有前驱，直接修改头指针就行了。其余情况下，删除逻辑是：

void SListPopAfter(SListNode* pos) { if (pos == NULL || pos->next == NULL) return; SListNode* del = pos->next; pos->next = del->next; free(del); del = NULL; }

这是“删除 pos 之后那一个节点”的版本。如果接口设计成删除指定位置，还需要在外部先找到目标位置的前驱。很多教材喜欢直接用“删除给定节点”，但初阶我更推荐“删除 pos 之后节点”的接口，因为这样省去再次查找前驱，而且能顺便锻炼对指针操作的敏感度。

3. 单链表的三大核心应用场景

3.1 动态数据规模：内存按需分配

链表最直观的应用就是解决“数据量事先不知道”的问题。比如从文件中读入一组未知数量的整数，如果只用数组，通常需要先统计行数，或者开一个足够大的静态数组，这两种办法都不优雅。用链表则可以在读取过程中不断创建新节点，数据量多少，节点就建多少。

这里的底层逻辑是每次 malloc 只是申请一个节点的大小，若干个节点之间通过 next 指针串联，不要求内存连续。这样即使数据总量很大，只要内存足够，链表都能逐一容纳。而数组一旦扩容，往往要 realloc 一整块更大的连续内存，并把原来的数据拷贝过去，这个代价在数据量大的时候比较明显。

不过要注意：链表的每个节点都额外占用一个 next 指针的空间，存储密度比数组低。假设 int 占 4 字节，指针占 8 字节（64 位系统），每个节点实际需要 16 字节（加上内存对齐可能是 16），有效数据只有 4 字节，存储开销是数据的 4 倍。因此，在数据量极大且内存紧张的场景下，不一定非要用链表，需要综合评估。

从应用层面来说，动态大小的场景很适合用链表做底层容器。例如一个任务队列，任务数量随运行状态不断变化；一个日志缓冲链表，日志条目不定长；一个订单列表，订单数量事先不确定。你都可以用链表先顶上去，后面再根据性能需求决定是否换成其他结构。

3.2 频繁头部插入删除：链表的主场

如果业务逻辑决定数据总是从头部进出，比如栈的一种实现、某种消息队列、浏览器的前进后退记录（当然这是双链表更合适），那么链表比数组有天然优势。数组头部插入需要把所有元素后移，时间复杂度 O(n)，而链表只需要创建新节点并修改头指针，时间复杂度 O(1)。

这种“头部操作频繁”的场景，初阶最典型的例子就是栈的链式实现。用链表模拟栈，只需要在头节点位置做 push 和 pop：

• push：调用头插函数，新节点成为头节点。
• pop：先保存头节点的 data，然后让头指针指向第二个节点，再释放原头节点。

这样实现的栈不需要预先知道栈的最大深度，适合编译器表达式求值、浏览器撤销操作这类不确定深度的场景。和数组栈相比，链表栈突出优点是灵活，缺点是数据分散，访问速度略慢，但在初阶学习中更关注的是逻辑正确性，性能差异不必过度纠结。

再比如实现一个简单的消息队列，可以使用尾插 + 头删的组合：新消息从尾部进，处理消息从头部出。关于尾插，单链表需要维护一个尾指针来避免每次遍历到末尾，这样才能保证入队 O(1)。如果不维护尾指针，每次入队都要从头遍历到最后一个节点，时间复杂度变成 O(n)，消息量大时性能会很难看。

3.3 内存不连续下的顺序访问

链表的第三个典型应用场景是“数据本身在物理上不连续，但逻辑上需要顺序访问”。链表只是把数据组织成线性逻辑关系的工具。理论上讲，只要想对一组数据做“逐一遍历”的处理，并且每一个元素都有唯一的前驱后继，就可以用链表。

例如多项式加法：多项式的每一项可以表示成一个节点，节点里存系数和指数，多个节点按指数从低到高排序。合并两个多项式时，只需要按顺序同时遍历两个链表，比较指数大小，然后决定插入哪个结果链表。这种场景如果使用数组，会面临一个问题：多项式可能非常稀疏，次数从 0 到 10000 中间只有几项，数组存储会浪费大量空间。链表则只存储存在的那些项，配合按指数有序的组织方式，遍历和合并的效率都很好。

类似的例子还有集合运算。集合 A 和 B 是两个递增有序链表，求并集时同时遍历两个链表，比较节点值，值小的先存入结果集，相同值只存一个。整个过程做到 O(m + n)，空间额外开销是结果链表本身。

其实这类场景反映的是链表的一个抽象价值：它让你把注意力放在“元素之间的顺序关系”上，而不必被内存地址的连续性牵着走。你用链表组织数据，顺序关系完全由 next 指针表达，数据放哪都行。这也是为什么很多高级数据结构，比如哈希表的拉链法、邻接表，底层都用链表——因为它们天然就需要管理一组不连续、动态变化、顺序访问的关联元素。

4. 常见功能模块：顺序表与链表的较量

很多同学会问，为什么不在所有线性表场景都改用链表？这里我整理了一张对比表，把我自己踩过坑后体会最深的部分写清楚：

一个重要结论是：单链表并非“插入删除都快”，它只有“已知前驱节点”的情况下插入删除才快。如果你已经知道要在某个节点后面插入，那确实是 O(1)，但如果只知道下标，仍要花费 O(n) 的时间寻找位置。所以实际写代码时，不要盲目认为链表一定优于数组。

拿“尾部删除”说，数组可以直接通过记录元素个数来减少长度，单链表则必须从头部走到倒数第二个节点，把它的 next 置空。如果链表很长，这个操作很慢。所以如果你的业务是“频繁尾部插入和删除”，单链表并不是最优选择，倒不如考虑动态数组或双向链表。

单链表最适合的操作组合是“头部增删 + 顺序遍历”，这是它性能优势最明显的区域。至于“随机访问某个位置的值”，那就老老实实用数组。

5. 单链表经典应用案例：从思路到代码

5.1 链式栈：用头插头删模拟后进先出

栈的特点是后进先出。用单链表实现栈非常自然：头节点是最新入栈的元素，入栈即头插，出栈即头删，取栈顶即读取头节点 data。

我给出一个完整的头文件接口设计：

typedef int STDataType; typedef struct StackNode { STDataType data; struct StackNode* next; } StackNode; // 入栈 void StackPush(StackNode** pplist, STDataType x); // 出栈 void StackPop(StackNode** pplist); // 取栈顶 STDataType StackTop(StackNode* list); // 判空 int StackEmpty(StackNode* list); // 销毁 void StackDestroy(StackNode** pplist);

这里的关键设计选择是使用二级指针传递头指针，原因是入栈和出栈都可能修改头指针本身。以 StackPop 为例：

void StackPop(StackNode** pplist) { if (*pplist == NULL) return; StackNode* del = *pplist; *pplist = del->next; free(del); del = NULL; }

如果不用二级指针，很容易写成只修改函数内局部参数，最后发现原来的栈头没变。我第一次写链式栈时就是在这里翻车，函数执行完，栈顶元素依然还在，调试了半天才意识到形参和实参的问题。

栈的经典应用场景包括括号匹配、表达式求值、函数调用栈模拟。括号匹配的算法用数组栈也能写，但链式栈版本更能体现“动态扩展”的价值：给定一段未知长度的括号串，使用链式栈可以一边读入一边入栈，完全不需要预知括号串总长度。

括号匹配的伪代码思路：

1. 遍历每个字符。
2. 遇到左括号，入栈。
3. 遇到右括号，判断栈是否为空：
   • 如果为空，说明右括号没有匹配的左括号，匹配失败。
   • 如果不为空，取栈顶元素，判断是否是对应左括号，不匹配则失败。
4. 遍历结束后，栈还有剩余左括号，匹配失败。

这个例子很适合初学，因为能把栈的“后进先出”和实际语义（最近的左括号需要最先被匹配）直接对应起来，也顺便练习了链表的创建和销毁。

5.2 多项式合并：链表的排序性应用

假设两个多项式已经按指数从低到高排好序，现在要合并它们。节点结构可以设计成：

typedef struct PolyNode { float coef; // 系数 int expon; // 指数 struct PolyNode* next; } PolyNode;

合并思路类似于归并两个有序序列。准备三个指针，pa 指向第一个多项式当前项，pb 指向第二个多项式当前项，结果链表的尾插用 tail 指针维护，方便 O(1) 尾部追加。

核心逻辑：

while (pa != NULL && pb != NULL) { if (pa->expon < pb->expon) { // 将 pa 当前节点复制到结果链表尾部 pa = pa->next; } else if (pa->expon > pb->expon) { // 将 pb 当前节点复制到结果链表尾部 pb = pb->next; } else { // 指数相等，系数相加，不为0才插入结果链表 float sum = pa->coef + pb->coef; if (sum != 0) { // 创建新节点，系数为 sum，指数为 pa->expon } pa = pa->next; pb = pb->next; } } // 把剩余链表节点复制到结果链表尾部

这个案例的价值在于，它让单链表的“遍历 + 条件插入”变成一种系统化的操作，而不是零散地调用插入函数。为什么建议复制节点而不是直接把原链表节点摘下拼过去？从教学角度看，复制节点更安全，避免两个多项式链表被修改后影响后续使用。从工程角度看，如果需要保留原多项式，复制是必须的。

实际使用中，两个多项式链表的节点数往往不同，最后一定有一个链表先遍历完，剩下那个就直接整体挂到结果链表尾部。整体挂接不是把 tail->next 指向剩余链表的头就行了吗？如果是复制节点，就需要逐一遍历复制；如果是直接拼接，那确实一行代码搞定。在允许修改原链表的场景，直接拼更快。我一开始写多项式合并时贪方便直接拼，后来发现调用方希望原多项式在后续继续参与运算，只能改成复制。

5.3 字符串数据链表：处理指针指向问题

如果链表里存字符串，有两种常见形式。

第一种，节点直接内嵌字符数组：

typedef struct NameNode { char name[32]; struct NameNode* next; } NameNode;

这种写法结构简单，复制字符串用 strcpy 直接写进数组，生命周期容易管理，但每个节点固定占用 32 字节，如果字符串长度差异大，空间浪费明显。

第二种，节点存 char* 指针：

typedef struct NameNode2 { char* name; struct NameNode2* next; } NameNode2;

这种写法灵活，但必须处理内存归属问题。当外部传入一个字符串字面量或临时缓冲区内容时，节点应该把字符串内容拷贝到自己的堆内存中，否则外部缓冲区一旦释放，链表节点里的 name 就变成了悬垂指针。

我推荐在插入函数内部统一处理复制逻辑：

void SListPushName(NameNode2** pplist, const char* str) { NameNode2* newnode = (NameNode2*)malloc(sizeof(NameNode2)); newnode->name = (char*)malloc(strlen(str) + 1); strcpy(newnode->name, str); newnode->next = *pplist; *pplist = newnode; }

销毁时也要先 free(newnode->name)，再 free(newnode)，顺序不能反，否则 name 内存就泄漏了。

这类问题表面看是链表知识的延伸，实际考察的是内存管理基本功。我在教学过程中发现，很多学生会在销毁链表时只 free 节点，忘了 free 内部的动态字符串，最终导致内存泄漏。排查内存泄漏真的很费劲，最好从设计上就杜绝这种可能：要么统一所有字符串都由外部管理，要么统一所有字符串都由链表节点自己管理，不要混用。

5.4 基于链表的邻接表：图的基础构建

邻接表是图论中常用的存储结构，每条边只存一次，适合稀疏图。每个顶点维护一个链表，链表节点存储“与该顶点相邻的另一个顶点编号”，还可以带一个权值字段用于带权图。

具体结构可以这样设计：

typedef struct EdgeNode { int adjvex; int weight; struct EdgeNode* next; } EdgeNode; typedef struct VertexNode { int data; EdgeNode* firstEdge; } VertexNode;

实际代码中，一个图可以是一个顶点数组加一个边链表数组。构建过程就是不断向顶点对应的链表头部插入边节点，时间复杂度接近 O(E)，非常高效。这也是链表在数据结构课程中一个非常经典的工程应用。

初阶阶段不必把这个案例完整实现，但可以从中看到链表真正的用武之地：管理一组数量不确定、动态变化、需要频繁增删的关联关系。这种场景用数组很难处理，因为一个顶点可能连接很多其他顶点，也可能一个都不连，无法提前给每个顶点分配定长空间。

6. 完整实操：从零写一个单链表应用 Demo

为了把上面的知识点串起来，我设计一个完整的小项目：学生成绩单链表。功能包括读取 N 个学生的姓名和成绩，创建链表；打印全部学生成绩；按成绩排序；删除低于及格线的学生；最后释放链表。

这个项目不复杂，但覆盖了单链表最常用的几个操作，非常适合作为初阶笔记的配套练习。下面给出核心代码片段、设计取舍和运行要点。

6.1 结构体与菜单设计

typedef struct Student { char name[32]; int score; struct Student* next; } Student;

我选择内嵌字符数组存姓名，主要考虑是删除和拷贝都方便，避免处理复杂的二级内存。如果追求更灵活，可以参考前面字符串链表那节的第二种写法，但初阶练习用固定字符数组更省心。

菜单采用循环结构：

int main() { Student* head = NULL; int choice; while (1) { printf("1.新建链表 2.打印 3.排序 4.删除不及格 0.退出\n"); scanf("%d", &choice); switch (choice) { case 1: CreateList(&head); break; case 2: PrintList(head); break; case 3: SortList(&head); break; case 4: DeleteFail(&head, 60); break; case 0: DestroyList(&head); printf("退出\n"); return 0; default: printf("无效输入\n"); break; } } }

注意 CreateList、SortList、DeleteFail 中都可能修改头指针，所以要传二级指针。PrintList 只需要遍历，传一级指针即可。这个设计细节本身就是一个考试常考点。

6.2 新建链表：尾插法

因为学生数据是顺序输入，保留原始顺序更符合直觉，所以我用尾插法插入。

void CreateList(Student** pphead) { int n; printf("请输入学生数量:"); scanf("%d", &n); for (int i = 0; i < n; i++) { Student* newnode = (Student*)malloc(sizeof(Student)); if (newnode == NULL) { printf("malloc fail\n"); return; } printf("请输入第%d个学生的姓名和成绩:", i + 1); scanf("%s %d", newnode->name, &(newnode->score)); newnode->next = NULL; if (*pphead == NULL) { *pphead = newnode; } else { Student* tail = *pphead; while (tail->next != NULL) { tail = tail->next; } tail->next = newnode; } } }

这段代码里每次尾插都要从头遍历到尾部，时间复杂度是 O(n^2)。虽然学生数量少问题不大，但可以优化：额外维护一个 tail 指针，每次直接接在新节点后面，使建表变成 O(n)。我在正式版代码中通常用后一种写法：

Student* tail = NULL; for (int i = 0; i < n; i++) { // 创建 newnode if (tail == NULL) { *pphead = newnode; tail = newnode; } else { tail->next = newnode; tail = newnode; } }

初学时对 tail 指针容易犯迷糊，其实核心思想就是始终记录“当前链表最后一个节点”，下次插入时直接接上，不需要重新遍历。

6.3 按成绩降序排序：选择排序思想

单链表排序可以在不改动 next 结构的情况下通过交换节点里的数据实现。虽然这种方式不优雅，但初阶更好理解。我用选择排序思想：第一次从头到尾找到最大成绩节点，把它和头节点数据交换；第二次从第二个节点开始找最大，和第二个节点交换；循环下去。

void SortList(Student** pphead) { if (*pphead == NULL) return; Student* cur = *pphead; while (cur != NULL) { Student* maxNode = cur; Student* p = cur->next; while (p != NULL) { if (p->score > maxNode->score) maxNode = p; p = p->next; } // 交换 cur 和 maxNode 的 name 和 score if (maxNode != cur) { char tmpName[32]; strcpy(tmpName, cur->name); strcpy(cur->name, maxNode->name); strcpy(maxNode->name, tmpName); int tmpScore = cur->score; cur->score = maxNode->score; maxNode->score = tmpScore; } cur = cur->next; } }

交换数据而不是交换节点，好处是逻辑简单、不容易丢链接；坏处是如果节点 data 很大（比如巨大的结构体），数据拷贝成本高。在初阶笔记阶段，交换数据完全可以接受，而且这种写法对理解选择排序也很有帮助。

如果想通过调整指针完成排序，思路就变成“每轮找到最大节点”，然后把它摘下来插到已排序区域的末尾。这种实现更接近链表式插入排序，但代码复杂度更高，建议学有余力再挑战。

6.4 删除不及格学生：注意头节点特判

删除低于 60 分的学生，需要同时考虑头节点是否要删：

void DeleteFail(Student** pphead, int passScore) { while (*pphead != NULL && (*pphead)->score < passScore) { Student* del = *pphead; *pphead = (*pphead)->next; free(del); del = NULL; } if (*pphead == NULL) return; Student* cur = *pphead; while (cur->next != NULL) { if (cur->next->score < passScore) { Student* del = cur->next; cur->next = del->next; free(del); del = NULL; } else { cur = cur->next; } } }

这个函数的难点在于，删除当前节点的下一个节点之后，cur 不应该向后移动，因为新的 cur->next 还要继续检查是否也需要删除。很多人会漏掉这一点，导致跳过一个需要删除的节点。我在实际调试中反复出现这种问题后，养成了一个习惯：只有在“没有删除操作”的情况下，当前遍历指针才往后滑。

6.5 销毁链表：防止内存泄漏

void DestroyList(Student** pphead) { Student* cur = *pphead; while (cur != NULL) { Student* next = cur->next; free(cur); cur = next; } *pphead = NULL; }

这里一定要先把 cur->next 保存下来，再 free(cur)，否则 free 之后再去访问 cur->next 就是悬垂指针访问。这个错误很隐蔽，程序可能碰巧不崩溃，但这是未定义行为。我建议大家在调试内存问题的时候打开内存检测工具，或者至少运行时多看几遍逻辑。

7. 常见问题与排查技巧实录

7.1 为什么链表只能输出一个节点？

最常见的原因是创建节点时没有让新节点链接到链表上。比如尾插法只在循环里创建节点，却忘了把 tail->next 指向新节点。排查方法是打印头指针地址和第一个节点的 next 地址，观察节点数目是否增长。

还有一种情况是头插法写成了newnode->next = *pplist，但函数接收的只是一级指针，结果修改没有回写原来头指针。排查时可以用调试器查看函数调用前后 main 函数中 head 的值。

7.2 为什么删除节点后链表断链？

删除节点的下一节点时，正确写法是：

del = cur->next; cur->next = del->next; free(del);

如果写成cur = del->next，则当前遍历指针前进到被删节点后一个节点，但链表中的前一个节点仍然指向 del，链表就断开了。这是单链表删除中特别典型的错误。

所以我在删除操作中有一个习惯动作：先问自己“现在还有没有指针指向被删除节点的前驱？没有的话就无法修改它的 next”。单链表删除永远要把前驱节点暴露出来。

7.3 什么时候该用二级指针？

只要函数内部可能让外部传入的头指针指向另一个节点，就需要二级指针。头插、头删、销毁链表，都会修改头指针本身，必须传二级指针。单纯遍历并打印、查找某个值，不需要修改头指针，传一级指针即可。

有一个例外值得注意：即使只是删除头节点的下一个节点，头指针本身不变，也可以传一级指针。但为了接口统一，很多项目干脆全用二级指针，虽然安全但稍显冗余。初阶我建议按“是否会修改头指针”严格区分。

7.4 插入节点顺序到底能不能乱？

创建新节点后，先给 next 赋值再改前驱的 next。如果先把前驱的 next 指向新节点，就把原来后面的节点弄丢了。比如：

newnode->next = cur->next; cur->next = newnode;

这个顺序不能反过来。虽然初学时觉得“先连后面，再改前驱”是顺口溜，但它背后有严格的指针逻辑：cur->next 是链表的桥梁，一旦改了，原来的后继就访问不到了，必须先让新节点保存它，才能安全替换。

7.5 链表的内存泄漏怎么排查

写链表应用最容易出现内存泄漏：创建节点时 malloc，但删除或销毁时漏了 free。初阶项目里，我建议每次写完销毁接口后，手动画一个节点分配和释放的对应表，数一数 malloc 了几次，free 了几次，是否匹配。

更高效率的办法是借助内存检测工具，在调试版本里观察程序退出时是否有内存泄漏报告。但不管工具多好用，逻辑上明白“谁分配，谁释放，分配与释放次数对等”才是根本。

8. 单链表应用的进阶扩展方向

学完上面这些案例，单链表的初阶应用基本覆盖了：链式栈、多项式、字符串链表、学生成绩管理、图邻接表。继续往前走，可以考虑几个进阶方向。

第一个是双向链表和循环链表。单链表只能向后走，双向链表每个节点多一个 prev 指针，删除指定节点时不需要再找前驱，所以删除操作更灵活。循环链表则是最后一个节点又指向头节点，适合循环队列、约瑟夫环这类问题。约瑟夫环如果用单循环链表实现，代码很有意思，建议自己写一遍。

第二个是链表与哈希表的结合。哈希表处理冲突常用拉链法，也就是桶下挂链表。这里链表只用来管理同一个哈希桶内的多个元素，冲突少时链表很短，性能不错；冲突严重时可以考虑把链表换成红黑树，但那是高级话题。

第三个是链表排序的进阶。初阶用交换数据的选择排序没问题，但真正考察链表操作时，更推荐用归并排序。链表归并排序不需要额外数组，只需递归地把链表切分成两半，然后合并，时间复杂度稳定在 O(n log n)。这个实现既检验链表基本功，也检验递归理解，是面试中一道经典题目。

9. 个人实操总结与建议

做了这么多链表练习，我最深的体会是：学链表不是靠看，而是靠动手画和动手写。画链表的时候，我建议在每个节点标注地址变量，用箭头把 next 指出来。插入操作只需要问自己：在改变某条箭头之前，还有没有别的方法能访问到旧的箭头目标？如果只有一条路径，就一定要先建立临时指针或者先让新节点指过去。

另外，强烈建议所有链表操作都配上打印函数。每次操作完都调用打印，观察结果是否符合预期。这样比单纯用调试器断点更快。

初阶阶段，可以只掌握头插、尾插、指定位置插入、头删、尾删、查找、销毁这七个基础操作，然后把它们反复用于不同场景。后面的项目里遇到链表问题时，先尝试用这七个操作组合，而不是一上来就写复杂的指针逻辑。等基础打牢了，再去挑战指针反转、区间反转这类更刁钻的题目。

单链表看似简单，但它背后涵盖的指针思维、内存管理、防御式编程习惯，会渗透到后续所有数据结构的学习中。把这部分练扎实，后面二叉树、哈希表、图这些复杂结构都会顺畅很多。我每次带新一届同学时都会说一句话：宁可花一周把链表练透，也不要赶进度留下模糊地带，因为指针这种东西，绕不绕得过去，后面代码一眼就能看出来。