单链表实战指南：从指针原理到核心操作详解

很多初学数据结构的人，一碰到“单链表”三个字就开始紧张，再叠加“指针”“动态内存”这两个C语言里的劝退大户，心态直接崩了。我在带本科课程、帮实习生看代码的时候，见过太多次这样的场面：概念背得滚瓜烂熟，一上手写链表题就翻车，不是断链就是内存泄漏，最后盯着报错发呆，完全不知道该从哪下手。

这篇文章想把单链表从头到尾讲透。从它到底解决了什么问题、指针和malloc在背后做了什么，到每一个核心操作怎么写、对应哪个容易踩的坑、用什么工具排查，全部按我在真实项目里验证过的方式来讲。无论你是刚学数据结构的学生、正在备战期末考试还是研究生入学考试，这份内容都能直接拿去用。你只需要照着思路敲一遍代码，再回来看这篇文里提到的“为什么”，对链表的理解会上一个台阶。

1. 为什么单链表是数据结构绕不开的第一关

1.1 数组的局限与链表的破局

很多人学链表都有一个疑问：数组用得好好的，为什么还要发明链表？这个疑问背后其实藏着理解链表的关键。数组的底层本质是一块连续内存，它读任何一个元素只需要通过下标计算偏移，时间复杂度是O(1)，这是它最大的优点。但连续内存带来的代价是插入和删除都很痛苦。举个最简单的例子：数组长度为10万，你想在头部插入一个元素，后面99999个元素全部要往后挪一格，这个操作的时间复杂度是O(n)。如果反复插入，性能会非常难看。

更麻烦的是扩容问题。数组在定义时就得确定容量，运行时发现不够了，只能重新申请一块更大的内存，把旧数据整体拷贝过去，然后释放旧空间。这个动作同样要付出昂贵的复制成本。对开发者来说，这种“容量上限”是一个很烦的约束，因为你永远不知道运行时会面临多大的数据量。

链表的思路则是彻底换个玩法：既然连续内存这么难伺候，干脆不要求连续。每个节点只保存两样东西，一个是真正有用的数据，另一个是“下一个节点的地址”。数据在内存里各放各的位置，靠地址一项一项串起来。插入和删除时只需要调整指针的指向，完全不用搬动其他数据，时间复杂度降到了O(1)。但代价是随机访问变慢了，你想找第k个元素，数组可以一步跳过去，链表只能从头一个个往后数，时间复杂度是O(n)。

这就是链表的价值所在，用“读的慢”换“写的快”。单链表又是所有链表形态里最基础、最核心的一种。只要把单链表吃透，后面再遇到双向链表、循环链表、跳表，甚至LRU缓存这类应用，本质上都是“在单链表的基础上多加几根指针”而已。

1.2 单链表的完整概念拆解

单链表在结构上只需要搞懂三件事：节点怎么定义、节点怎么串联、头节点怎么管理。

先看节点定义。在C语言里，单链表节点通常长这样：

c复制typedef struct Node {
    int data;              // 数据域，保存实际数据
    struct Node *next;     // 指针域，保存下一个节点的地址
} Node, *LinkedList;

很多人第一次看到 struct Node *next 会被绕晕，心想一个结构体里怎么还能包含自己？不是无限递归吗？其实它存的不是一个完整的 Node，而是一个地址，一个“指向同类型节点”的地址。你可以把它想成每个人的手里都握着一张卡片，卡片上写着下一个人住在哪，而不是把下一个人整个人绑在身上。顺着这一张张卡片，就能一个接一个找到所有人。

链表的“头”也很有讲究。这里要先分清两个概念：头指针和头节点。头指针是一个指针变量，它保存的是链表第一个节点的地址。头节点则是链表里的一个哨兵节点，它不存真实数据，它的 next 才指向第一个真正有数据的节点。我在工程实践里几乎总是用带头节点的写法，原因后面会详细解释。头节点的 data 一般不用来存东西，有些教材喜欢拿它存链表长度，但我不太推荐，因为这样会把“数据节点”和“管理节点”混在一起，调试时容易造成误解。

1.3 适用场景：什么时候真的该用链表

很多初学者有个误区，觉得链表比数组“高级”，于是不管什么场景都硬上链表。这是不对的。数据结构的选择一定要看场景需求，链表的优势集中在以下几类情况里。

第一，插入和删除非常频繁，而且操作位置不确定。比如你经常要在某个中间位置增删元素，数组需要搬动大量数据，链表只需要改两个指针，性能差距非常明显。第二，数据总量事先无法预估，或者波动很大。如果用数组，频繁扩容会导致性能抖动和内存浪费，链表天然支持按需分配节点。第三，应用场景并不需要频繁的随机访问。如果你大多数时候是顺序遍历，或者只关心头部尾部操作，链表的内存布局反而更灵活。

反过来，如果数据量不大、创建后基本只读、需要二分查找、需要充分利用CPU缓存局部性，那数组明显是更合理的选择。真实开发中，数组和链表也经常搭配使用，比如哈希表里用链表解决冲突。搞清楚“什么时候真的该用链表”，你才算不是在背概念，而是真的理解了它的存在价值。

2. 指针与动态内存：先吃透这两块硬骨头

2.1 指针的本质：地址就是门牌号

写单链表绕不开指针，但指针恰好是C语言里劝退率最高的知识点。我的经验是，不要被“指针”这个名词吓住，它本质上就是一个“保存地址的变量”，跟快递单上的地址栏是一个道理。你去朋友家做客，只需要知道门牌号，不需要把整栋楼搬过来。电脑访问内存也是一样，每个变量都住在内存的某个地址上，指针保存的就是这个地址。

int *p = &a; 这行代码里，p 保存的是变量 a 的地址。*p 是“解引用”，意思是通过 p 保存的地址找到那块内存，然后取出或修改里面的值。链表里的 next 字段，就是一个保存“下一个节点地址”的指针变量。整个链表就像一排列队的人，每个人手里攥着下一位的位置线索，你只要拿到第一个人的位置，就能顺着线索一个接一个找到所有人。

深入理解指针，有一个很重要的点需要知道：指针本身也是有类型的。int * 和 char * 虽然都存地址，但它们解引用时读取的字节数不同，int * 移动一步会跳过4个字节（在常见32位或64位平台上取决于int宽度），char * 只跳过1个字节。链表的节点指针类型必须是 struct Node *，这样移动一步才能准确跳到下一个节点。这种“类型决定了步长”的机制，是C语言指针最微妙的特性之一。

2.2 malloc/free的核心机制与配对原则

动态内存分配是链表真正“活”起来的前提。链表的节点数量在编译时无法确定，只有在程序运行过程中才知道要创建几个节点，所以必须使用 malloc 在堆上申请内存。

c复制Node *newNode = (Node *)malloc(sizeof(Node));
if (newNode == NULL) {
    // 申请失败，需要处理
    return;
}

这个操作看似简单，其实包含三个关键点，每一步都有讲究。第一，申请大小必须用 sizeof(Node)，不要自己去猜数字。有人图省事直接写 malloc(8)，一旦结构体里加了一个字段，内存就不够用，后续写入越界，排查起来非常痛苦。第二，malloc 返回的是 void *，C语言里可以隐式转换成其他指针类型，但C++里必须显式强转。为了代码在两种语言下都能编译，统一的写法是 (Node *)malloc(...)。第三，必须检查返回值。很多人考试或平时练习时嫌麻烦不写判断，但在真实工程里，malloc 失败后会返回 NULL，如果你不检查直接强行解引用，程序会立刻崩溃。

有 malloc 就有 free，而且二者必须配对出现。申请了多少块内存，就要在合适的时机释放多少块，否则就是内存泄漏。内存泄漏在短时间运行的小程序里看不出影响，但换成一个需要长期运行的服务，内存会被一点一点耗尽，最后崩溃。我曾经接手过一个运行一晚上就吃掉十几个GB内存的进程，查了半天才发现是在循环里反复创建节点但忘记释放。

2.3 二级指针什么时候必须出现

很多新手一看到二级指针就头皮发麻，觉得指针已经够难了，怎么还有指向指针的指针。其实二级指针解决的是一个非常明确的问题：当你想在函数内部修改调用者传入的指针变量本身时，就必须传二级指针。

举一个最典型的例子。假设你写了一个头插法函数，想要往链表头部插入新节点，如果函数的参数是 Node *head，那么在函数内部对 head 重新赋值，是不会影响外层变量的。因为C语言参数是值传递，函数拿到的只是head指针的一个拷贝，你修改拷贝的指向，原指针纹丝不动。

解决办法有两种。一种是函数返回新的头指针，调用方接收返回值：head = insertHead(head, data);。另一种就是传二级指针：

c复制void insertHead(Node **head, int data) {
    Node *newNode = (Node *)malloc(sizeof(Node));
    newNode->data = data;
    newNode->next = *head;
    *head = newNode;
}

Node **head 的意思是：head本身是一个指针变量，它里面保存的是另一个指针的地址。*head 取出来的，才是真正的链表头指针。很多刚接触二级指针的人觉得绕，宁可返回新头也不愿用二级指针，这完全可以理解。但我还是建议把二级指针搞懂，因为很多标准库、框架代码、面试参考解都采用这种写法。搞懂它的瞬间，你对“传地址才能改变量”这句话的理解会加深一层，以后再看复杂的C代码会轻松很多。

2.4 内存泄漏与悬空指针的前世今生

动态内存操作有几个典型的坑，我最想提前提醒大家的就是这两类：内存泄漏和悬空指针。

内存泄漏指的是“申请了内存但没释放”，导致系统堆内存越用越少。比如删除链表节点时，你只顾着把指针改写，让前驱节点跳过待删节点，但忘了 free 那个节点，它就变成了一片被占用却再也找不到的内存。这不是马上出问题的Bug，而是一个“慢性病”，运行越久越严重。

悬空指针则是“释放了内存但指针还指着一块已经回收的区域”。free(p) 执行完之后，p这个变量的值并没有被清空，它仍然保存着那块内存的地址。但这块内存已经还给系统了，你再去访问它，行为是未定义的，轻则读出脏数据，重则直接段错误。这种Bug非常难查，因为它的表现可能是随机的，有时候能打印出错误的值，有时候又看起来完全正常。

我自己写链表代码时会养成三个习惯：第一，free 之后立刻把指针置为NULL，防止误用；第二，删除节点之前先把下一个节点的地址保存下来，再执行free，避免指针丢失；第三，每次写完链表操作，不管看起来有没有问题，都用内存检查工具跑一遍，确认没有遗漏。

3. 单链表核心操作实战：每个节点都是精细活

3.1 结构定义与带头节点的初始化

正式开始写操作之前，需要明确一点：这一节所有的代码都采用带头节点的写法。为什么带头节点？因为带头节点之后，插入、删除、遍历在边界处理上都能统一，代码逻辑明显更简洁。你可以把头节点想象成一个“哨兵”，它永远站在那里，真实数据排在它后面，这样即使在空链表中操作，也不会出现“头指针为NULL”的尴尬场景。

首先定义节点并完成初始化：

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

Node *initList() {
    Node *head = (Node *)malloc(sizeof(Node));
    if (head == NULL) {
        exit(EXIT_FAILURE);
    }
    head->data = 0;
    head->next = NULL;
    return head;
}

注意，头节点初始化时 next 必须置NULL，这一步不能省。很多人创建完头节点就忘了置空，后续遍历时循环条件 p->next != NULL 会因为随机值而判断错误，导致越界访问。exit(EXIT_FAILURE) 在 malloc 失败时直接终止程序，这在小练习里是合理的处理方式，但如果是写库代码，建议改成返回错误码或者调用统一的错误处理函数。

3.2 头插法与尾插法：两种最基本的插入方式

头插法是在头节点后面插入新节点。代码很简洁：

c复制void insertHead(Node *head, int data) {
    Node *newNode = (Node *)malloc(sizeof(Node));
    if (newNode == NULL) {
        return;
    }
    newNode->data = data;
    newNode->next = head->next;
    head->next = newNode;
}

头插法的精髓在于执行顺序：必须先让新节点的 next 指向原来第一个数据节点，再把头节点的 next 指向新节点。口诀就是“先接后断”——先把新节点接到原链表上，再把头节点切换过来。如果顺序反了，先执行 head->next = newNode，那么原链表的首个节点就丢了，再执行 newNode->next = head->next 只会让新节点指向它自己，形成环。

尾插法需要先找到最后一个节点，再在它后面接上新节点：

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

尾插法保持了输入顺序，但每次都要O(n)找到尾节点。如果在实际项目中频繁尾插，一个常见的优化是额外维护一个 tail 指针，每次插入后更新它，让尾插的复杂度降到O(1)。头插法和尾插法有一个容易忽视的区别：假如你依次插入1、2、3，头插法最终链表里是3、2、1，尾插法是1、2、3。这个细节在有些需要用链表实现链栈、链队列的场景里很有用。

3.3 按位置插入与删除：指针重连的关键细节

按位置插入需要先找到第pos-1个节点，也就是目标位置的前驱，然后在它之后插入。这里有一个很容易搞混的地方：在带头节点的链表里，位置0通常表示第一个数据节点，所以循环从0开始计数。

c复制int insertPos(Node *head, int pos, int data) {
    Node *p = head;
    int cnt = 0;
    while (p != NULL && cnt < pos - 1) {
        p = p->next;
        cnt++;
    }
    if (p == NULL) {
        return -1;  // 位置非法
    }
    Node *newNode = (Node *)malloc(sizeof(Node));
    if (newNode == NULL) {
        return -1;
    }
    newNode->data = data;
    newNode->next = p->next;
    p->next = newNode;
    return 0;
}

按位置插入的常见错误是循环边界算错，导致新节点插到了错误的位置。我的建议是写完之后，用纸笔画一遍：画几个节点，画好p的移动路线，再对照代码走一遍，通常能发现边界问题。

删除操作的逻辑稍微复杂一点，最核心的一步是“找到待删节点p的前驱prev”，然后让 prev 的 next 直接指向 p 的 next，最后释放 p 的内存。

c复制int deleteByValue(Node *head, int val) {
    Node *prev = head;
    Node *p = head->next;
    while (p != NULL && p->data != val) {
        prev = p;
        p = p->next;
    }
    if (p == NULL) {
        return -1;  // 没有找到
    }
    prev->next = p->next;
    free(p);
    return 0;
}

删除操作里最需要警惕的是：prev->next = p->next 已经完成之后，可千万不要在 free 之前把 p 的指向改了，比如顺手执行一个 p = p->next，那你后面 free 的就是另一个节点了。另外，被删除节点的位置如果是在尾部，p->next 是NULL，prev->next = NULL 会让新的尾节点变成p的前驱，这也正确。很多人一看到NULL就慌，其实NULL也是合法的地址值，链表的终点天然就是NULL。

3.4 查找与遍历：循环条件决定成败

链表查找和遍历的逻辑看起来简单，但循环条件非常容易写错，也是我在代码审查中最常看到的问题之一。

c复制Node *findNode(Node *head, int val) {
    Node *p = head->next;
    while (p != NULL && p->data != val) {
        p = p->next;
    }
    return p;  // 找不到会返回NULL
}

遍历打印则长这样：

c复制void printList(Node *head) {
    Node *p = head->next;
    while (p != NULL) {
        printf("%d ", p->data);
        p = p->next;
    }
    printf("\n");
}

这里最容易踩的坑是循环条件的 NULL 判断位置。如果是“从头遍历到最后一个真实数据节点”，循环条件用 p != NULL；如果是“找到最后一个节点然后在其后插入”，循环条件用 p->next != NULL。前者在p为NULL时退出，最后一个节点会被正常处理；后者在p指向最后一个节点时退出，因为最后一个节点的next是NULL。这两种条件的适用场景不同，搞混了就会出现“打印少一个元素”或者“插入位置偏前一个节点”这种莫名其妙的问题。

3.5 单链表逆序：高频考点现场推演

逆序是单链表操作里最经典的高频考点，很多学校的期末考和研究生入学考试都爱出这道题。核心思路是遍历原链表，每经过一个节点就把它的 next 指向它的前驱。由于指针方向一旦反转，后面的节点就找不到了，所以必须在反转前先保存好下一个节点的地址。

c复制Node *reverseList(Node *head) {
    Node *prev = NULL;
    Node *curr = head->next;
    while (curr != NULL) {
        Node *nextNode = curr->next;  // 先保存下一步的地址
        curr->next = prev;            // 反转指针
        prev = curr;                  // 前驱后移
        curr = nextNode;              // 当前节点后移
    }
    head->next = prev;                // 头节点接管新的第一个节点
    return head;
}

这段代码的最后一步很容易被人忽略。循环结束后，prev 指向的是原链表的最后一个节点，也就是逆序后的第一个真实数据节点。如果不执行 head->next = prev，头节点还拽着原来的旧指针，链表结构就是乱的。很多人在考试时能写出循环，但忘了接回头部，导致逆序后的链表“看不见”第一个元素。

逆序还有一种递归解法，思路是假设当前节点的后面都已经被逆好了，只需要处理当前节点和它下一个节点的关系。比起迭代法，递归更简洁，但对初学者来说抽象程度更高。面试时最好两种解法都能写，笔试用迭代，讲思路用递归，会让面试官觉得你对这个问题的理解是立体的。

4. 常见错误与调试技巧：我踩过的坑你没必要再踩

4.1 断链事故现场还原

单链表代码写多了，你会发现最常见的故障就是“断链”。断链的意思是链表在某个位置断开，或者形成了一个自己指向自己的环，导致数据丢失或死循环。

断链的头号原因是插入操作里指针赋值的顺序错误。我见过太多这样的写法：

c复制// 错误示范
head->next = newNode;
newNode->next = head->next;

第二行执行时，head->next 已经被newNode覆盖了，所以 newNode->next 指向了newNode自己，链表在第二个节点往后直接丢掉了所有旧数据，而且遍历时还会陷入死循环。这里最扎心的是编译器不会报任何错误，程序甚至能跑，只是结果完全不对。所以写链表插入时，遇到“先改变旧指针再使用旧指针”的操作，一定要停下来想想：我是不是应该先把旧值存起来？

删除操作里也容易出问题。比如你找到了待删节点p，但没有保留p->next，而是直接free(p)，然后试图去访问 p->next，就会访问已经被释放的内存，这种行为完全没有定义。正确顺序是先提取下一节点地址，再做指针重连，最后释放。我自己在带人写代码时，会反复强调一句话：删除操作真正要改的是“前驱节点的next”，不是“待删节点自己的next”。抓住这句话，删除逻辑就顺了。

4.2 空指针崩溃与防御性编程

空指针崩溃大概是链表初学者最熟悉的噩梦。p->next 这种代码，只要p是NULL，程序立刻段错误，而且报错位置往往不是真正出bug的地方，排查起来很费劲。

防御性编程的核心做法很简单：在使用指针前先判断它是否为NULL。查找没找到会返回NULL，删除时遍历到链表结尾也可能得到NULL，这时如果继续访问 p->next，一定会崩。我在写链表相关的函数时，默认会给所有需要解引用的地方加上NULL检查，这个习惯在工程里非常值钱，能为你省下大量调试时间。

还有一个更细节的坑：在遍历链表时同时做删除操作。如果你在循环里发现某个节点符合条件，直接 free(p)，但此时循环体后面还有一句 p = p->next，访问一个已经被释放的内存，同样会出问题。这种情况下，最稳的做法是在free之前先把下一个节点保存下来，或者用 prev->next 绕过待删节点，不要再用p去完成后续迭代。

4.3 内存问题排查三板斧

写链表，尤其是写带动态内存分配的链表，用肉眼查Bug效率极低。我很早就养成了“写完必查内存”的习惯，这里分享我常用的三板斧。

第一板斧是valgrind。Linux下运行 valgrind --leak-check=full ./a.out，它能精确告诉你哪一行malloc的内存没有释放，甚至在程序退出时报告uninitialized value的使用。第二板斧是AddressSanitizer，编译时加 -fsanitize=address，运行时会立即报告内存越界、use-after-free等错误，定位非常准，对内存问题的亲和度比valgrind更高。第三板斧是“printf大法”，在关键位置打印指针信息，比如插入前后分别打印 prev、newNode、head->next 的地址，指针变化过程一目了然。

有些同学觉得用printf太原始，喜欢直接上调试器断点。调试器当然好用，但如果你对链表指针的变化过程没有清晰的图像，断点打到一半你也不知道该看哪里。反而是先把关键地址打出来，配合画图，能把问题锁定到具体某一步。等定位到疑似位置，再开调试器逐步走，效率最高。

4.4 链表问题现场速查表

下面这张表是我在实际教学和开发中总结出来的，拿去对照能找到大部分问题。

5. 从单链表延伸：双向、循环与真实应用

5.1 双向链表与循环链表的改进思路

单链表最大的短板是只能向后走。想象你手中只有一张指向后一个人的卡片，想回到前一个人，你只能从队头重新走一遍。双向链表就是给每个节点再加一个prev指针，让它前后都能走。这样设计的好处是删除节点时不需要再找前驱，直接通过 p->prev 就能拿到，操作更高效。代价是每个节点多一个指针字段，内存开销增加，而且插入、删除时要维护两个方向的指针，代码复杂度明显上涨。

循环链表则是把链表的尾节点指向头节点，让整个链表变成环。从任意节点出发都能遍历完整张表，非常适合需要循环调度的场景，比如操作系统的进程时间片轮转、循环队列的实现。但要注意，循环链表的遍历终止条件不再是 p != NULL，而是 p != 起点，不熟悉的人很容易在写循环条件时翻车。

为什么我会建议先学单链表？因为它最“干净”，只有一个方向的指针约束，所有问题都暴露得清清楚楚。你一旦把单链表里的指针、前驱、边界这些概念搞透，双向链表和循环链表的区别就只是在原有思维上再追加几个细节。

5.2 LRU淘汰算法里的链表身影

链表不只是考试题，它在真实系统里扮演着非常重要的角色，最典型的就是LRU缓存淘汰算法。LRU的全称是Least Recently Used，最近最少使用，核心思想是当内存满了，优先淘汰最久没被访问的数据。

用链表实现LRU的思路非常直观：维护一个链表，越靠近头部的节点表示最近刚被访问过，越靠近尾部表示很久没用了。每次访问一个数据，就把它对应的节点移动到链表头部；当链表满了，就把尾部节点删掉。链表的优势在于“移动到头部”和“删除尾部”都只需要O(1)时间，而数组做不到这一点。

当然，实际的工业级LRU会比这个复杂一些，通常会采用哈希表加双向链表组合的方式。哈希表负责O(1)查找，双向链表负责O(1)移动和删除。这也是LeetCode第146题的经典解法。面试时如果你能讲清楚“为什么用双向链表而不是单链表”以及“为什么还需要哈希表”，会是一个非常亮眼的加分项。我们学习链表不只是为了做题，更关键的是培养一种思维：当你在场景里发现“需要频繁增删头尾元素”，第一反应就应该是链表。

5.3 链表思想在其他语言中的形态

很多人学完C语言的链表，会冒出这样一个问题：我在Python、Java里还有必要学这个吗？答案是当然有必要。数据结构的思想是跨语言的，语言只是表达方式不同。

Python里的list虽然叫list，但底层实现是动态数组，不是链表。想体验链表思想，一般用 collections.deque，它内部是双向链表实现，支持两端O(1)的append和pop。如果你用Python刷LeetCode链表题，代码里照样会出现 class ListNode 和 next 指针，和C语言里的思路完全一致，只是换了一种语法。

Java里的 LinkedList 类内部就是双向链表，提供了 addFirst、addLast、removeFirst 等接口。Redis里的quicklist也是链表和压缩列表的组合，用来在内存效率和操作效率之间取平衡。这都说明链表结构不仅没有过时，反而在很多高性能组件里扮演核心角色。你学的是C语言版的单链表，掌握的却是普适的数据结构思想，这件工具以后走到哪里都用得上。

6. 把单链表学透的最后一公里

6.1 指针是工具，别怕它

我教了这么多年，最大的感触是：指针难不在语法，而在抽象。你盯着代码里的 next，脑海里看不到内存，自然觉得虚。克服办法其实非常朴素：画图。把每个节点画成一个方块，方块里写上地址、data、next指向哪个节点，然后拿着纸笔一步步推演代码。这个方法听起来简单，但确实是我见过最有效的破解方式。很多学生用完之后跟我说，原来指针没那么玄，只是自己之前没把“地址”和“指向”画清楚。

6.2 操作的本质：前驱与后驱

如果要把单链表的所有操作浓缩成一句话，我会说：链表操作的本质，就是对前驱节点的操作。插入时，你操作的是前驱的next；删除时，你操作的还是前驱的next；逆序时，你改变的是每个节点next的指向。抓住“前驱”这个视角，再去写代码就不会东改一个西改一个，思路会很清晰。

6.3 动态内存是双刃剑

动态内存让链表拥有了灵活增删的能力，但也带来了内存泄漏和悬空指针这两大风险。学会用工具定期检查内存，是每个写C程序的人都必须养成的好习惯。不要觉得这只是“工程里才讲究”，考试时虽然不太考内存检查，但你对内存细节的理解程度，往往体现在你能不能解释清楚“为什么free之后要把指针置NULL”这类问题上。

最后分享一个我保持了很多年的习惯：写完任何一个链表操作，我都会用笔画出指针变动图，再对着图把代码走一遍。虽然现在是IDE调试器的时代，但画图这件事能帮我真正理解指针的走向，让我在写复杂链表操作时始终有底气。数据结构这东西，第一遍看不懂就画图，看完图还看不懂，就把代码一句一句念给自己听，多来几遍，一定会通透。