很多人学链表时都有一种感觉：上课听懂了，课后一写就懵。明明代码不长，但一运行就出错，不是空指针就是死循环，改了半天还不知道问题出在哪。这个情况我在带新人、帮同学调试时见得太多了。链表看起来简单，本质却是一连串指针操作加上边界条件的组合，任何一个细节没想清楚，写出来的代码就是错的。这篇文章我打算把链表系统性地拆一遍，从数据结构本质、核心操作、手写实现到常见排查技巧，尽量讲透，让不同基础的读者都能用得上。
这篇文章适合三类人：刚学完指针和结构体、想真正掌握链表的初学者；准备面试笔试、需要快速把链表操作练扎实的同学；以及工作中偶尔要手写数据结构的开发者。不论你是哪种情况，只要愿意动手把代码敲一遍，这篇文章的内容基本够用了。
1. 为什么说链表值得一次系统的学习
很多教材把链表和数组放在一起对比，上来就讲时间复杂度，其实这个对比才是理解链表价值的钥匙。数组在内存里是一段连续空间，通过下标访问元素，时间复杂度是 O(1)；链表则是把节点分散在内存各处，通过指针把节点串起来，访问某个节点必须从头开始顺着指针走。这个差异决定了它们各自适合什么场景。
1.1 链表的本质：用指针串起来的数据结构
链表的节点结构很简单：一个数据域，一个指针域。数据域存实际内容，指针域存下一个节点的地址。用代码表示就是：
typedef struct Node { int data; // 数据域 struct Node *next; // 指针域，指向下一个节点 } Node;就这么一段结构体定义，就是链表的全部基础。整条链表就是由无数个这样的节点通过 next 指针依次连接而成。最后一个节点的 next 指向 NULL，表示链表结束。
你可以把链表想象成一列火车：每节车厢装着自己的货物（数据），车厢之间有挂钩（指针），火车头是整个链表的入口，通常用一个头指针 head 来记录。一旦挂钩脱落，后面的车厢就全找不到了。这个类比虽然朴素，却非常准确——链表的很多问题，本质上都是"挂钩"没挂对，导致节点丢失或者访问了错误的内存。
1.2 为什么实际项目里仍然离不开链表
有人会问：现在的高级语言里数组、动态数组那么好用，为什么还在用链表？这个问题背后其实是数据结构选型的核心逻辑。
第一个典型场景是频繁插入和删除。数组在中间位置插入一个元素，需要把后续所有元素都后移一位，时间复杂度 O(n)；链表插入一个新节点，只需要修改前后两个节点的指针指向，时间复杂度 O(1)。操作系统里的进程调度队列、内存分配器的空闲块管理，都有大量中间插入和删除操作，这种场景下链表比数组合适得多。
第二个场景是数据量不确定、又需要动态增长。数组扩容通常涉及整块内存的重新分配和拷贝，链表则每来一个新数据就申请一个节点，天然支持动态增长，没有扩容成本。
第三个场景是作为更复杂数据结构的基石。比如图的邻接表、哈希表的链地址法、LRU 缓存、文件系统里的空闲块链表，底层都是链表。你把这一个结构学扎实了，后面理解这些东西会轻松很多。
1.3 链表的三种基本形态与选型
链表在基础形态上有三种变化：单向链表、双向链表、循环链表。
单向链表每个节点只有一个 next 指针，只能从前往后走。双向链表每个节点有 prev 和 next 两个指针，可以双向遍历，但代价是每个节点多出一个指针所占的内存，插入删除时也要多维护一个指针。循环链表则是把尾节点的 next 指向头节点，形成环状结构，常用于轮询调度这种需要循环遍历的场景。
我在实际教学里经常看到有人纠结要不要直接上双向链表。我的建议是：先把单向链表练到闭着眼睛都能写，再去看双向链表。单向链表能把指针操作的核心逻辑搞清楚，双向链表不过是多了一个指针的对称维护，本质没有变化。先把基础打牢，再学变体，效率高得多。
2. 链表的操作到底在操作什么
很多初学者写链表出错，不是因为语法不会，而是没想清楚每一步操作的本质。链表的全部操作，无非就是两件事：改指针指向、处理边界。把这两个问题想透了，链表就算入门了。
2.1 五个核心操作背后的共同规律
链表最核心的操作有五个：遍历、插入、删除、查找、反转。看起来各不相同，其实背后有共同的规律。
先说遍历。遍历就是从头节点开始，用一个临时指针 p 依次指向每个节点，直到 p 为 NULL。这段代码是链表的"呼吸"，几乎所有操作都建立在遍历的基础之上。
void traverse(Node *head) { Node *p = head; while (p != NULL) { printf("%d ", p->data); p = p->next; // 移动到下一个节点 } }这里有一个所有链表操作的黄金法则：在修改某个指针之前，先保存它指向的下一个节点的地址。为什么？因为如果你直接写p = p->next，然后又修改了 p 的 next 指向，原来的下一个节点就找不到了，整条链表就断了。保存地址的目的，就是为了在指针操作之后还能找回原来的路径。
再说插入和删除。头插法、尾插法、中间插入，核心都是三步：新建节点、找准位置、修改前后节点的指针指向。删除则是两步：找到待删节点的前驱节点，让前驱节点的 next 跳过待删节点，直接指向后继节点。难就难在"找准位置"和"处理边界"，头节点、尾节点、空链表、单节点链表，每一种边界情况都得单独考虑。
2.2 头节点和哨兵节点：让代码简单一半的技巧
链表分类里有一对概念特别容易混淆：带头节点的链表和不带头节点的链表。
不带头节点的链表，头指针 head 直接指向第一个数据节点。这样带来的麻烦是：在头部插入或删除节点时，head 本身要重新赋值，代码要单独处理；空链表的判断也特殊，head 为 NULL 就代表空。
带头节点的链表则不一样。它额外有一个 head 节点，这个节点的数据域不存有效数据，next 指向第一个实际节点。这样一来，空链表的判断变成了head->next == NULL，头部插入删除节点时不需要修改 head 本身，统一按照"在某个节点后面插入"的逻辑处理，边界情况大幅减少。
很多人觉得带头节点浪费一个节点，其实这个成本微乎其微，换来的却是代码逻辑的统一和简单。工程实践里我几乎总是推荐使用带头节点的链表，尤其是在做插入删除特别频繁的场景，省掉的分支判断会让人舒服很多。
2.3 链表的时间复杂度：不能只看表面数字
教科书上写链表插入是 O(1)，删除是 O(1)，很多人就以为链表操作一定比数组快。实际上这个 O(1) 是有前提的：你已知要操作的位置。现实里我们通常是按值找节点，找到目标节点的过程本身就是 O(n) 的遍历。
所以更准确的理解是：链表的优势不在于省掉查找，而在于查找完成后，插入和删除本身不需要移动其他元素。这个特性在频繁插入删除、且查找次数相对较少的场景下才真正有优势。比如构建一个只做追加操作的队列，用尾指针维护 tail，每次入队 O(1)，出队 O(1)，这种场景链表比数组合适。但如果你的操作主要是按下标随机访问，链表反而不如数组。
操作类型 数组(动态) 单向链表 按下标访问 O(1) O(n) 头部插入 O(n) O(1) 中间插入(已知位置) O(n) O(1) 尾部插入 O(1)均摊 O(1)需维护尾指针 按值删除 O(n) O(n)这张表我会建议读者自己动手列一遍，比看十遍书都管用。理解了复杂度来源，才能在实际场景里做出合理选型。
3. 手写一遍才算真懂：核心操作的完整实现
我在带人的时候有个硬性要求：链表这段代码必须手写，不能复制，不能看参考。写完之后再对照检查。原因是链表代码很短，但每一步都有隐藏的细节，手写才能让大脑把这些细节过一遍。
3.1 节点定义与初始化
先定义节点结构体，然后写一个创建节点的函数。创建节点的本质就是用 malloc 分配一块内存，把数据写入，再把 next 置为 NULL。
#include <stdio.h> #include <stdlib.h> typedef struct Node { int data; struct Node *next; } Node; // 创建新节点 Node *createNode(int data) { Node *newNode = (Node *)malloc(sizeof(Node)); if (newNode == NULL) { printf("内存分配失败\n"); exit(1); } newNode->data = data; newNode->next = NULL; return newNode; } // 初始化带头节点的空链表 Node *initList() { Node *head = createNode(0); // 头节点数据域不存储有效数据 return head; }注意两点。第一，malloc 的返回值一定要检查。虽然练习代码里通常能分配成功，但实际项目中内存分配失败会导致空指针访问，程序直接崩溃，养成检查的习惯是职业素养。第二，头节点创建时也调用了 createNode，这样默认就把 next 置为 NULL，省得后面忘记初始化。
3.2 头插法与尾插法：建表方式决定链表顺序
头插法是每次把新节点插入到链表最前面，插入顺序和最终链表顺序相反。尾插法是每次把新节点追加到链表末尾，顺序一致。
头插法代码：
void insertAtHead(Node *head, int data) { Node *newNode = createNode(data); newNode->next = head->next; // 新节点指向原来的第一个节点 head->next = newNode; // 头节点指向新节点 }尾插法代码，需要先遍历到最后一个节点：
void insertAtTail(Node *head, int data) { Node *newNode = createNode(data); Node *p = head; while (p->next != NULL) { // 找到最后一个节点 p = p->next; } p->next = newNode; }两个函数的边界情况对比很有意思。头插法完全不需要判断链表是否为空，因为头节点永远存在，head->next即使是 NULL 也照样可以赋值。尾插法也不需要单独判断空链表，因为带头节点的链表至少有一个头节点，循环一定能找到尾部。这就是带头节点的好处，空链表和非空链表用同一套代码。
实操中头插法常用来完成"逆序重构"。比如你按顺序读到 1、2、3，用头插法建表，最终链表顺序是 3、2、1。有些算法题需要逆序输出，就可以顺手用头插法实现，不需要额外反转。
3.3 按位置插入与按值删除：两个最经典的边界考题
按位置插入，比如在第 pos 个位置插入新节点，需要先找到第 pos-1 个节点。这里 pos 从 1 开始计数的话，找前驱节点的循环要尤其小心。
int insertAtPos(Node *head, int pos, int data) { Node *p = head; int i = 0; while (p != NULL && i < pos - 1) { p = p->next; i++; } if (p == NULL) { printf("插入位置无效\n"); return 0; } Node *newNode = createNode(data); newNode->next = p->next; p->next = newNode; return 1; }这段代码的陷阱在于，如果 pos 大于链表长度，循环条件p != NULL会终止循环，此时 p 实际上已经越过了有效范围。所以在插入前必须检查 p 是否为空，否则p->next就是空指针访问。
按值删除，删除第一个值为 data 的节点。核心逻辑是：找到这个节点的前驱节点，然后让前驱的 next 指向待删节点的后继，最后释放待删节点的内存。
int deleteByValue(Node *head, int data) { Node *p = head; while (p->next != NULL && p->next->data != data) { p = p->next; } if (p->next == NULL) { printf("未找到值为 %d 的节点\n", data); return 0; } Node *toDelete = p->next; p->next = toDelete->next; free(toDelete); return 1; }这里有一个新手特别容易犯的错：直接用p = head->next开始查找，找到后想删除时发现没有前驱节点指针。所以删除操作的前驱指针 p 格外重要，遍历条件p->next != NULL保证了 p 始终是待删节点的前驱，这样删除时才能修改前驱的 next。删除完记得 free，这也是很多代码泄漏的根源。
注意：以上代码基于带头节点的链表，所以不需要单独处理"删除的是第一个节点"这种情况。如果你用的是不带头节点的链表，删除头节点时 head 本身需要重新赋值，代码要多一个分支。
3.4 反转链表：指针翻转的经典演示
反转链表是面试里出现概率极高的题目，它完美检验了链表指针操作是否扎实。迭代法的思路是：用三个指针 prev、cur、next，依次把每个节点的 next 指向前一个节点。
Node *reverseList(Node *head) { Node *prev = NULL; Node *cur = head; while (cur != NULL) { Node *next = cur->next; // 先保存下一个节点 cur->next = prev; // 翻转指针 prev = cur; // 前驱前移 cur = next; // 当前节点前移 } return prev; // 循环结束时 prev 是新的头节点 }这段代码的精髓就在Node *next = cur->next;这一行。如果不先保存下一个节点的地址，一旦执行cur->next = prev，原来的下一个节点就再也找不到了，链表后面的部分就丢了。所以"先保存后修改"是链表操作的第一原则。
这个函数返回的是新的头节点，调用方式要小心：head = reverseList(head);，如果你写reverseList(head);而不接收返回值，原来的 head 就变成尾节点了，链表就废了。这是一个典型的、很多人会犯的错。
递归写法也值得掌握，它更短，但理解成本更高：
Node *reverseListRecursive(Node *head) { if (head == NULL || head->next == NULL) { return head; } Node *newHead = reverseListRecursive(head->next); head->next->next = head; head->next = NULL; return newHead; }递归的思路是：先反转当前节点之后的子链表，再把当前节点接到子链表的尾部。理解递归版有助于加深对链表的递归结构的认识，但实际编码我推荐优先用迭代版，空间复杂度更低，也不容易爆栈。
4. 实际写代码时最容易踩的坑
链表代码的 bug 通常不是逻辑复杂，而是几个固定类型的错误反复出现。把这些坑列出来，排查效率会高很多。
4.1 空指针与悬空指针
空指针错误，就是对 NULL 执行了->操作。常见场景是在尾插法里写while (p != NULL)而不是while (p->next != NULL)，结果循环结束后 p 是 NULL，再写p->next = newNode就崩了。
悬空指针错误，是释放了某块内存，但还有指针指向它。比如删除节点后忘了让前驱指向后继，那么这个节点的后继节点就丢失了，整个链表断成两截；再比如 free 之后没有把指针置空，后续复用这个指针就会访问非法内存。我的习惯是：free(toDelete); toDelete = NULL;，宁可多写一行，不给自己留隐患。
排查空指针问题有个很实用的技巧：打印每个指针变量的地址。在关键操作前后加 printf，输出 head、p、p->next 的值，运行一遍基本能定位到具体是哪一步出现了 NULL。比起盯着代码干瞪眼，这招快得多。
4.2 死循环与节点丢失
死循环的经典场景是链表成环了。比如构建循环链表时忘了给尾节点的 next 置 NULL，遍历就会永远走不完。还有一种情况是反转链表时翻转指针的顺序写错，导致链表在原位置打转。
节点丢失的场景通常是插入操作时先执行了p->next = newNode，再执行newNode->next = p->next。这样新节点先挂到了链表上，但新节点的 next 指向的是自己，后续节点全部丢失。正确顺序是先让新节点指向原来的后继，再让前驱指向新节点。
我在调试时习惯准备一个小白板，把链表的节点画成方框，指针画成箭头，每操作一步就改一次箭头。链表本身就是逻辑结构，画图比纯想代码直观得多。即便是在公司做项目，遇到复杂的链表问题，我也会先画图再写代码。
4.3 调试链表的高效技巧
除了画图和打印，还有几个技巧值得分享。
第一，尽量用最小数据集测试。比如测试删除功能，就用 3 个节点的链表测：删头节点、删中间节点、删尾节点、删不存在的值。这四个 case 覆盖了所有边界，跑通基本就没大问题。
第二，写一个打印链表的辅助函数。不要嫌它占代码行数，调试任何链表逻辑时都能用上。比如在反转前后各打印一次链表，一眼就能看出反转是否生效。
void printList(Node *head) { Node *p = head->next; while (p != NULL) { printf("%d -> ", p->data); p = p->next; } printf("NULL\n"); }注意：打印链表内部可以通过循环遍历，但判断链表有没有环时，不能用这种简单遍历——有环的话会死循环。检测环需要用到快慢指针算法，后面会提到。
第三，如果真的崩溃了，用调试器定位崩溃行。现在的调试器都能直接告诉你崩溃在哪个文件哪一行，结合打印出来的指针值，通常很快就能找到问题。不要靠猜，要让数据说话。
4.4 常见问题速查表
我把这几年看到的典型链表 bug 整理成一张速查表，写代码时可以对照自查。
症状 可能原因 解决思路 程序崩溃(空指针访问) 对NULL执行->操作 打印指针定位，检查遍历条件 程序崩溃(段错误) 访问已释放的内存 释放后置NULL，避免悬空指针 死循环 链表成环或遍历条件写错 检测循环终止条件，检查尾节点next 输出节点变少 插入顺序错误导致节点丢失 先连后继再连前驱 输出顺序反了 头插法建表练习时误判 头插法结果和插入顺序相反属正常 无法删除头节点 不带头节点的链表未更新head 改用带头节点或单独处理head这张表不可能覆盖所有问题，但大多数链表代码的问题都能归到这几类。遇到问题时不要急着改代码，先把症状归类，再针对性排查。
5. 从会写到会用的进阶路线
学会了基础操作，只是拿到了链路的入场券。接下来怎么练、怎么往深处走，我分享一套经过验证的路径。
5.1 用"手写 + 变形"建立肌肉记忆
第一步，把上面所有代码手写三遍。第一遍对着文章写，第二遍合上文章默写，第三遍边写边在心里解释每一步为什么这样做。三遍下来，链表的基本操作基本就能形成肌肉记忆。
第二步，做几个经典变种题，用它们来检验自己是否真正理解。
经典题一：判断链表是否有环。用快慢指针，快指针每次走两步，慢指针每次走一步，如果有环，两者必定相遇。
int hasCycle(Node *head) { Node *slow = head; Node *fast = head; while (fast != NULL && fast->next != NULL) { slow = slow->next; fast = fast->next->next; if (slow == fast) { return 1; } } return 0; }这个算法的巧妙之处在于它的前提：快指针必须先检查下一步是否为 NULL，否则一旦 fast 走到最后一个节点，fast->next->next就是空指针访问。很多人写这个算法崩溃，就是没注意这个细节。
经典题二：查找链表中间节点。同样是快慢指针，快指针每次走两步，慢指针每次走一步，快指针到达末尾时，慢指针正好在中间。
经典题三：合并两个有序链表。递归写法很简洁，但工作中我推荐用迭代写法加哨兵节点，逻辑更直观。
Node *mergeTwoLists(Node *l1, Node *l2) { Node dummy; // 哨兵节点，避免判断头节点为空 Node *tail = &dummy; dummy.next = NULL; while (l1 != NULL && l2 != NULL) { if (l1->data <= l2->data) { tail->next = l1; l1 = l1->next; } else { tail->next = l2; l2 = l2->next; } tail = tail->next; } tail->next = (l1 != NULL) ? l1 : l2; return dummy.next; }这里的哨兵节点 dummies（dummy 栈节点）配合尾插法，巧妙地消除了对空链表、头节点的一系列判断。这种"一个哨兵解决一类边界问题"的思路，在以后的算法编码里会反复用到。
5.2 链表之后还能学什么
链表学扎实之后，你可以顺着两个方向继续深入。
一是从链表的变体和扩展出发。基于链表实现栈和队列，本质上就是在链表的某个固定端插入删除；实现 LRU 缓存，就是哈希表加双向链表；实现跳表，就是在链表上增加多层索引。你会发现，这些高级数据结构的底层都离不开指针串接节点的核心思想。
二是从算法技巧出发。快慢指针、双指针、递归反转、迭代合并，这些技巧在数组中同样适用，但链表是理解它们最直观的载体。把链表题练好，再做数组相关题目时，很多思路是可以迁移的。
我个人在实际教学中的体会是：链表最难的其实不是某个具体算法，而是从"用数组的思维看问题"切换到"用指针的思维看问题"。数组的访问模式是下标的算术运算，链表的访问模式是指针的追踪移动。一旦你习惯了这种追踪思维，看到任何链表题都会条件反射地画出节点和箭头，写代码的速度和准确率都会上一个台阶。
最后分享一个我自己的土办法：每次写完链表代码，我都故意把代码里的某个指针操作顺序打乱，然后观察运行结果的变化。比如把头插法里的两行赋值交换，看会不会丢节点；把反转里的 cur 移动放到 prev 移动之前，看会不会死循环。做几次这种"破坏性实验"之后，你对指针操作的时序理解会深刻很多。写链表，稳字当头，永远记得先保存后继、再修改指针。
