链表详解：手写单链表、双向链表、反转与环检测

1. 链表到底是什么：它解决的痛点和被误解的地方

1.1 从数组的痛点引出链表的存在意义

聊链表之前，得先聊清楚数组到底哪里不好用——因为链表这个东西，说白了就是冲着数组的那几个毛病去的。很多教材一上来就甩出“链表是一种物理存储单元上非连续、非顺序的存储结构”，这句话背下来容易，但真没几个人能说清楚它到底解决了什么问题。

数组最大的问题有两个：第一个是插入和删除需要搬移元素。你在一个长度为100的数组中间位置插入一个元素，最坏情况下要把后面50个元素全部往后挪一格。如果是Java的ArrayList，底层还会涉及扩容时整个数组的复制拷贝。第二个问题是数组的长度在大部分静态语言里是固定的，你要么提前申请一个足够大的空间（浪费内存），要么动态扩容（触发一次全量拷贝）。

链表的思路完全不一样：它不追求“紧挨着放”的物理连续性，而是让每个元素（通常叫节点Node）自己记住下一个元素在哪里。就像寻宝游戏，每个线索纸条上只写了下一个线索的藏匿地点，你要找第50个宝藏，就得从第一个纸条一路找过去。听起来效率好像很低，但换来的是两个巨大的好处：插入和删除只需要改前后两个节点的指针，时间复杂度从O(n)直接降到了O(1)；长度可以随便变，想加几个加几个，想减几个减几个，完全不需要预先分配一整块连续内存。

1.2 节点：链表世界里的最小基本单元

理解链表的第一步，是理解节点。一个节点就是一个小容器，里面至少装两样东西：数据本身，以及指向下一个节点的引用（指针）。在C语言里它长这样：

c复制typedef struct Node {
    int data;           // 数据域
    struct Node *next;  // 指针域，指向下一个节点
} Node;

在Java里长这样：

java复制public class Node {
    int data;
    Node next;
}

在Go里也差不多：

go复制type Node struct {
    Data int
    Next *Node
}

很多初学者会忽略一个细节：这个“指向下一个节点”的引用，在定义的时候是一个自身类型的指针。这个概念叫“递归定义”——一个结构体里面包含了一个指向同类型结构体的指针，而不是直接嵌入了另一个同类型的结构体。为什么不能直接嵌入？因为如果Node里面直接放一个Node，那这个Node里面又要放一个Node，无限嵌套下去，内存根本没法分配。用指针就完美解决了这个问题：指针的大小是固定的（32位系统4字节，64位系统8字节），不管它指向的对象有多大，指针本身占用的空间是确定的。

1.3 头节点、头指针和哨兵节点的概念辨析

这是链表里头最容易让人糊涂的一组概念，我当年考研复习的时候在这里栽过好几次跟头。先说结论：

• 头指针：指向链表第一个节点的指针变量。它就像一个引路人，没有它，你根本找不到链表的入口。
• 头节点：在第一个元素节点之前额外添加的一个节点，它的数据域可以不存任何有效数据。有了头节点之后，空链表的判断、首节点的删除操作都统一了，代码写起来会清爽很多。
• 首元节点：第一个存了有效数据的节点，也就是链表中第一个真正的元素。

很多教科书和考研题目里会专门区分“带头节点的链表”和“不带头节点的链表”。这俩在操作上有一个非常关键的区别：对不带头节点的链表，在头部插入或删除节点时，头指针本身会被修改，所以函数需要返回新的头指针，或者传入二级指针；而带头节点的链表，头指针始终指向头节点，永远不需要改动头指针，只需要操作头节点的next就够了。

我个人的习惯是：写代码练习时用带头节点的版本，因为代码更统一、边界条件更少，不容易出错。但考研做题时要两边都熟练掌握，因为考试题经常会考察不带头节点的版本，考察你对指针变更的敏感度。

2. 单链表手写实现：从结构定义到六大核心操作

2.1 初始化与销毁：别看简单，细节藏得深

链表的初始化，严格来说分两步：创建头节点，让头指针指向它。在C语言里你需要手动管理内存：

c复制Node* initList() {
    Node *head = (Node*)malloc(sizeof(Node));
    if (head == NULL) {
        printf("内存分配失败\n");
        exit(1);
    }
    head->next = NULL;
    return head;
}

这里有一个很多教学视频不会强调但你实际写代码会踩的坑：malloc之后一定要判断返回值是否为空。我在大学实验室见过太多同学直接写完malloc就去操作head->next，结果在内存紧张的时候程序莫名其妙崩溃，查了半天才发现是这里的问题。

销毁链表同样容易踩坑。销毁的关键是：先保存下一个节点的指针，再释放当前节点。否则你释放了当前节点之后，它的next指针已经变成野指针了，再访问就是未定义行为：

c复制void destroyList(Node *head) {
    Node *cur = head;
    while (cur != NULL) {
        Node *temp = cur;   // 先记下当前节点
        cur = cur->next;    // 再移动到下一个节点
        free(temp);         // 释放当前节点
    }
}

这个“先保存、后移动、再释放”的顺序就是链表中所有遍历操作的基本功——不管你是搜索、打印、还是释放，只要你想在遍历过程中删除当前节点，就必须先走到下一位。

2.2 头插法与尾插法：建链表的两条路

建链表的时候只有两种选择：从头部插入或者从尾部插入。

头插法的代码非常简短：

c复制void insertAtHead(Node *head, int data) {
    Node *newNode = (Node*)malloc(sizeof(Node));
    newNode->data = data;
    newNode->next = head->next;  // 新节点指向原来的首元节点
    head->next = newNode;        // 头节点指向新节点
}

注意操作的顺序：一定是先接后链，再断前链。也就是先把新节点的next指向原来的首元节点，再把头节点的next指向新节点。如果反过来，先把head->next改成newNode，那原来的首元节点就找不到了，链表直接断掉。

头插法有一个很有意思的特性：它会逆转元素的输入顺序。你依次输入1、2、3、4，用头插法建链，最终链表里存的是4、3、2、1。这个特性在有些场景是天然有用的，比如逆序输出一个序列，你不需要额外开一个栈，直接头插建链表然后顺序遍历就是逆序结果。

尾插法需要额外维护一个尾指针（tail），每次插入后将tail向后移动：

c复制void insertAtTail(Node *head, int data) {
    Node *newNode = (Node*)malloc(sizeof(Node));
    newNode->data = data;
    newNode->next = NULL;
    
    Node *tail = head;
    while (tail->next != NULL) {
        tail = tail->next;
    }
    tail->next = newNode;
}

当然，上面这个版本每次都要O(n)遍历找尾节点，更好的做法是函数外维护一个tail指针，每次插入后更新它，这样尾插法就能做到O(1)。但如果你只是建一次表、后面大部分操作都是查找和删除，那用尾插法时多跑的那几次遍历其实可以接受。

2.3 按位置插入与按值删除：指针操作的黄金法则

按位置插入的核心逻辑是：找到第i-1个节点，然后执行和头插类似的“先接后断”操作。这里有一个必须背下来的经验法则——改指针的顺序，永远是从远端到近端，先把新节点和后面的节点牵上线，再让前面的节点断开旧链接指向新节点。

按值删除的核心逻辑是：找到待删节点的前驱节点，然后让前驱的next直接跳过待删节点：

c复制void deleteByValue(Node *head, int value) {
    Node *prev = head;
    Node *cur = head->next;
    
    while (cur != NULL && cur->data != value) {
        prev = cur;
        cur = cur->next;
    }
    
    if (cur != NULL) {          // 找到了
        prev->next = cur->next; // 跳过cur
        free(cur);              // 释放cur
    }
}

很多人写这个操作时会犯一个错：直接用cur指针去找目标节点，找到之后发现自己根本拿不到前驱节点，因为单向链表只能往后走，没法回头。所以你必须始终维护一个prev指针紧跟cur后面。这个套路叫“双指针遍历”，虽然名字听起来高级，本质就是走路的时候一只手扶着前面一个人的肩膀，防止走丢。

2.4 查找与修改：链表操作的“快餐”

按值查找的逻辑很简单：从首元节点出发，依次比较数据域，找到了返回节点指针或位置，没找到返回空。如果是有序链表，你还可以做一个小优化：遇到第一个比目标值大的节点就提前终止，没必要再往后找了——这算是链表里为数不多的“剪枝”手段。

修改某个位置的值就更简单了，先按位置找到节点，然后直接重新赋值。要注意的是，如果你在遍历过程中修改了当前节点的next指针本身，要格外小心，最好是先保存原来的next再操作——这个“魔鬼细节”在后面的链表反转、局部重排等高级操作里会反复出现。

2.5 各操作的时间复杂度清单

这张表值得反复看。链表看起来“插入删除很快”，但那是相对元素搬移而言的；如果你真的要定位到某个位置做插入删除，那寻找的过程本身就要O(n)。这也是为什么后面工程场景里，链表经常搭配哈希表一起用——哈希负责O(1)定位节点，链表负责O(1)增删节点，互补性极强，Redis的字典就是这种设计思路的典型。

3. 双链表与循环链表：从“单向依赖”到“互为备份”的设计演进

3.1 双链表为什么需要前驱指针

单链表最大的痛点是什么？回不去。你想删除一个节点，必须从头开始找到它的前驱；你想从尾部往前遍历——做不到。这种“只能往后看”的设计，在顺序访问的场景里是没问题的，但一旦涉及逆向操作就会很被动。

双链表（也叫双向链表）在节点里多加了一个prev指针，指向前一个节点：

c复制typedef struct DNode {
    int data;
    struct DNode *prev;
    struct DNode *next;
} DNode;

这相当于给每个节点装了一个“后视镜”。代价是每个节点多占了一个指针的空间，而且在插入、删除的时候需要同时维护两套指针关系，代码细节翻倍。但换来的是：按给定节点做删除操作时，不需要再找前驱了，直接O(1)完成；从尾部往前遍历也不再需要费劲反转或者用栈了，顺着prev一路走就是。

Java里的LinkedList、Java集合框架里的LinkedList底层就是典型的双向链表，你在源码里能看到Node里面有prev和next两个字段——如果你能独立手写一个双向链表并实现add、remove、iterator三大核心功能，你对Java集合框架的理解会飞升一个层级。

3.2 双向链表的插入与删除：四根指针的魔鬼舞蹈

双向链表插入一个节点，需要建立四根引用关系。以在节点p后面插入新节点s为例，正确的顺序是：

text复制1. s->prev = p;
2. s->next = p->next;
3. p->next->prev = s;   // 如果p->next不为空
4. p->next = s;

这个顺序的关键在于：第四步执行之前，p->next还没有被修改，所以第三步能通过p->next访问到原来的后继节点。如果先执行第4步，p->next已经指向s了，第三步就彻底抓瞎。

删除节点p的操作相对简单，只需要让前后两个节点绕过p：

text复制1. p->prev->next = p->next;
2. p->next->prev = p->prev;
3. free(p);

我见过很多同学在写这套代码时，把p->next->prev写成了p->prev，结果链表直接错乱。我的建议是：每次写完这四行，都在纸上画一遍四根引用的变化图，画几次之后就再也不会错了。

3.3 循环链表：让尾节点重新接回头节点

循环链表的意义，一句话就能说清楚：当你需要从任意节点出发都能遍历完整条链表时，用循环链表。它的实现特简单——让尾节点的next不再指向NULL，而是指向头节点（带头节点版本）或首元节点（不带头节点版本）。

循环链表最有名的应用是约瑟夫环问题：N个人围成一圈报数，每次报数到M的人出列，求最后的幸存者。这个问题用循环链表实现几乎是天然的：围着圈遍历，到了M就删除当前节点，然后继续从下一个节点数。相比用数组硬算，循环链表的代码写起来直观得多，而且边缘情况少。

另一个典型应用是操作系统的进程调度。系统里所有进程可以用一个循环链表组织起来，每次时间片用完，调度器就把指针移到下一个进程，永远不需要判断“到尾了重新回到头部”——因为循环链表本身就没有尾部。

3.4 双向循环链表：双链表的“完全体形态”

把双向链表和循环链表结合，就有了双向循环链表：头节点的prev指向尾节点，尾节点的next指向头节点。这是所有链表形态里“对称性”最好的——每一个节点，往前走和往后走都能走通，整个链表如同一个环，任选一个节点都能用一种方向遍历整条链表。

在这种结构里，头节点的prev指向尾节点，会带来一个非常优雅的性质：查找尾部元素永远是O(1)。这个特性和很多内核队列、缓存淘汰算法的实现高度相关。你在阅读Linux内核的list_head实现时，会发现它就是双向循环链表，而且是通过“侵入式链表”的设计嵌套到各种结构体里的——这是C语言链表实现的最高水平，值得每个想深入底层的人去啃一遍。

4. 链表的高频变体：缓存淘汰、反转与环检测背后的思维模式

4.1 LRU缓存淘汰：哈希表+双向链表的经典组合

链表在工程上最经典的应用，莫过于LRU（Least Recently Used，最近最少使用）缓存淘汰算法。这个算法几乎是面试题里链表的“必考题”，而且它完美地展示了链表+哈希表的协同能力。

LRU的核心思想很简单：维护一个按访问时间排序的序列，每次访问一个数据，就把它挪到最前面（表示最近用过）；当缓存满了之后，从最末尾淘汰一个数据（表示最久没被用过）。这种“频繁移动到头部+频繁淘汰尾部”的操作，如果用数组实现，每次移动元素都要O(n)搬移；用双向链表+哈希表，可以做到O(1)访问、O(1)更新、O(1)淘汰。

具体来说：哈希表的key是缓存的键，value是指向双向链表节点的指针；双向链表节点存key和value。访问一个数据时，先从哈希表找到它在链表中的位置，然后把它摘下来挪到头部；插入新数据时，如果容量已满，先删掉尾节点，同时删掉哈希表里对应的key，然后把新节点插到头部。整个过程的关键就是“通过哈希表拿到节点后，O(1)地把它从链表中摘出来”——而这正是双向链表相对单链表的核心优势：删一个节点不需要从头找前驱。

4.2 链表反转：三指针法为什么能成为必背模板

链表反转几乎是所有数据结构笔试面试中的“Hello World”，但每年依然有大量的人在考场上写错。反转的本质是：把每个节点的next指针从指向后继改为指向前驱。但因为单链表只能往前看，你必须先把后继存下来，才能安全地修改指针。

c复制Node* reverseList(Node *head) {
    Node *prev = NULL;
    Node *cur = head;
    
    while (cur != NULL) {
        Node *nextTemp = cur->next; // 1. 先保存后继
        cur->next = prev;           // 2. 反转当前节点的指针
        prev = cur;                 // 3. prev前移
        cur = nextTemp;             // 4. cur前移
    }
    return prev; // 新的头节点
}

这个模板的口诀就是：“先存后继、再改指向、然后一起往前推”。很多人会问，为什么不能直接把cur->next改成prev，然后再把cur移到cur->next？因为改了之后cur->next已经不再是原来的后继了，整个链表就断了。所以“先用临时变量存后继”是不可跳过的关键步骤。

进阶版本还有递归反转：

c复制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;
}

递归版的核心思想是：先把后面那段链表反转好，然后把当前节点接在它的后面。理解递归版的关键是把“head->next->next = head”读作“让我的下一个节点重新指向我”。这两个版本我建议都要手写至少十遍，直到闭着眼睛都能写对。

4.3 环的检测：快慢指针的数学原理与实践

链表里有一个非常常见的坑：不小心把某个节点的next指回了它前面的某个节点，整个链表就变成了一个环。这时候你遍历永远不会结束，程序直接卡死。

检测链表是否有环的标准做法是快慢指针：慢指针每次走一步，快指针每次走两步。如果链表无环，快指针会先到达末尾；如果有环，快慢指针必定在某个时刻相遇。

为什么一定会相遇？假设慢指针进入环之后，快指针已经在环里转了若干圈。两者之间的距离差会随着每次移动减1（慢的走1步，快的走2步，距离差减少1），所以不管一开始差多远，经过有限次移动必然相遇。这个证明过程在很多面试里会被追问，建议自己能完整讲一遍。

更进一步，如果要找到环的入口节点，有一个很巧妙的结论：从相遇点出发的指针和从头节点出发的指针，每次都走一步，它们相遇的位置就是环的入口。这个结论可以用数学严格证明，这里先记住结论，实际刷题时配合证明一起理解，效果更好。

c复制Node* detectCycle(Node *head) {
    Node *slow = head, *fast = head;
    while (fast != NULL && fast->next != NULL) {
        slow = slow->next;
        fast = fast->next->next;
        if (slow == fast) { // 相遇说明有环
            Node *p = head;
            while (p != slow) {
                p = p->next;
                slow = slow->next;
            }
            return p; // 环的入口
        }
    }
    return NULL; // 无环
}

4.4 有序链表合并：归并思想的线性表落地

两个有序链表合并成一个有序链表，是“归并排序”思想在链表上的最佳练习。思路其实和数组合并差不多：比较两个链表当前节点的值，把小的那个摘下来接到结果链表的尾部，然后移动对应链表的指针，直到某一条链表遍历完，再把剩下的那条直接接上去。

c复制Node* mergeTwoLists(Node *l1, Node *l2) {
    Node dummyHead;  // 哨兵节点，简化边界处理
    dummyHead.next = NULL;
    Node *tail = &dummyHead;
    
    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 dummyHead.next;
}

这个实现里最关键的一笔就是用了一个栈上的哨兵节点dummyHead。它的作用在于：不用单独判断“合并后的头节点是l1的还是l2的”——哨兵节点统一收容两种情况。你在很多链表题目中会反复看到这种“dummy node”技巧，比如删除链表倒数第N个节点、对链表进行归并排序时，它都能让代码简洁不少。

5. 链表与数组怎么选：性能数据的真相与工程场景对照

5.1 一个反直觉的事实：链表的“O(1)插入”在现实中经常跑不赢数组

很多初学者学到链表之后会产生一种错觉：链表插入O(1)，数组插入O(n)，所以链表一定更快。这个结论在大O复杂度层面是对的，但在工程现实中远没有那么简单——原因有三层：

第一，链表的O(1)插入是指“已经定位到目标位置之后”的插入。要定位，你还是得花O(n)从头遍历。这和数组通过下标直接定位到目标位置的O(1)相比，整整差了一个数量级。

第二，链表节点的内存是分散的。你在遍历链表的时候，CPU每次访问一个节点，都大概率面临缓存未命中，要从主内存甚至更慢的层级中加载数据。而数组是连续内存分布，访问下一个元素时，前一个元素大概率已经在CPU缓存里了，访问速度能快十倍甚至更多。这就是局部性原理对性能的巨大影响，在大O复杂度里它被完全抹掉了，但在七千万元素的超大数据集上，这可能是几秒钟和几十秒的差别。

第三，链表的每个节点需要额外存指针，还伴随着频繁的内存分配/释放。每次插入新节点就是一次malloc，每次删除就是一次free，这些操作本身的开销不低，而且容易造成内存碎片。

所以工程上的真实经验是：只在“频繁在中间插入/删除且已经能O(1)定位到目标位置”的场景，链表才明显占优。其他场景，数组、切片、ArrayList往往是更省心也更快的选择。

5.2 不同语言里的“链表原生支持”有什么不一样

不同语言对待链表的态度差异非常大：

• C语言：没有内置链表，所有节点、指针、内存管理全靠自己写。这是我的建议——学链表一定要用C语言手写一遍，它逼你直面内存的每一个细节。
• Java：有LinkedList，底层是双向链表，但也因为节点分散、缓存不友好，很多时候性能反而不如ArrayList。Java里如果你需要频繁头尾插入，ArrayDeque（一个可扩容的数组实现的双端队列）往往更快。
• Go：标准库container/list提供了双向链表，但Go语言社区更推荐直接用切片，因为切片本身的扩容机制和内存布局已经足够高效。
• Python：list是动态数组，不是链表。标准库没有专门的链表实现，因为Python的list已经经过高度优化，绝大多数情况下没必要再用链表。
• C++：STL的list是双向链表，forward_list是单向链表。如果你只需要顺序访问且频繁在头部插入，forward_list反而比list更省内存，因为它只有一根指针。

5.3 实际项目中的选型决策清单

我自己的判断逻辑整理如下，供你直接抄作业：

6. 实战中的三个坑：指针丢失、边界判断和内存管理的经验

6.1 指针丢失：链表世界里最经典的“翻车事故”

我见过太多次链表代码在考试和面试中的翻车，十次里有八次是同一个原因：操作顺序不对，导致指针丢失。

举一个最典型的例子——在单链表节点p之后插入新节点s，初学者最容易写出的错误代码是：

c复制p->next = s;   // 先让p指向s
s->next = p->next; // 这里p->next已经是s了，s自己指向了自己

这个代码一执行，链表在s之后就断了。正确写法我前面已经强调过：“先接后断”。具体的记忆方法可以这样：先把s的前面和后面都牵好（s->next指向p的下一个，s的prev指向p），再把p的next切换到s。如果你画一张带四个箭头的图，按照“先画新箭、再断旧箭”的顺序走，永远没错。

同理，删除链表节点时，很多人用cur指针遍历，找到目标后直接free(cur)，却忘了在free之前要维护前驱节点的指针。正确的惯例是：删除任意单链表节点都需要前驱节点。如果没有前驱（比如要删除头节点），要么特别处理，要么用哨兵节点统一逻辑。

6.2 边界条件：空链表、单节点链表、头尾操作

链表代码的边界条件，是区分“会写链表”和“背模板”的分水岭。我建议每次写完链表代码，第一时间检查这几个场景：

• 链表为空时，插入、删除、查找、遍历是否都能正常走通？
• 链表只有一个节点时，反转、删除该节点、判断是否有环，是否还能正确运行？
• 在头部插入、在头部删除、在尾部插入、在尾部删除，头指针/尾指针是否都能正确更新？
• 传入的指针是NULL或野指针时，代码是否会崩溃？

我见过很多同学在LeetCode上刷题时，代码在普通用例下全对，一旦提交就报错，原因十有八九就是边界条件没考虑。比如按值删除节点时，如果值不存在于链表中，函数应该返回原链表而不是什么都不做；判断链表是否有环时，空链表和单节点无环链表不应该死循环；反转链表时，空链表应该直接返回NULL。

一个小技巧是：在写循环遍历链表时，统一写成while (cur != NULL && cur->next != NULL)这种包含判空条件的写法，可以避免绝大多数的空指针崩溃。当然也要留意，这种写法可能会导致循环提前退出，所以要结合具体逻辑取舍。

6.3 内存管理：malloc的朋友必须成对出现

在C/C++等手动管理内存的语言里，链表是一座“内存漏洞的重灾区”。每一个malloc创建出来的节点，最终都必须有一一对应的free把它释放掉，否则程序运行时间一长，内存就被慢慢吃光，最终在某个角落突然崩溃——这种bug调试起来非常痛苦，因为它不好复现、时间点随机。

我的经验是：写链表相关代码时，养成每写一个malloc/free就往旁边加注释的好习惯，标出“谁申请、谁释放、在哪个分支释放”。另外，release模式下建议立刻开启内存检测工具（比如Valgrind，在macOS上就是leaks命令），跑一遍功能测试后看一眼内存报告，如果有leak直接能定位到具体代码行。在Java或Go这类带垃圾回收的语言里虽然没有这个烦恼，但手动把节点置空、养成清晰的引用释放习惯仍然是好习惯——它能让你的代码逻辑更清楚，也能避免“明明可以回收却一直被引用”的隐性问题。

6.4 为什么考研和面试都爱考链表：一张图看清它的知识密度

链表为什么能成为数据结构考试里的“常青树”？因为它的知识密度实在太高了：它拷问你指针理解、内存管理、边界条件、算法思维、代码风格，一个“反转链表”的题目就能覆盖链表一半以上的核心考点。

再看考研真题的方向：严蔚敏教材和王道数据结构这两本考研参考书里，链表的考点覆盖了带头节点/不带头节点的区别、头插法/尾插法的元素顺序、链表合并、循环链表约瑟夫问题、双向链表操作、链表逆置、两个有序链表合并、链表是否存在环——这些正好就是我上面写到的所有内容。你在复习时如果能把每一块都做到“能画图、能写代码、能说出复杂度”，链表这块基本就不会失分了。

在面试里，链表是全场默认的“手写题开场”。面试官不需要你一定要用最优解，更看重你能不能边写边说清楚每一步指针的走向、能不能主动分析空指针风险、能不能在写完之后快速自查。这些能力，只有靠平时反复手写、反复踩坑才能练出来。

我自己的体会是，链表是真正考验“把抽象逻辑落成具体代码”能力的训练场。数组的代码写错了，debug起来相对容易；链表的代码一旦指针错乱，程序甚至可能不报错，只是结果悄悄变错，或者跑着跑着就崩。这种“静默出错”的属性，恰恰逼着你在写完代码的那一刻就把逻辑想得非常清楚。数据结构（3）如果你把链表这部分吃透了，后面的栈、队列、树、图，你都会发现它们多多少少都长着链表的影子——栈和队列其实都只是“限制了操作位置的线性表”，而树和图，从某种意义上就是“更复杂的链表关系”。能把链表学明白，整个数据结构的大厦就有了一个坚实的地基。