最近在帮人讲数据结构，发现链表这个概念真是两极分化：懂的人觉得它特别简单，不就是指针指来指去；不懂的人看代码就像看天书，尤其是那种带了prev又带next的节点，彻底懵圈。我这次手写了一版单链表和双向链表的模拟实现，把增删查改、反转、合并这些常见操作全过了一遍，踩了几个坑，也总结了一些自己的理解方式。这篇文章想把“链表到底是怎么被模拟出来的”这件事讲透，顺便把我在调代码过程中遇到的典型问题、排查的套路都整理出来，给正准备啃数据结构的同学一份可以直接抄的参考。
1. 先把思路理顺：为什么单链表和双向链表要分开说
1.1 单链表的核心逻辑就一句话：拿空间换时间
单链表的核心其实不难，它就是一个结构体节点，每个节点里面存了两样东西：data（数据域）和next（指针域）。data可以是整数、字符串，甚至是一个更复杂的结构体；next保存的是下一个节点的地址。通过这种方式，数据不再像数组那样必须连续存放，而是散在内存各处，靠指针串起来。
这么一来，插入和删除就变得很便宜了。数组插入中间位置，得把后面所有元素都往后挪，时间复杂度 O(n)；而在单链表里插入，只需要改两个指针，时间复杂度 O(1)。这就是我说的“拿空间换时间”——每个节点都额外卖一个指针的内存，换来的是插入删除的高效率。
但是，单链表有个天生的缺陷：只知道往后走，不知道回头。想找某个节点的前驱节点，你得从头再遍历一遍。这个痛点，正是双向链表存在的理由。
1.2 双向链表多一个 prev，却解决了大问题
双向链表在单链表的基础上，给每个节点多加了一个指针prev，指向它的前驱节点。看起来只是多了一个指针，但它带来的变化是质的：从前向后、从后向前都可以遍历，找前驱节点再也不用 O(n) 了。
举个例子，如果你要在双向链表里删除某个节点，只要拿到了这个节点的地址，直接通过prev找到它的前一个节点，然后改两对指针就完成了。而在单链表里，你删节点必须从头遍历，找到目标节点的前驱才能操作。所以很多对性能敏感的场景，比如 LRU 缓存淘汰算法、浏览器的前进后退历史，用的都是双向链表。
不过要注意，双向链表的每一个操作都更复杂了：插入和删除时要处理的指针个数从“1 个”变成了“2 个”，漏改任何一条指针，都可能导致链表断链或者成环。这也是很多初学者写双向链表时容易崩溃的地方。
1.3 模拟实现到底是什么跟直接写代码有什么区别
这里必须解释一下“模拟实现”这四个字。模拟实现的意思是：不用语言内置的现成链表结构，而是自己定义节点结构体，手动管理指针关系，模拟底层内存中链表的工作方式。比如在 Java 里用LinkedList类那是调用现成的，而模拟实现是你自己写一个Node类，自己写insert、delete、reverse这些方法。
为什么要做模拟实现？因为数据结构的核心是“结构”两个字，只有亲手把指针搭起来、打断掉、再搭起来，你才能真正理解链表的工作原理。用现成的类，你只知道“调一下方法就好了”，底层发生了什么一概不知，面试的时候一问细节就露馅。
我的做法是这样的：用 C 语言写核心逻辑，用 Node 加 next 加 prev 三段式节点定义，配以malloc和free手动管理内存。这样最贴近底层，最能模拟出真实的“指针世界”。也可以顺手在 Python 里写，用类模拟节点，不过 C 语言写起来更有那种血肉感，所以我选择用 C 语言作为主讲解语言。
2. 核心细节拆解：节点定义、插入设计、删除设计
2.1 节点该定义成什么样，多两个字段又怎么算
单链表的节点定义很简单，C 语言代码如下：
typedef struct Node { int data; struct Node* next; } Node;双向链表在此基础上多了一个prev指针：
typedef struct DNode { int data; struct DNode* prev; struct DNode* next; } DNode;说个小细节：每个节点里的data类型我用了int方便演示。实际上，真正在工程里，这里的data可以是一个void*指针，指到任意类型的数据，也可以是一个结构体。这时候整个链表就灵活了，你在节点里存一个Student结构体、存一个图片路径字符串、甚至存一个函数指针，都没问题。
比较关键的还有头节点的使用。很多人习惯加一个head节点作为哨兵（dummy node），真正存放数据从head->next开始。这个做法有两个好处：第一，插入和删除不需要对头节点做特殊判断；第二，链表为空时也永远有一个节点存在，操作逻辑统一。我在模拟实现中就用的是带头节点的写法，能省掉很多边界判断的烦恼。
2.2 单链表插入的三个场景：头插、尾插、中间插
单链表插入最核心的动作，一句话概括就是：先连接右边，再连接左边。这个顺序是铁律。
假设要在节点prev_node后面插入一个新节点new_node，正确的做法是：
new_node->next = prev_node->next; // 先把新节点指向原来的后继 prev_node->next = new_node; // 再让前驱节点指向新节点为什么必须先更新新节点的next，再更新前驱节点的next？因为如果先改写prev_node->next，原来的后继节点地址就丢了，你再也找不到它了，链表就直接断掉了。这个细节看似简单，却是我见过最多人写错的地方。
处理头插法的时候，因为用了带头节点的结构，逻辑没有任何变化，只是在head节点后面插而已。尾插法则是先遍历到最后一个节点，再挂在它后面。中间插入和尾插的核心逻辑一致，只是需要你通过遍历，找到合适的位置。
我写了个统一的插入函数：
void insertAfter(Node* prev_node, int data) { if (prev_node == NULL) { return; } Node* new_node = (Node*)malloc(sizeof(Node)); new_node->data = data; new_node->next = prev_node->next; prev_node->next = new_node; }2.3 双向链表插入的细节：四条指针顺序的多与少
双向链表插入，因为多了一个prev指针，处理的指针关系从两条变成了四条。看代码：
void dInsertAfter(DNode* prev_node, int data) { if (prev_node == NULL) return; DNode* new_node = (DNode*)malloc(sizeof(DNode)); new_node->data = data; new_node->prev = prev_node; new_node->next = prev_node->next; if (prev_node->next != NULL) { prev_node->next->prev = new_node; } prev_node->next = new_node; }注意看最后几行：我先把新节点的 prev 和 next 都设置好，然后才修改老节点的指针。尤其要留意第 12 行，prev_node->next->prev = new_node这行是在处理原来后继节点的回指指针，这一步很容易漏掉。如果是尾插，也就是prev_node->next == NULL时，这行可以跳过，但如果你不管三七二十一直接访问prev_node->next->prev，就会触发空指针异常。所以我每次写双向链表的插入，都会刻意检查prev_node->next是否为NULL，再决定要不要维护回指关系。
2.4 删除操作的注意点：内存释放与指针置空
删除操作的核心是：先绕过要删除的节点，再释放它的内存。别看这句话简单，实际写起来有不少坑。
单链表删除指定节点的后继：
void deleteNext(Node* prev_node) { if (prev_node == NULL || prev_node->next == NULL) return; Node* temp = prev_node->next; prev_node->next = temp->next; free(temp); }注意有一个关键点：我把要删除的节点地址先存在temp里，让前驱节点直接指向“孙节点”，然后再释放temp。如果你先free(temp)再改指针，那就变成了访问已释放内存，属于未定义行为，直接查不到问题。
双向链表的删除则要讲究顺序，因为要维护两条链的关系：
void dDeleteNode(DNode* node) { if (node == NULL) return; if (node->prev != NULL) node->prev->next = node->next; if (node->next != NULL) node->next->prev = node->prev; free(node); }这里我用的是“拿到目标节点本体 -> 修改前后节点指针 -> 释放自己”的思路。如果你只在单链表里会做删除，在双向链表里就要特别注意：当删除的是头节点时，node->prev == NULL，你不能去访问它的前驱；当删除的是尾节点时，node->next == NULL，同理。这种边界判断不做，运行起来准崩。
3. 实战环节：从头到尾实现一遍两个链表的增删改查
3.1 环境准备和启动代码
我使用的是纯 C 环境，编译器用的就是 GCC，没有引入任何第三方库。你不需要什么花哨的 IDE，一个文本编辑器加一个终端就行。我平时用 VSCode 写代码，终端里直接gcc linkedlist.c -o linkedlist && ./linkedlist就能跑起来。
为了演示方便，我把所有代码都放在一个源文件里。最大的好处是学习者打开就能跑、断点调试也方便。你也可以拆成list.h、list.c、main.c三个文件，工程上更规范，但学习阶段一个文件反而看得更明白。
我先定义一个头文件风格的结构：
#include <stdio.h> #include <stdlib.h>然后用前面写的节点定义建立两个链表。我会先在main函数里初始化带头节点的空链表，然后依次调用插入、删除、打印、反转等函数，每一步都打印出链表的现状，方便观察指针关系的变化。
3.2 单链表完整实现：创建、插入、遍历、反转
先看完整的单链表模拟代码，我分函数写。首先是初始化：
Node* initList() { Node* head = (Node*)malloc(sizeof(Node)); head->next = NULL; head->data = 0; return head; }这个头节点的数据域我用 0 占位，实际上它的数据域往往不用，更严谨的写法是给头节点也分配一个有效数据，但在模拟场景里无所谓。关键只是head->next指向真正的第一个元素。
遍历打印链表，最简单直接：
void printList(Node* head) { Node* current = head->next; while (current != NULL) { printf("%d -> ", current->data); current = current->next; } printf("NULL\n"); }你要记住current = current->next这行是在做“前进”操作，每次循环都把自己切换到下一个节点。有些人会在这个循环里写死循环，多半就是忘了在循环体末尾更新current。
单链表的反转，我选择了迭代反转法。它的核心图解是：不断把当前节点的next指向前一个节点，然后向右滑动：
Node* reverseList(Node* head) { Node* prev = NULL; Node* current = head->next; while (current != NULL) { Node* nextNode = current->next; // 先保存后继 current->next = prev; // 反向指 prev = current; // 前驱向前走 current = nextNode; // 当前节点向前走 } head->next = prev; // 头节点指向新的第一个 return head; }这段代码我有必要强调一行：Node* nextNode = current->next;这一行绝对要放在修改current->next之前。如果不保存，一旦你执行current->next = prev，原来的后继就找不到了，后面的链表全丢。我自己刚学的时候，就看到有人把这一行放在后面，结果整个链表变成只有一个节点，数据全没了。
归并两个有序单链表也值得写一下。逻辑是用两个指针分别指向两个链表的当前节点，谁小就接谁，然后移动那个指针：
Node* mergeLists(Node* headA, Node* headB) { Node dummy; Node* tail = &dummy; Node* a = headA->next; Node* b = headB->next; while (a != NULL && b != NULL) { if (a->data <= b->data) { tail->next = a; a = a->next; } else { tail->next = b; b = b->next; } tail = tail->next; } tail->next = (a != NULL) ? a : b; return dummy.next; }这里有个小技巧：我在栈上定义了临时头节点dummy，利用它来简化插入过程，这样就不用为人参出口而额外判断“谁先成为新链的头”了。
3.3 双向链表完整实现：创建、前插、后插、删除、遍历
双向链表每个函数的复杂度都比单链表高一层，因为双链的两个方向都要维护。
初始化一个带头节点的双向链表：
DNode* initDList() { DNode* head = (DNode*)malloc(sizeof(DNode)); head->prev = NULL; head->next = NULL; head->data = 0; return head; }前插法（在头节点之后插入）：
void dInsertFirst(DNode* head, int data) { DNode* new_node = (DNode*)malloc(sizeof(DNode)); new_node->data = data; new_node->prev = head; new_node->next = head->next; if (head->next != NULL) { head->next->prev = new_node; } head->next = new_node; }别把顺序搞乱。我先让新节点和头节点建立关系，然后才改动原来第一个节点的prev指针。这一步错了，双向链表就会变成单向链表甚至断链。
尾插法，必须遍历到链表最后一个节点：
void dInsertLast(DNode* head, int data) { DNode* cur = head; while (cur->next != NULL) { cur = cur->next; } DNode* new_node = (DNode*)malloc(sizeof(DNode)); new_node->data = data; new_node->prev = cur; new_node->next = NULL; cur->next = new_node; }双向链表的打印，我习惯正反都打一遍。正向遍历用next，逆向遍历从尾节点开始用prev走回去：
void dPrintForward(DNode* head) { DNode* cur = head->next; while (cur != NULL) { printf("%d <-> ", cur->data); cur = cur->next; } printf("NULL\n"); } void dPrintBackward(DNode* head) { DNode* cur = head; while (cur->next != NULL) { cur = cur->next; } while (cur->prev != NULL) { printf("%d <-> ", cur->data); cur = cur->prev; } printf("NULL\n"); }通过这两个打印函数，你可以直观地验证双向链表的两个方向是否都正确连通。如果发现正向打印对、反向打印却少了节点，多半就是prev指针在某个插入操作里没维护好。
删除一个指定值的节点：
void dDeleteByValue(DNode* head, int value) { DNode* cur = head->next; while (cur != NULL) { if (cur->data == value) { DNode* toDelete = cur; if (cur->prev != NULL) cur->prev->next = cur->next; if (cur->next != NULL) cur->next->prev = cur->prev; cur = cur->next; free(toDelete); return; } cur = cur->next; } }这里注意一个小陷阱：在释放toDelete之前，我已经把cur指向了cur->next，这样我才能继续遍历，否则你释放了cur再访问cur->next就是非法访问了。我是先保存后续遍历位置，再更新前后节点的指针，最后free，这个顺序堪称经典。
3.4 写完代码立马测试：几个关键用例
我在写代码的时候会刻意准备几组测试用例，覆盖各种边界场景：
- 空链表插入第一个元素。
- 在头部插入、尾部插入、中间插入若干元素。
- 删除头节点、删除尾节点、删除不存在的节点。
- 反转单链表后，元素顺序是否完全颠倒。
- 双向链表正向与反向打印是否一致。
写测试时最关键的一点是每次都从空链表开始重跑，不要在一个已有数据的链表上叠加测试。这样才能确定每个函数在边界条件下的行为是否正确。还有一个建议就是打印到屏幕上的每一步都跟自己手动在纸上画出来的链表图对照，我看代码十遍，不如在纸上画一遍指针连线来得清楚。
4. 常见问题与排查技巧实录：这份避坑手册我先放这
4.1 空指针和野指针是万恶之源
链表模拟中对空指针的访问，是运行时崩溃的主要来源。常见的场景有三类：
第一，删除节点时没有检查next是否为 NULL，直接访问cur->next->prev。这在双向链表尾删时尤其致命。
第二，free 之后再访问已经释放的区域。比如有人先把free(cur)写在前面，然后再cur = cur->next，这在 C 语言里就是未定义行为，程序可能时好时坏，极难排查。
第三，局部变量地址被暴露到链表里。有时候有人图省事，直接用Node temp;这种栈上变量作为新节点插入链表，结果函数一返回，temp就出栈了，链表里挂着一个指向失效栈空间的指针，后续访问时数据全是随机值。这个坑我见过好多次，解决方式永远是malloc分配到堆上。
我排查这类问题，最常用的手段是加打印日志。在每个函数的入口和出口分别打印“进入/退出”，再在每个节点插入删除后打印整个链表。如果哪个函数入口正常、出口链表状态不对，问题就锁定在那个函数内部了。配合调试器断点看指针值也是好办法，但在学习阶段，我觉得手写日志更直观。
4.2 断链与成环：如何快速发现链表结构坏了
链表断链的表现有很多：遍历时提前遇到 NULL，后半段数据丢失；或者遍历时走进了死循环，因为某个节点的next指回了之前的节点，形成了环。
排查断链问题，我先会检查每个节点是否只有一条有效的 “被前驱指向” 和 “指向后继” 的关系。对于单链表，我从头开始每个节点向前推进，并在纸上画出A -> B -> C的连线，比对实际输出。如果中途断了，说明某个插入或删除函数的指针构建顺序不对。
排查成环，最直观的方法是打印访问过的节点地址，如果某次循环中重复出现同一个地址，基本可以确认成环。快速定位是：在循环里加入“步数计数器”，超过链表长度说明有环。高级一点的可以用快慢指针法，但在学习阶段，暴力加日志已经足够了。
我还喜欢在链表操作后加一个“校验函数”，把我的链表结构从头扫到尾，检查某些关键约束。比如双向链表里每个节点的next->prev是否一定等于这个节点本身。下列代码就是干这个事的：
int dCheck(DNode* head) { DNode* cur = head->next; while (cur != NULL && cur->next != NULL) { if (cur->next->prev != cur) { printf("结构错误：节点地址差异\n"); return 0; } cur = cur->next; } return 1; }很多乍一看难以理解的 bug，靠这种校验函数可以一秒钟定位出来，这是我特别想推荐给大家的“自检习惯”。
4.3 搞清楚什么时候该用单链表，什么时候该用双向链表
很多初学者会问：既然双向链表功能更强大，为什么还要学单链表？这里有一个非常实际的原因：内存开销和应用场景。
每个双向链表节点比单链表多了一个prev指针，这在数据量大时是很大一笔额外开销。假如一个指针是 8 字节，100 万个节点就多出 8MB 内存，这在嵌入式等资源受限环境里不可接受。所以当你只需要从头到尾顺序访问时，用单链表就够了。
单链表常见的生产场景是：哈希表里的链地址法解决哈希冲突、图的邻接表、文件系统的索引块链。双向链表则常见于：内存页面置换的 LRU 算法、浏览器前进后退栈、操作系统的任务队列调度等场景。
遇到一个新需求，我判断用单还是双，首先看一个问题：“我是否需要从后往前找前驱？”如果你的答案是不需要，那就单链表；如果需要，就双向链表。不要为了炫技而给没必要的场景加复杂结构，能简单就简单。
4.4 内存管理这件事，C 语言里必须做到位
写 C 语言链表，malloc和free必须配对出现。每个malloc都要有一个对应的free，不然就会内存泄漏。用工具检测内存泄漏是很好的习惯，在 Linux 下我习惯用 Valgrind 检查，一条命令就能告诉你哪一行分配的内存没有被释放。
避免内存泄漏的另一个技巧是封装释放函数，统一入口释放整个链表。例如：
void destroyList(Node* head) { Node* cur = head->next; while (cur != NULL) { Node* temp = cur; cur = cur->next; free(temp); } free(head); }这段代码有一个细节值得反复咀嚼：temp = cur与cur = cur->next的顺序。如果先free(cur)再取cur->next，就是前面说的野指针访问——看起来偶尔也能跑出正确结果，但本质上是在悬崖边试探。正确写法是先用temp保存要释放的节点，同时让遍历指针先跳到下一个节点，再回头释放temp。
注意：写链表代码时，free 之后建议立刻把指针置为 NULL。虽然这不是必须的，但能让你后续不小心使用这个指针时第一时间发现问题，而不是等到程序崩溃后靠调试器慢慢找。
5. 双向链表的独特操作与我的经验补充
5.1 双向链表的逆序遍历：一行代码就能完成，但别忽略边界
双向链表逆序遍历的思路很简单：从尾节点开始，不停往prev跳。但需要警惕的是头节点的 prev 是 NULL 的问题。如果你直接从某个节点开始逆序走，走到 NULL 时就该停下来，否则空指针访问随之而至。
写逆序遍历时，我的习惯是先找到最后一个节点，然后用while (cur->prev != NULL)作为循环条件，这样就能安全地把每个有效节点都访问一遍。有的同学会用while (cur != NULL)，那样循环会走进头节点，然后通过头节点的prev访问非法内存。这个边界差之毫厘谬以千里。
5.2 在双向链表中做“删除当前节点”的操作，比单链表舒服太多
单链表删除当前节点时，由于不知道前驱，必须从头遍历，这是它的硬伤。而在双向链表中，只要给你一个节点的指针，你直接就能操作：
void dDeleteNodeDirect(DNode* node) { if (node == NULL) return; if (node->prev != NULL) { node->prev->next = node->next; } if (node->next != NULL) { node->next->prev = node->prev; } free(node); }这里有一个使用场景特别贴切：Josephus 环（约瑟夫问题）。如果用单链表，每次数到第 k 个人时都需要从头重新找前驱；用双向链表，你只需要在环上移动，然后直接删除当前节点。性能上差距十分明显。这也是我为什么总强调“选对数据结构比写对代码更重要”。
5.3 双向链表和单链表互换的陷阱：方向一定别搞反
双向链表反转，很多人第一反应是直接交换prev和next，然后头尾互换。写出来大概是三段式：遍历每个节点，交换cur->next和cur->prev，然后把head指向原来的尾节点。这个思路没什么问题，但在实现时有一些容易翻车的细节，比如你在交换指针之后如果用cur = cur->next前进，就会走进已经交换过的节点导致死循环。正确做法是：
DNode* dReverse(DNode* head) { DNode* current = head->next; DNode* temp = NULL; while (current != NULL) { temp = current->prev; current->prev = current->next; current->next = temp; current = current->prev; // 注意：因为已经交换，下一个实际是之前的 next } if (temp != NULL) { head->next = temp->prev; } return head; }这里最反直觉的地方，就是最后一行换成current->prev来前进。之所以要用它，是因为此时节点的prev和next已经交换了，原来的后继变成了现在的前驱。如果你还按惯性思维current = current->next，那就会掉进死循环。这种“交换后就以新方向前进”的思路，不亲自动手写一遍很容易晕。
5.4 实战扩展：LRU 缓存的雏形可以这么搭
模拟实现链表不是为了应付作业，它完全可以对接一个真实项目。最经典的就是 LRU 缓存淘汰算法。LRU 的核心思想是：最近被访问的数据保留，最久没被访问的数据优先淘汰。这个场景正好完美契合双向链表加哈希表的组合。
具体来说，哈希表负责 O(1) 查找节点地址，双向链表负责维护访问顺序。每当访问一个数据，如果命中，就把对应节点移到链表头部；如果未命中，且缓存已满，就先删除链表尾部的节点，再把新数据插到头部。
我用自己实现的双向链表分分钟搭出这个雏形。核心代码并不复杂，但你会立刻意识到：双向链表的头插、尾删、任意节点摘除，这三个操作在 LRU 里缺一不可，单链表做起来会非常别扭。通过这种扩展，我才真正理解“双向链表不只是单链表加一个指针，它是一种改变算法复杂度的数据结构”。
6. 踩坑实录：把每次调试当教材，才能越写越稳
6.1 我第一次写双向链表时，连续崩溃了三个小时的原因
这个场景我一直记着。那是刚开始写双向链表尾插法的时候，我写完代码一运行，第一次插入正常，第二次插入就崩溃了。当时排查了很久，最后发现问题出在第一次插入时，头节点的 next 原本为 NULL，我没有维护新节点的 prev 对头节点的回指。换句话说，我第一次插入时构造的节点prev指到了空的head->prev上，第二次插入时前驱节点就找错了对象。
这个教训教会我一件事：第一次插入永远是最重要的边界场景。现在每次写双向链表的插入，我都会先自言自语地过一遍：如果链表当前为空，该怎么做；如果当前只有一个节点，又该怎么做。把这些边界提前在草稿纸上演算出来，再落到代码里，就会稳很多。
6.2 反转链表时变量顺序搞反，输出结果居然是空的
还有一回，我写单链表反转，把current = nextNode写成了current = current->next。在第一次循环里，此时current->next已经被改成prev（通常为 NULL），于是当前节点原地踏步，后面节点全丢了，整个链表直接变成只有一个节点。那次我把代码贴到群里问人，对方一眼就指出了问题：改指针之前先把下一步要去的地址存下来。这成了我根深蒂固的肌肉记忆，现在看到任何先改指针再往前走一步的代码，都会下意识觉得危险。
6.3 判断链表是否为空，到底是用 head 还是 head->next
重新复习一个看似简单但特别迷惑的点：带头节点的链表，判断“链表是否为空”应该看head->next == NULL，而不是head == NULL。因为head本身就是哨兵节点，它永远存在，就算链表里没有有效数据，它也不为空。这导致不少人初期把if (head == NULL)当成空判断，结果链表里没有任何数据时程序却认为它非空，白白走一趟遍历打印出个寂寞。
如果你不带头节点，那判断空就是head == NULL。两种方案各有各的逻辑，但你一定要固定用一种，并且贯穿所有函数。我最怕看到的就是一个工程里，一半函数按带头节点写，一半按不带头节点写，拼起来就乱了。
6.4 一个小而美的辅助函数：让链表代码调试效率翻倍
前面提到了校验函数，这里我再补充一个辅助函数：计算链表长度。别小看这个函数，它虽然只有几行代码，但调试时配合一个长度总和与遍历数不匹配的报错，能快速判断链表从哪里断了。
int listLength(Node* head) { int count = 0; Node* current = head->next; while (current != NULL) { count++; current = current->next; } return count; }我每次写完插入删除函数，都顺手跑一下长度和遍历输出。比如插入 5 个节点，打印长度应为 5，遍历输出应为 5 个数据。如果输出只有 4 个，就说明某个插入的指针连接断了；如果长度对但输出顺序错乱，说明某个next接到了错误位置。把简单的辅助函数组合成一套自动检查流程，是链表调试里最划算的投资。
7. 工程视角下的补充：不只是模拟实现，更是理解数据结构的起点
许多人不理解为什么学习链表要如此详细地模拟底层。我的观点是：链表是所有动态数据结构的地基。树、图、跳表、邻接表这些高级结构，本质上都是链表的变体或者扩展。二叉树也可以理解为“每个节点有左右两条链的链表”，图则可以理解为“多个链表的集合”。如果你把单链表和双向链表的指针操作真正搞懂了，后面的树和图的代码就不那么可怖了。
比如在学习二叉树时，你会经常听到“递归插入节点”这个概念，其实它跟链表插入节点是一脉相承的：都是新节点的指针指到某个位置，再把父节点指针指向新节点。唯一的区别只是二叉树的“后继”有两个方向（左和右）。一旦在链表里建立了这种“把节点搭进既有结构”的思维模型，树和图的遍历、插入、删除写起来都会丝滑很多。
在工程实践中，虽然很多高级语言已经封装好了现成的链表类，比如 Java 的LinkedList、Python 的list、C++ 的std::list，但我依然建议你先自己去模拟实现一遍底层。你调一个封装的链表类，出了问题只会怪文档；你调一个自己写的链表模拟实现，出了问题就是一次真正的能力成长。这种“亲手制造并使用工具”的过程，才是数据结构学习中最有营养的部分。
最后说一个我在实操里总结的小习惯：学链表时不要沉迷于各种花哨算法，先把最基础的创建、插入、删除、遍历这四个操作练到闭着眼睛都能写对，再去看反转、合并、环形链表这些进阶操作。基础不牢靠时，每次花哨操作的 bug 都是底层指针逻辑在作祟，而不是算法思想本身有问题。先把地基砌稳，后面的楼想盖多高都不怕。
