单链表详解：从数据结构原理到插入删除与逆序实操

先说说我自己的感受：很多初学编程的人在《数据结构》这门课上，第一个真正“卡住”的地方往往不是排队、树或者图，而是“单链表”。教材翻到那一章，节点结构体看懂了，插入删除的流程图也能跟上，可一旦脱离书本自己动手写代码，要么写完不打印东西，要么一运行就崩溃，要么链子莫名其妙断成几截。如果你是这种状态，不用慌，这非常正常。单链表是数据结构这门课里第一个把“内存”“指针”“逻辑结构”三者绑在一起的知识点，等这篇讲完，你会发现它其实就是“几个节点 + 每个节点记着下一个节点的地址”这么一件事。

这篇文章我会从以下几个角度展开：先讲清楚单链表到底解决了数组的什么痛点，再按实验报告的高频要求把建表、查找、插入、删除、销毁这些基本操作全部拆开讲，并且每一步都会说明为什么这么写。然后我会专门分享这几年在实际编码和帮同学查错时遇到的那些典型坑——断链、死循环、空指针崩溃，基本都在链表这一章扎堆出现。最后再结合单链表逆序这种经典题和面试、考研里常考的变体，帮你把学和用之间的路打通。

适合谁看？正在学数据结构的学生、准备考研或软考的人、刷力扣链表题总翻车的开发者，以及所有想知道“为什么链表插入删除是O(1)，我却总是写不对”的人。下面进入正题。

1. 单链表到底在解决什么问题：从数组到链表的思维转换

1.1 数组的痛点与链表的核心思路

先回到最基础的问题：数组用得好好的，为什么会需要链表？

数组在内存里是一段连续的空间，所以它有一个天然优势：知道首地址，想访问下标为i的元素，直接做一次地址运算就行，这就是“随机访问”。但正是这个“连续”，让它付出代价。如果你要在数组中间插入一个新元素，逻辑上很简单——把后面的元素统统往后挪一个位置，可这个“统统往后挪”在数据量大的时候非常伤。删除同理，得把后面元素全部往前挪。程序的复杂度一眼就能看出来是O(n)，而且这里说的n是移动元素的个数，不是简单算一次就结束。

链表换了一种思路：我不要求数据在物理上连续存放。每个元素是一个“节点”，节点里除了存数据本身，再额外存一个指针，指向下一个节点在哪。这就好像一列火车，每节车厢都知道后面拖着的是哪一节，但车厢之间并不需要焊死在同一根轨道上。你随时可以在两节车厢中间加一节新的，只需要把前面那节车厢的连接钩换一下，同时让新车厢钩住后面那节，其它车厢根本不用动。

插入删除“只改指针”这种特性，是链表存在的最根本理由。如果一件事只需要改一两个指针就能完成，那它的时间复杂度就是O(1)，和前面有多少个元素没有关系。当然，代价也很明确：因为每个节点散落在不同位置、只靠指针串联，你想找第5个节点，就没办法像数组一样直接算地址，必须从第一个节点开始一路顺着指针走，这是一种“顺序访问”。所以链表和数组本质上是一对互补的结构：一个擅长高频访问，一个擅长高频插入删除。

1.2 头指针、头结点和首元节点：为什么许多教材要加一个“不存数据的节点”

网上讨论单链表时，最常见的一个混乱点就是“头指针”“头结点”“首元节点”三者到底什么关系。先说结论：

• 头指针：指向链表第一个节点的指针。它是整个链表的“入口”，只要它还在，链表就找得到。
• 首元节点：真正存第一个有效数据的节点。
• 头结点：位于头指针和首元节点之间的一个节点，通常不存数据，只起辅助作用。

用人话说，带头结点的链表就是多加了一个“哨兵位”，站在最前面，不存业务数据，next指针指向真正的首元节点。为什么多此一举？因为加了它，空链表和非空链表的插入删除逻辑就统一了。

举个例子：如果链表是空的，那么头指针直接指向NULL。此时你想在头部插入一个新节点，你得修改头指针本身。可如果头指针是作为参数传进函数里的，修改它能不能生效就要看函数传参方式了，这是一个很大的坑，后面我会专门讲。而如果链表有头结点，那么即使链表为空，头结点的next也是NULL，插入时你只需要修改头结点的next指针，逻辑和“在非空链表头部插入”完全一致，不存在需要修改头指针本身的情况。这就是为什么严蔚敏教材和王道数据结构里，几乎所有单链表实现都默认带头结点——不是为了加一个节点好玩，是为了让代码更稳、更统一。

初学的时候建议先只画带头结点的版本，把这块玩熟了，再看“无头结点”的版本会非常轻松。

1.3 节点的定义与动态内存：链表的“地基”

先看C语言里单链表节点的标准定义，这个定义几乎是所有教材的统一写法：

c复制#include <stdio.h>
#include <stdlib.h>

typedef struct LNode {
    int data;              // 数据域，这里以int为例
    struct LNode *next;    // 指针域，指向下一个节点
} LNode, *LinkList;

解释几个容易懵的地方。typedef struct LNode { ... } LNode, *LinkList; 这行等于做了两件事：给结构体起了一个别名LNode，又给结构体指针起了一个别名LinkList。所以以后你写LinkList L;就表示定义了一个指向链表节点的指针，它通常用来表示“整条链表”，因为链表本身就是靠头指针认亲的。而写LNode *s;和LinkList s;其实是同一件事，只是前者更强调“这个指针指向一个节点”，后者更强调“这是一条链表的抽象”。这两种写法在C语言项目里都常见，看个人习惯。

节点本身不是一个静态分配的固定结构，而是在程序运行过程中“按需申请”的。C语言里用malloc来申请：

c复制LNode *s = (LNode *)malloc(sizeof(LNode));
if (s == NULL) {
    // 内存分配失败，一般直接返回或者报错
    return;
}
s->data = x;
s->next = NULL;

这种在运行期才分配内存的方式叫做“动态存储分配”。很多初学者不理解为什么不能像数组那样LNode arr[100]一次性定义好，因为链表的价值就在于长度不确定、随时增删。写死100个节点，本质上又回到了数组的思路，那链表的意义就没了。

这里还必须养成一个习惯：每次malloc之后都要检查返回值是不是NULL。虽然考试卷子上经常默认内存足够，但真实工程或实验报告里，操作系统给程序的内存不是无限的，申请失败是可能的。不检查就解引用空指针，程序大概率直接崩。

2. 实验报告高频操作拆解：建表、查找、插入、删除、销毁

2.1 初始化带头结点的空链表：为什么这里必须用二级指针

很多人第一次写单链表的初始化函数，会把代码写成下面这样，然后发现链表根本“没有初始化成功”：

c复制// 错误示范
void InitList(LinkList L) {
    L = (LNode *)malloc(sizeof(LNode));
    L->next = NULL;
}

问题出在C语言的函数参数传递上。函数参数是值传递，L只是外部头指针的一份拷贝，你在函数里改了这份拷贝，外部的头指针依然是原来的值（通常是未初始化的垃圾值或NULL）。要想在函数里真正修改外部的指针变量本身，必须再套一层，也就是传“指针的指针”。正确写法如下：

c复制int InitList(LinkList *L) {
    *L = (LNode *)malloc(sizeof(LNode));
    if (*L == NULL) {
        return 0;   // 初始化失败
    }
    (*L)->next = NULL;
    return 1;       // 初始化成功
}

调用时这样写：

c复制LinkList L;
if (InitList(&L)) {
    // 链表初始化成功，此时的L是一个带头结点的空链表
}

为什么*L指向头结点，而头结点的next要置为NULL？因为空链表不代表没有头结点，只是“有头结点但头结点后面没有任何有效数据”。把next置空，就是明确告诉程序“此处已是链尾”。很多查找、插入操作的循环终止条件都依赖这个NULL，比如while (p->next != NULL)，如果少了这样一个终点，循环就会越过链表末尾，可那不是“过了边界就停止”，而是会去访问不存在的内存，也就是野指针问题。

顺带说一句，在Python、Java这些现代语言里，因为对象默认是引用传递，这个问题不会那么明显，这也是为什么很多用C学数据结构的人一开始总觉得别扭。但请相信，C语言这种“什么都要你管”的设计，恰恰能让你把指针和内存之间的联系理解得更深。

2.2 头插法与尾插法：同样是建表，结果顺序完全相反

初始化完成后，接下来的高频需求就是“创建链表”——把一组数据存进链表里。主流方法有两种：头插法和尾插法。

头插法每次把新节点插到头结点后面，也就是插到整个链表的最前面。它的代码非常短：

c复制void HeadInsert(LinkList L, int x) {
    LNode *s = (LNode *)malloc(sizeof(LNode));
    if (s == NULL) return;
    s->data = x;
    s->next = L->next;   // 新节点的next指向原来的首元节点
    L->next = s;         // 头结点的next指向新节点
}

如果你依次用头插法插入1、2、3、4，最终链表里存的顺序是4、3、2、1。原因很简单：你每次都在头部操作，后来者永远站在最前面。所以头插法常常被用来实现“逆序建表”或者“链表的反转”，不少实验题直接让“输入一组数，用头插法建表”，本质上就是在考察你是否清楚插入顺序和最终顺序的这种镜像关系。

尾插法就直白很多：每次都把新节点接到链表的末尾。但问题是怎么找到末尾？最笨的办法是每次从第1个节点开始遍历到最后一个节点，再挂上去。这种做法虽然逻辑不错，但假设你要插入n个节点，每次都从头找到尾，总时间会变成O(n^2)，数据量一大就不合适。所以实际写尾插法时，通常会维护一个“尾指针”r，它始终指向当前链表的最后一个节点：

c复制void TailInsert(LinkList L, int x) {
    // 先找到当前链表尾节点
    LNode *r = L;
    while (r->next != NULL) {
        r = r->next;
    }
    // 创建新节点
    LNode *s = (LNode *)malloc(sizeof(LNode));
    if (s == NULL) return;
    s->data = x;
    s->next = NULL;
    // 把新节点挂到尾节点后面
    r->next = s;
}

不过这个版本在连续尾插时会重复遍历，更高效的工程写法是在建表过程中用一个变量保存当前的尾节点位置。这些细节不用死记，理解思路即可：尾插法的本质就是始终维护“最后一个节点在哪里”。

2.3 查找第i个节点：为什么没有捷径可走

链表查找分为两种：按值查找和按位查找。按位查找就是找到第i个节点。它为什么麻烦？因为链表的内存地址是离散的，每个节点只知道下一个节点在哪，不知道自己在“全局地址表”里的编号。这点和数组完全不同：数组arr[i]可以通过首地址加偏移直接定位，但链表不能，你必须从头开始一个一个数过去。

按位查找的标准实现如下，返回值可以设计成节点指针或布尔值。我一般更习惯返回节点指针，方便后续插入和删除直接复用：

c复制LNode *GetElem(LinkList L, int i) {
    if (i < 0) return NULL;
    LNode *p = L;        // p从第0个节点开始，也就是头结点
    int j = 0;
    while (p != NULL && j < i) {
        p = p->next;
        j++;
    }
    return p;            // 如果i超出了链表长度，p自然走到NULL，返回NULL即可
}

注意一个非常容易错的点：这里下标i指的是“从头结点数起的第几个节点”。很多教材里，头结点被当成第0个节点，首元节点是第1个节点。如果你想找“第2个数据节点”，传入的参数应该是2还是3？这得看具体实现的约定。先理清约定，再写循环，否则代码一会儿错位一个节点。你可以在自己的代码注释里明确写“本函数从0开始计数”，这样就避免了混乱。

按值查找更直接，就是从头遍历，比较每个节点的data：

c复制LNode *LocateElem(LinkList L, int e) {
    LNode *p = L->next;
    while (p != NULL && p->data != e) {
        p = p->next;
    }
    return p;
}

如果找到就返回那个节点的指针，如果没找到，p会走到NULL。

2.4 插入与删除：核心其实就一句话“先连后断”

现在开始解决最核心的插入和删除。假设要在第i个位置插入值为e的新节点，你得先找到第i-1个节点。为什么一定要找前驱？因为单向链表只能从前往后走，如果你已经拿到了第i个节点，你是没有办法回头看前一个节点是谁的，所以只能从起点出发，把目标定在“新节点要接在谁后面”。

找到了前驱节点p之后，真正核心的插入就两行代码：

c复制s->next = p->next;   // 新节点先“抓住”p后面的节点
p->next = s;         // p再指向新节点

这两行的顺序绝对不能反。如果先执行p->next = s，那么p原来的后继节点就再也找不到了——因为唯一的线索已经被覆盖掉，你拿着s也救不回来，这叫做“断链”。你可以这样记忆：先让新来的手伸出去抓住后面的兄弟，再让前面的车子挂住新来的，顺序永远是“先连后断”。

删除操作同理。删除第i个节点时，需要找到它的前驱p，再让p跨过这个节点，直接指向后继：

c复制int ListDelete(LinkList L, int i, int *e) {
    LNode *p = L;
    int j = 0;
    // 找到第i-1个节点
    while (p->next != NULL && j < i - 1) {
        p = p->next;
        j++;
    }
    if (p->next == NULL) {
        return 0;  // 第i个节点不存在
    }
    LNode *q = p->next;   // q就是要删除的节点
    *e = q->data;         // 把被删元素的值带出去，方便调用方处理
    p->next = q->next;    // 前驱跨过q
    free(q);              // 释放q占用的内存
    return 1;
}

这里有一个很容易被忽略的好习惯：用free(q)释放了被删除节点后，不能让链表里还有指针指向这片已经还给系统的内存。上面的代码让前驱先跨过q再free，这是对的。如果你先free再改指针，那你就是拿着一个悬空的指针去访问已经不属于你的内存，属于典型的“野指针”错误，可能在运行时随机崩溃。

2.5 遍历输出与销毁链表：容易被扣分的两个操作

写实验报告时，很多人建完表就算结束，但遍历输出和销毁链表是两个高频考查点。

遍历输出只需要从第一个有效节点开始，走到NULL为止：

c复制void PrintList(LinkList L) {
    LNode *p = L->next;
    while (p != NULL) {
        printf("%d ", p->data);
        p = p->next;
    }
    printf("\n");
}

这里循环条件用p != NULL而不是p->next != NULL，可以保证最后一个节点也能被打印到。

销毁链表则是一个更难写对的操作，因为要把每一个节点都free掉。初学者最容易犯的错误是这样：

c复制// 错误示范
void DestroyList(LinkList L) {
    LNode *p = L;
    while (p != NULL) {
        free(p);
        p = p->next;   // 错！p已经被释放了，p->next是野指针访问
    }
}

free(p)之后，p指向的内存已经不属于你了，再去访问p->next属于未定义行为。正确做法是先保存下一个节点的地址，再释放当前节点：

c复制void DestroyList(LinkList L) {
    LNode *p = L;
    while (p != NULL) {
        LNode *next = p->next; // 先记下下一跳
        free(p);               // 再释放当前节点
        p = next;              // 走到下一跳
    }
}

用链表来类比就是：拆火车的时候，你得先把跟后面车厢的连接钩摘下来，把后面车厢的信息记录好，再拆当前车厢。如果先拆了再回头找下一节，早就找不到了。这个“先保存、后释放”的习惯，在你以后写树、图这些结构时同样适用。

3. 我调试链表时遇到的坑：从死循环、断链到空指针崩溃

3.1 断链：插入顺序反了，链表从中间裂开

很多同学第一次手写链表插入时，犯的错误如出一辙。假设当前有一个链表，节点顺序是A -> B，现在要把新节点S插到A后面。错误代码是这样的：

c复制p->next = s;      // 错误顺序：先把A指向S
s->next = p->next; // 此时p->next已经是S自己了，这行等于s指向s

表面上看，链表不会立刻崩溃，甚至打印时可能只会无限循环。原因在于S的next指向了自己，形成了一个环。程序从头结点出发打印，走到A，然后走到S，再走又回到S，永远跑不到NULL。

这就是为什么我在讲插入的时候反复强调“先连后断”。放在调试场景里，如果你看到程序卡死，并且CPU占用率居高不下，那大概率是链表里出现了环。你可以立刻怀疑是不是插入顺序写反了，或者某个节点的next没有正确指向下一个节点。

3.2 空指针和野指针：崩溃信息不会说谎，但要看懂它

链表相关的崩溃信息通常长这样：Segmentation fault，或者Windows下的“0xC0000005访问冲突”。崩溃点多发生在解引用指针的代码里，比如p->data。最常见的背景是，p实际上是NULL，你去访问NULL的data，当然报错。

最容易产生空指针解引用的几个位置：

• 建表后忘了初始化L->next = NULL，然后直接遍历；
• 查找第i个节点时，传入的i比链表实际长度大很多，返回NULL后没有检查就直接用；
• 删除节点的循环里，判断条件是while (p != NULL)，但实际应该判断p->next != NULL，导致p移动到NULL后继续使用了p->next。

调试这种崩溃，我的经验是不要急着改代码，先在能定位到的那一行前后打印指针的值。比如，在访问p->data之前加一句：

c复制printf("当前p=%p\n", p);

如果打印出来是0x0或者nil，说明p是空指针，那问题就变成“p为什么是空”。沿着调用链往上找，看是循环条件错了，还是查找函数本来就返回了NULL。这种“先确认指针值，再找原因”的动作，比反复看不报错的地方高效太多。我自己每次用链表写代码，都会习惯性地在关键位置加几个printf，跑通之后再删掉。等到你驾驭熟练了，再配合调试器一步步走，效果更好。

3.3 传值修改不生效：为什么初始化总是失败

我在前文讲初始化时，提到过一级指针不行、要二级指针的问题。这个坑几乎每个转C的同学都会踩一次，而且它不会立刻报错，而是表现得特别隐蔽：函数里明明malloc了，可是回到调用处，头指针还是NULL，或者还是垃圾值。

如果你用的是Dev-C++或者一些老教材的写法，可能还会看到一个版本叫：

c复制LinkList InitList() {
    LinkList L = (LinkList)malloc(sizeof(LNode));
    L->next = NULL;
    return L;
}

这其实也是一种思路：既然函数内部改不了外部指针，那就把改好的指针作为返回值返回出来，调用方用LinkList L = InitList();去接住。对于“只要创建一条链表”的场景，这个写法简单直观。但如果你的函数既要创建链表，又想通过参数带回其它状态信息，那可能两个方案都要用，看需求灵活选择。

记住一条底层规律：C语言的函数参数永远是值传递。你需要修改的是“指针变量本身”，就必须传指针变量的地址，也就是二级指针；而如果你只是通过指针去修改它指向的目标对象，那么一级指针就够用了。区分这两点，能帮你避免很多莫名的bug。

3.4 我排查链表问题的通用方法

链表的抽象能力很难通过眼睛看代码一步到位。我现在写链表，基本上遵循这样的排查流程：

第一步，先画图。把操作前的链表状态画出来，每个节点的data和next都标清楚，然后再画操作后应该变成什么样。插入删除的代码其实就是把“图的变化”翻译成语言。

第二步，给每个函数加边界检查。建表成功后检查头指针是不是NULL；查找时如果参数不合法，先返回NULL而不是直接往下走；插入删除前检查待查找位置是否越界。别嫌麻烦，链表这类结构的错误几乎都来自边界情况。

第三步，打印中间状态。排查死循环时打印遍历到的节点值，排查断链时打印每个节点的next地址。

第四步，也是最重要的，一定用free去释放自己malloc出来的内存，并且free之后避免再使用那个指针。内存泄漏在数据结构实验里不像崩溃那么显眼，但它确实是工程上的大忌，养成从小程序就注重内存管理的习惯，后面学树和图时能少踩无数坑。

4. 单链表逆序专题：迭代、递归与Python玩法

4.1 迭代反转：从单向走的核心矛盾出发

单链表逆序是几乎每一本教材、每一场面试、每一份考研真题都会出现的题。它的核心矛盾在于：单链表只能从前往后走，没有prev指针，可逆序之后，每一个节点的next都要指向它的前一个节点。所以问题变成了：在一趟遍历过程中，怎么在改变某个节点方向的同时，不丢掉下一个节点？

标准解法是准备三个指针：prev、curr、next。

• prev：已经反转好的那一段链表的头节点，最开始是NULL；
• curr：当前正要处理方向的那个节点，最开始是链表的第一个有效节点；
• next：curr原来的下一个节点，防止方向改完之后找不到路。

每轮循环做的事情就是：先记下next，然后把curr->next改成prev，再把prev挪到curr，curr挪到next。

C语言实现如下：

c复制void ReverseList(LinkList L) {
    LNode *prev = NULL;
    LNode *curr = L->next; // 从首元节点开始
    LNode *next = NULL;

    while (curr != NULL) {
        next = curr->next;  // 先保存原后继
        curr->next = prev;  // 反转方向
        prev = curr;        // prev前进
        curr = next;        // curr前进
    }

    L->next = prev;         // 最后prev就是新的首元节点
}

这个算法的每一步都可以用画图来验证。比如链表是1 -> 2 -> 3 -> NULL：

• 初始：prev=NULL，curr=1，next=NULL
• 第一轮：next=2；1->next=NULL；prev=1；curr=2
• 第二轮：next=3；2->next=1；prev=2；curr=3
• 第三轮：next=NULL；3->next=2；prev=3；curr=NULL
• 循环结束，L->next=3，链表变成3 -> 2 -> 1 -> NULL

之所以最后要让L->next = prev，是因为此时prev指向反转后链表的头部，原来的头结点还在，只需要把头结点挂到新头部前面就行。这个思路如果在考场或面试现场能脱口而出，说明你对指针操作已经有一定感觉了。

4.2 递归解法：先相信子问题已经解决

迭代好理解，递归却总让人犯迷糊。递归反转链表的经典代码很短：

c复制LNode *ReverseRecursion(LNode *head) {
    // 递归出口：空链或只有一个节点
    if (head == NULL || head->next == NULL) {
        return head;
    }
    LNode *newHead = ReverseRecursion(head->next);
    // 把当前节点挂到它后继的后面
    head->next->next = head;
    head->next = NULL;
    return newHead;
}

这段代码看起来神神秘秘，关键在理解递归的“信任”机制。假设原链表是1 -> 2 -> 3 -> NULL。当函数处理节点1时，它调用自己处理head->next，也就是节点2开始的子链表2 -> 3。我们不需要在脑中把递归过程完全展开，只需要信任递归调用返回的结果是“已经反转好的子链表”，也就是3 -> 2。

此时站在节点1的视角，它后面跟着2，而2现在已经被反转成子链表的末尾了。于是要做的事情很简单：让2的next指向1，也就是head->next->next = head;，然后让1的next指向NULL，防止产生环。最终返回的newHead就是反转好的新链表头节点3。

递归解法的优点是好写、思路优雅，缺点是对初学者不友好，而且递归深度等于链表长度，如果链表非常长，可能有栈溢出的风险。面试时如果要用递归，最好能同时说清楚它和迭代各自的代价，这会是你和其他候选人拉开差距的地方。

4.3 用Python写单链表逆序：为什么动态语言更轻松

热搜词里有“python单链表逆序”，这说明现在越来越多课程和面试允许用Python写算法。Python没有指针概念，对象的引用机制帮你屏蔽了大部分底层细节，单链表的节点定义也简单不少：

python复制class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

反转函数用迭代写，核心思路和C完全一致，只是把指针赋值改成了变量赋值：

python复制def reverse_list(head: ListNode) -> ListNode:
    prev = None
    curr = head
    while curr:
        next_node = curr.next  # 先保存下一个节点
        curr.next = prev       # 反转方向
        prev = curr            # prev前进
        curr = next_node       # curr前进
    return prev                # 反转后prev就是新的头节点

Python版本少了malloc、free这些内存管理操作，所以代码更清爽。但我要提醒一句：如果你只用Python学链表，很容易把链表当成“列表的替代品”，从而削弱对指针和内存的理解。数据结构这门课的底层逻辑，用C或C++过一遍，再去写Python，你会更清楚每个操作背后到底发生了什么。

5. 面试和考试会怎么考单链表：高频题型与复习思路

5.1 双指针技巧：找中间节点、倒数第k个节点、判断环

单链表题目里有一类“套路王”，叫双指针。它看似技巧性很强，实际上只是把“链表只能单向走”这个限制利用到了极致。

找中间节点：准备一个slow指针，一个fast指针，都从首元节点出发。slow每次走一步，fast每次走两步。当fast走到链表末尾时，slow正好在中间位置。这个思路也是之后学习“判断回文链表”的基础。

找倒数第k个节点：让快指针先走k步，然后快慢指针一起每次走一步。当快指针走到NULL时，慢指针指向的就是倒数第k个节点。这个做法的精妙之处在于，慢指针和快指针始终保持k个节点的距离，不需要知道链表总长。

判断链表有没有环：同样是快慢指针，fast每次走两步，slow每次走一步。如果链表中存在环，那么fast和slow一定会在某个时刻相遇；如果fast走到了NULL，说明链表无环。这个结论可以这样理解：只要有环，两个指针就相当于在环形跑道上以不同速度奔跑，速度更快的迟早会和速度慢的相遇。

这三道题本质上都在利用“快慢速度差”或者“固定距离差”。做这类题时不要机械背诵代码，最好在纸上先画一串节点，自己手动“跑”一遍指针，你会发现这些方法本质上非常直观。机考或面试时，如果能现场说出“为什么这样不会死循环”，会让面试官对你放心不少。

5.2 合并有序链表：递归思想在链表题里的又一次体现

合并两个升序链表也是考研、面试必备题。两个链表都已经有序，你需要把它们合成一个仍然有序的链表。用递归写非常工整：

python复制def merge_two_lists(l1: ListNode, l2: ListNode) -> ListNode:
    if not l1:
        return l2
    if not l2:
        return l1
    if l1.val < l2.val:
        l1.next = merge_two_lists(l1.next, l2)
        return l1
    else:
        l2.next = merge_two_lists(l1, l2.next)
        return l2

思路是这样的：比较两个链表当前节点的值，谁小，谁就作为合并结果的头节点，然后递归去合并“它的下一个节点”和“另一个链表”。和单链表逆序的递归一样，核心是“信任递归能解决子规模更小的问题”。当然也可以用迭代，用哨兵节点当新链表的头，逐个挑选较小节点挂上去。两种都值得写一遍，对比着看，你对“递归怎么把问题拆小”的体会会深很多。

5.3 概念与复杂度：这些送分题可不要丢

除了手写代码，考试和面试还经常考一些概念性内容。最容易丢分的是“顺序表和单链表的比较”。我把对比表放这里，考前可以多扫几眼：

另外还要记住几个复杂度：对于带头结点的单链表，头插O(1)，尾插如果不维护尾指针是O(n)，维护尾指针可以做到O(1)；查找第i个节点最坏O(n)；删除某个已知节点的后继节点，只需要O(1)就能完成，因为只改前驱的next。这些数字不是死记硬背，而是从“是否需要遍历”推导出来的，理解了就忘不掉。

5.4 资料与学习顺序：教材、网课和刷题怎么搭配

很多人在“数据结构怎么学”这件事上买了三四本资料，结果一本都没吃透。我自己的经验是：选一套主线教材足够。像严蔚敏的《数据结构（C语言版）》和王道考研系列，都是围绕考研和课程体系来的，结构比较完整，适合从头读到尾。配合一个讲题节奏合适的网课来听，比如在B站能找到的完整数据结构课程，用来帮你把教材里抽象的段落转化成具象的画面。

进阶阶段再去LeetCode或类似平台刷“链表”标签下的题目。但注意，刷题和做实验报告并不完全一样。实验报告要求你把初始化、销毁这些细节全部写清楚，考察的是“你会不会管理内存、会不会处理边界”；而OJ和面试题通常默认你有一个完整的链表类或节点类，只考你某个核心算法。两种场景都练，才算真正掌握。

学习顺序上我建议这样走：先跟着教材把单链表基础操作手写一遍（至少覆盖建表、插入、删除、查找、销毁），再去看网课里对逆序、合并、双指针这些经典题目的讲解，最后集中刷题巩固。等你把单链表这一章吃透，后面学栈、队列、树都会顺很多，因为它们的本质几乎都是“节点 + 指针”或者“受限的链表/递归结构”。

最后再说几句实在话

做技术这些年，我见过太多同学期末前临时抱佛脚，把链表代码背得滚瓜烂熟，可考试稍微换一种问法就懵了。链表这种结构，最忌讳的就是“背代码学”。我现在自己写链表时，依然会在动手前先画一张小示意图，标注清楚prev、curr、next各指向谁，画完再写代码，基本一遍过。这个习惯看起来笨，但在处理比较复杂的链表操作时能节省大量调试时间。

如果你正在准备实验报告，我的建议是：不要直接抄网上的代码，先自己把带头结点的空链表初始化写出来，再一步步补上头插、尾插、查找、插入、删除和销毁，运行有问题就按我第三部分的方法打印指针状态来排查。把这套流程完整走完一遍，你对链表的理解会远远超过“看会了”的同学。以后不管是用C、C++还是Python，再遇到链表相关的问题，你都不会再慌。