SeigRobotics决定啃Algorithms_4th的人，十有八九会卡在第一章的链表练习题上。这本书的课后题不像一般的"填空题式"数据结构练习，它经常用一句话描述场景，然后让你自己设计API、处理边界情况。书里给的参考实现是Java，很多人习惯性地把Java代码直接翻译成C++，结果发现处处踩坑：对象引用变成了指针、垃圾回收变成了手动delete、while循环里的空指针判断漏了一条就整段崩溃。我自己当时刷这本书的1.3节时，链表相关题目前前后后写了不下十遍，每次重写都能发现新的细节错误。
这篇博文不打算把书里的题号从1.3.19一道道念到1.3.48，而是按操作类型把链表练习题重新归类，每一类都给出C++实现时的核心思路、容易出错的边界条件，以及我在调试过程中总结出来的排查经验。内容会覆盖单链表、双链表、循环链表，以及基于链表衍生的快慢指针、递归反转、有序合并等问题。无论你是正在跟这本书死磕的学生，还是准备面试想快速复习链表操作的开发者，这篇文章的思路和代码段都可以直接拿去用。
1. 链表练习的整体设计与思路拆解
1.1 为什么链表练习是算法入门的真正分水岭
很多人学数据结构时，数组和链表是"听懂了、一写就废"的两兄弟，但链表尤其容易废。原因很简单：数组的操作完全依赖下标，你的脑子可以自动把数组想象成一排抽屉，操作哪一格、移动哪一格，非常直观。链表不一样，它没有"第几个"这种天然索引，访问任意节点只能从头指针开始一个next一个next地走过去。这种"只能顺藤摸瓜"的访问方式，和人类平时处理随机访问数据的直觉是相反的。
Algorithms_4th把链表练习放在第一章，目的不只是让你学会"增删查改"这四件事。它真正想训练的是你处理间接引用和别名的能力。一个节点里存放着next指针，意味着你手里持有的可能只是前一个节点的地址，而不是目标节点的地址。删除一个节点时，真正改的是前驱节点的next字段，而不是你当前指针指向的那个节点本身。这种"通过别人来操作目标"的思维模式，是后续学习二叉搜索树、红黑树、图邻接表等所有复杂数据结构的共同底层逻辑。
我在练习时最大的体会是：链表题写错，绝大多数不是语法错误，而是"在错误的层级上操作了指针"。理解了这一点，你就明白为什么书上不断要求你用"只给定头节点""只给定某个节点的引用"这类限制条件来设计API了——它逼你在受限条件下，重新理解数据结构的内部结构。
1.2 C++实现与Java实现的本质差异
Algorithms_4th书上的参考代码是Java，如果你照着它的函数签名改成C++，第一个坑就是参数传递。Java里引用类型天然就是"对象地址"，方法内修改引用指向的对象的字段，调用方是能感知的。C++则把这个能力拆分成了几个不同的写法：指针、引用、指针的引用、指针的指针……每一种都有完全不同的语义。
举一个最典型的例子：删除链表的第一个节点。Java代码可以简单写：
java复制public void deleteFirst(Node node) {
node = node.next;
}
很多初学者以为这部分C++也能直接照搬：
cpp复制void deleteFirst(Node* node) {
node = node->next;
}
这个函数执行完，外面的头指针根本不会变。因为node是外面头指针的一个拷贝，你这么一改，只是让这个局部变量换了个指向，外面的指针还站在原地。要在C++里真正改变外部的头指针，必须用Node**或者Node*&：
cpp复制void deleteFirst(Node** head) {
if (*head == nullptr) return;
Node* tmp = *head;
*head = (*head)->next;
delete tmp;
}
这是C++链表练习里最容易踩的坑，没有之一。我当年把1.3.19（删除尾节点）的题目写完，编译过了、运行也没崩溃，但头节点莫名其妙丢了，排查了半小时才发现是函数参数传递层级的问题。
另一个差异是内存管理。Java有垃圾回收，你不需要考虑节点对象什么时候被销毁。C++里，new出来的节点如果不手动delete，就会泄漏；但如果delete太早，又会出现悬垂指针。所以用C++写链表练习，你不仅要考虑算法的正确性，还要考虑每一条代码路径上的内存生命周期。这也是为什么很多公司在面试C++岗位时，特别喜欢靠链表题来考察候选人的综合素质：既要逻辑正确，又要内存管理正确。
1.3 做练习题之前先建立一个测试小框架
Algorithms_4th的链表练习没有自动判题系统，很多人写完代码直接扔一边，过两天回头一看，不知道对不对。我建议你在动手写题之前，先花十分钟写一个极简的测试辅助函数，后面所有题目都用它来验证。
对我来说，这个辅助框架包含三个函数：一个根据数组值构建链表、一个打印链表全部内容、一个释放链表全部节点。核心代码大概长这样：
cpp复制#include <iostream>
#include <vector>
struct Node {
int val;
Node* next;
Node(int v = 0, Node* n = nullptr) : val(v), next(n) {}
};
void printList(Node* head) {
while (head) {
std::cout << head->val;
if (head->next) std::cout << " -> ";
head = head->next;
}
std::cout << std::endl;
}
Node* buildList(const std::vector<int>& values) {
Node dummy;
Node* tail = &dummy;
for (int v : values) {
tail->next = new Node(v);
tail = tail->next;
}
return dummy.next;
}
void destroyList(Node* head) {
while (head) {
Node* next = head->next;
delete head;
head = next;
}
}
注意两个细节。buildList用了dummy节点，也就是哑节点技巧，这样构建时不需要单独处理头节点为空的特殊情况。destroyList必须先把next存下来再delete，否则你删除了当前节点之后，再去访问它的next就属于访问已被释放的内存，属于典型的未定义行为。
有了这套小框架，每道题写完直接构造一个链表，跑一遍看输出，再跑一遍检查有内存泄漏。效率会高非常多。
需要模型API调用？ 免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。
2. 单链表核心操作的C++实现细节
2.1 节点结构定义的选择与构造函数设计
C++里定义链表节点，可以从struct起步，也可以从class起步，各有各的偏好。我的习惯是struct，因为链表节点本质上就是一个聚合体，需要公开访问val和next，用struct语义上更直白。而且Algorithms_4th的Java版本用的是内部类或者直接公开字段，从风格上继承过来，struct更自然。
构造函数建议直接写成带默认参数的形态：
cpp复制struct Node {
int val;
Node* next;
Node(int v = 0, Node* n = nullptr) : val(v), next(n) {}
};
默认参数的好处是：new Node(42)可以创建值为42、next为空的节点，new Node(42, oldNode)可以创建指向已有节点的节点。大量题目里你需要"用前一个位置的值来初始化新节点"，这种构造函数写起来会方便很多。
有些参考书为了讲解方便，会省略构造函数，直接Node* n = new Node; n->val = 42; n->next = nullptr;这样三步来创建节点。做题可以，但代码非常啰嗦。而且一旦忘了初始化next，就会产生一个野指针，后面遍历时直接崩溃。有构造函数强行兜底，能省掉一大类低级错误。
2.2 插入操作分为"插在头部""插在尾部""插在中间"三种场景
插在头部是最简单也最能说明C++指针层级问题的操作。要在头节点前面插入新节点，必须更新外部持有的头指针，所以函数签名推荐用Node**或传引用：
cpp复制void insertFront(Node** head, int value) {
Node* newNode = new Node(value);
newNode->next = *head;
*head = newNode;
}
为什么要先让newNode->next = *head再去更新*head？顺序反了会怎样？假如你先执行*head = newNode，原来的头节点就再也找不到了，newNode->next想指向原来的头节点时，已经没有任何指针可以访问它。所以在链表操作里，"先把新节点和新位置的连接建立好，再去动旧指针"是个通用原则。
插在尾部需要先遍历到最后一个节点，然后让尾节点的next指向新节点。这里有个细节：遍历终止条件是tail->next != nullptr还是tail != nullptr？如果写成while (tail)，循环结束时tail已经是空指针，你丢失了尾节点的地址，也就没法把它和新节点连起来。正确写法是：
cpp复制void insertBack(Node* head, int value) {
Node* tail = head;
while (tail->next) tail = tail->next;
tail->next = new Node(value);
}
插在中间指定位置是练习里最常见的变体，例如"在第k个节点后面插入"。常规做法是遍历k步，到达目标位置的前一个节点，然后操作。这个位置非常重要，因为链表的核心操作都依赖"待操作位置的前驱节点"。如果你直接拿着"目标节点"的指针做插入，新节点只能插到它前面，但问题是你并不知道目标节点的前驱是谁。所以，一切插入和删除，本质上都是在处理目标位置的前驱节点。
2.3 删除操作与空指针保护的边界分析
删除操作的经典变体包括：删除头节点、删除指定值的第一个节点、删除所有指定值的节点、删除尾节点。每一种的核心都是找到前驱，然后再修改next。
删除所有指定值的节点，是几道练习题中难度跨度最大的。初版代码很容易写成这样：
cpp复制void removeAll(Node* head, int key) {
Node* cur = head;
while (cur && cur->next) {
if (cur->next->val == key) {
Node* tmp = cur->next;
cur->next = cur->next->next;
delete tmp;
} else {
cur = cur->next;
}
}
}
这个函数的问题在于：如果头节点本身就是要删除的值，它会被漏掉。需要单独处理头部，或者更优雅的做法是引入dummy节点：
cpp复制Node* removeAll(Node* head, int key) {
Node dummy;
dummy.next = head;
Node* cur = &dummy;
while (cur->next) {
if (cur->next->val == key) {
Node* tmp = cur->next;
cur->next = cur->next->next;
delete tmp;
} else {
cur = cur->next;
}
}
return dummy.next;
}
哑节点技巧在链表操作里非常强，它把"头节点也可能被删"的特殊情况，统一成了"和中间节点完全一样"的常规情况。题目中凡是涉及"可能修改头节点"的，建议一律用哑节点。注意这里函数返回的是新的头节点指针，因为原头节点可能已经被删掉了。
删除尾节点时，你同样需要找到倒数第二个节点，而不是最后一个节点。遍历条件要写成while (cur->next->next)，找到倒数第二个节点后，保存尾节点，释放它，再把倒数第二个节点的next置空。有没有想过为什么不能只用一个指针遍历到尾部然后直接delete？因为你还得把新尾节点的next赋成nullptr，而且如果链表只有一个节点，你还需要把外部头指针置空。这些都是边界情况，也是练习题的考察重点。
3. 经典练习题逐题拆解与C++实现要点
3.1 反转链表：迭代法与递归法两种路径
反转链表可能是链表练习题里讲解最多的一道，但很多人只看懂了代码，没有真正理解两种写法各自的前提条件。Algorithms_4th的1.3.30就是这道题，要求实现链表的反转。先看迭代版：
cpp复制Node* reverse(Node* head) {
Node* prev = nullptr;
Node* cur = head;
while (cur) {
Node* nextNode = cur->next;
cur->next = prev;
prev = cur;
cur = nextNode;
}
return prev;
}
核心思想是：每到一个节点，先把它的下个一节点保存下来，因为它把cur->next指向prev后，原本的next就丢了。然后当前节点变成"前驱"角色，继续向后推进。整个过程不需要额外空间，时间复杂度O(n)。我第一次写这个循环时，忘了保存nextNode，直接cur->next = prev，结果链表从中段开始失联，后面的节点全部内存泄漏，程序却在继续跑，最后打印出来只有前面几个逆序节点，后面全部丢失。这个教训印象非常深。
递归版也很经典：
cpp复制Node* reverseRecursive(Node* head) {
if (head == nullptr || head->next == nullptr) return head;
Node* newHead = reverseRecursive(head->next);
head->next->next = head;
head->next = nullptr;
return newHead;
}
理解递归版的关键是：递归函数返回后，newHead是整个链表反转后的新头节点，而head->next指向的是原链表中的下一个节点。此时下一节点已经反转完毕，它的next正好指向原链表更靠后的节点，我们需要做的就是把下一节点的next指回到当前节点，同时把当前节点的next置空。这一步是"把指针掉转方向"的瞬间，也是最容易写成死循环的地方——如果忘了把head->next = nullptr，那么链表的旧头节点（现在是新尾节点）会指回旧次节点，形成一个环。
迭代和递归怎么选？我个人的建议是：面试和练习中以迭代为主，因为不需要担心递归深度，也不会因为调用栈爆掉。但递归版的理解能力非常重要，因为后面很多树形结构问题都依赖同样的"自底向上反转思路"。从代码简洁度上看，递归显然更优雅；从工程可靠性上，迭代更稳。
3.2 快慢指针系列：找中间节点、判断是否有环、找倒数第k个
快慢指针不是Algorithms_4th里直接给出的一个独立话题，但它几乎穿插在每一道与"定位"相关的链表题里。思路其实就一句话：两个指针，一个每步走一格，一个每步走两格，当快指针走到终点时，慢指针正好在中间；当存在环时，快慢指针必定相遇。
寻找中间节点，核心代码如下：
cpp复制Node* findMiddle(Node* head) {
Node* slow = head;
Node* fast = head;
while (fast && fast->next) {
slow = slow->next;
fast = fast->next->next;
}
return slow;
}
注意循环条件是fast && fast->next，不能只写fast。因为如果链表长度为奇数，fast会在最后一个节点停下，这时候循环还可以继续，但下一轮fast->next就是空指针，再去访问fast->next->next就崩溃了。所以必须同时检查fast和fast->next都不为空。
判断环的写法类似，只是退出条件不同：
cpp复制bool hasCycle(Node* head) {
Node* slow = head;
Node* fast = head;
while (fast && fast->next) {
slow = slow->next;
fast = fast->next->next;
if (slow == fast) return true;
}
return false;
}
如果存在环，快指针终会在某个时刻和慢指针相遇。为什么不是快指针永远在绕圈、慢指针永远在后面追不上？因为每次循环快指针都比慢指针多走一步，相当于相对速度是每轮缩短1步的距离，当这个距离被缩短到0时，两指针就会指向同一节点。这是一个经典的数学结论，也是快慢指针最奇妙的地方。
找倒数第k个节点，做法是把快指针先走k步，然后慢指针从头开始走，快慢同步前进，当快指针到达末尾时，慢指针正好在倒数第k个。这里比较容易忽略的边界是：当k大于链表长度时，快指针会先走到空指针，此时应该直接返回nullptr或者抛出异常，而不是继续执行后面的循环。
3.3 删除重复节点：链表的去重操作
删除有序链表中重复节点的题，虽然Algorithms_4th没有单独编号强调，但它和1.3.26（删除所有指定key）高度相关，而且面试非常高频。有序链表的去重写法是：
cpp复制Node* removeDuplicates(Node* head) {
if (!head) return nullptr;
Node* cur = head;
while (cur && cur->next) {
if (cur->val == cur->next->val) {
Node* tmp = cur->next;
cur->next = cur->next->next;
delete tmp;
} else {
cur = cur->next;
}
}
return head;
}
这种去重方式只保留每个重复值中的一个，删除后续所有重复节点。如果题目要求"删除全部重复值"，即一个都不保留，就需要在dummy节点上做文章，同时比较相邻三个节点的状态，逻辑会复杂一截。这个变体可以作为练习时的加分项自己做一遍。
我个人的建议是：不要只满足于写出一个版本。把"保留一个"和"全部删除"两种版本都写一遍，你会发现后者对dummy节点和prev节点的使用要求更高，写下来对指针操作能力的提升非常明显。
3.4 两数相加与逆向链表的实际应用
1.3节里没有直接出现"两数相加"的题，但它天然契合链表练习的旨意：数字按位逆序存储在链表中，每个节点存一位，让你实现两个数的加法并返回结果链表。这种题既可以考察链表遍历，也可以考察进位处理和边界场景。
核心思路是：同时遍历两个链表，每一位上的值等于l1->val + l2->val + carry，当前节点值等于该和模10，进位等于除以10向下取整。循环结束后，如果carry不为0，还要额外接一个值为1的新节点。
cpp复制Node* addTwoNumbers(Node* l1, Node* l2) {
Node dummy;
Node* tail = &dummy;
int carry = 0;
while (l1 || l2 || carry) {
int sum = carry;
if (l1) { sum += l1->val; l1 = l1->next; }
if (l2) { sum += l2->val; l2 = l2->next; }
carry = sum / 10;
tail->next = new Node(sum % 10);
tail = tail->next;
}
return dummy.next;
}
注意循环条件我写成了l1 || l2 || carry，三个条件同时判断，这样就自动处理了"两个链表长度不一致"和"最终还有进位"的所有边界情况，不需要在循环结束后再单独补一次。写这种代码时，要刻意训练自己"把边界情况纳入主循环"的思维方式，而不是每次跑完了发现漏了一种情况，然后再补一段if代码。这种思维习惯对刷所有算法题都有帮助。
3.5 有序链表的合并与排序变体
合并两个有序链表，是Algorithms_4th中归并排序思想在链表上的直接应用。一种常见写法是递归：
cpp复制Node* merge(Node* a, Node* b) {
if (!a) return b;
if (!b) return a;
if (a->val <= b->val) {
a->next = merge(a->next, b);
return a;
} else {
b->next = merge(a, b->next);
return b;
}
}
递归的优点是代码极短、逻辑清晰。缺点是当链表很长时，会有递归深度开销。如果想写成迭代版，核心思路是引入dummy节点，每次从两个链表中挑一个较小的节点接到新链表尾部，直到某一方为空，然后把另一方的剩余节点整体接过去。
值得一提的是，如果链表本身无序，要求你用O(n log n)的时间复杂度做排序，那就可以用归并排序的思路：先找中点，把链表切成两半，分别排序，再合并。这个过程中，快慢指针找中间节点、递归切分、有序合并这三个技巧会被全部串起来。我强烈建议把这道综合题作为所有链表练习的收官题目，因为它几乎把链表的所有基础操作都覆盖了一遍。
4. 双链表与循环链表的练习要点
4.1 双链表：指针更新顺序是练习题的核心陷阱
双链表每个节点有两个指针：prev和next。Algorithms_4th的1.3.31要求实现双链表。表面上只是多了一个指针，实际上操作复杂度上升了一大截，因为任何一个插入或删除操作，都可能需要同时更新两个方向上的指针。
双链表插入到指定节点之前，一般步骤是：
cpp复制void insertBefore(Node* node, int value) {
Node* newNode = new Node(value);
newNode->prev = node->prev;
newNode->next = node;
if (node->prev) node->prev->next = newNode;
node->prev = newNode;
}
这里有一个必须遵守的更新顺序问题：先把新节点的前后连接全部搭好，再去修改原链表中两个旧节点的指针。如果顺序写反，比如先执行node->prev->next = newNode再把newNode->prev赋成旧前驱，本身结果也一样，但如果你边写边调试，很容易因为中间态混乱而出错。固定一套"先新节点、后旧节点"的顺序，能显著降低心智负担。
双链表删除节点就简单一些，因为不需要找前驱：
cpp复制void removeNode(Node* node) {
if (node->prev) node->prev->next = node->next;
if (node->next) node->next->prev = node->prev;
delete node;
}
这种操作是单链表做不到的——单链表删除一个已知节点时，如果不知道它的前驱，需要从头遍历才能找到。而双链表在节点结构里天然保存了前驱信息，所以删除操作的时间复杂度是O(1)。这也是双链表存在的核心意义。
4.2 循环链表与约瑟夫问题的实现
循环链表是把尾节点的next重新指向头节点，形成一个环。约瑟夫问题是一个经典的循环链表应用：n个人围成一圈，从某个人开始报数，报到m的人出局，然后从下一个人重新报数，直到只剩一个人。
用C++实现时，一个常见的选择是使用循环链表来模拟这个过程：
cpp复制int josephus(int n, int m) {
Node* head = new Node(1);
Node* tail = head;
for (int i = 2; i <= n; i++) {
tail->next = new Node(i);
tail = tail->next;
}
tail->next = head; // 成环
Node* cur = tail; // 从头节点的前驱开始，方便删除
while (cur->next != cur) {
for (int i = 1; i < m; i++) {
cur = cur->next;
}
Node* victim = cur->next;
cur->next = victim->next;
delete victim;
}
int result = cur->val;
delete cur;
return result;
}
注意这里cur初始化成tail而不是head。为什么？因为每次要删除的是"报数到m的那个人"，而删除操作需要知道被删节点的前驱。如果从head开始，第m个人是head，删除它时没有前驱可以改。所以干脆把cur初始化为尾节点，也就是头节点的前驱，这样就统一了"删除节点"的方式，不需要单独处理头节点被删的情况。
学习这个例子时，值得关注的是"循环"概念带来的边界变化。普通链表遍历终止条件通常是cur == nullptr或cur->next == nullptr，而循环链表遍历的终止条件是cur->next == cur或回到了起始节点。这种思维切换在后续处理环形缓冲区、循环队列时非常有用。
4.3 单链表和双链表的选择考量
做题时我经常被问到"既然双链表功能这么全，为什么还需要单链表？"回答这个问题的关键不是"单链表结构简单"这种套话，而是从内存占用和局部性两个角度理解。
单链表每个节点只存一个指针，双链表存两个指针。在节点数量很大时，额外那8字节（64位系统上的指针大小）对内存占用和缓存命中率都有影响。再考虑到单链表做插入和删除时，必须经过前驱才能找到目标，这虽然限制了很多操作，但也让它的结构调整更少、不容易出错。
实际工程里，像Linux内核的list_head其实是一种双向循环链表，因为内核需要快速删除任意节点；而简单的队列、栈这种只在端点操作的结构，用单链表就够了。你写练习时不需要过度纠结选型，但每做完一道题，可以想一想"如果用另一种链表，题目会变得更简单还是更复杂？"这种对比思考对加深理解非常有益。
5. 常见问题与调试经验实录
5.1 野指针、重复释放、死循环是三大高频bug
链表题写错，通常不是算法思路错，而是C++具体操作导致的内存问题。我在练习和帮别人看代码的过程中，总结出三大高频bug。
第一个是野指针。常见场景是：删除节点后没有把某个持有的指针置空，后面又访问了它。比如你写了Node* tmp = cur->next; cur->next = cur->next->next; delete tmp;，如果后续不小心又访问了tmp->val，那就属于对已释放内存的访问。这种问题有时不会立刻崩溃，而是在数据量大时才偶发，非常难排查。好的习惯是：删除节点之后，如果后续还有引用它的指针变量，及时置nullptr。
第二个是重复释放。典型场景是在同一个函数里，既手动释放了节点，又调用了destroyList，导致同一个节点被delete两次。这在C++里属于未定义行为，轻则运行报错，重则直接crash。我自己的解决方法是：一个链表从头到尾只用一套释放逻辑，不混用；每次delete节点之后，心里清楚地知道"已释放的节点不再属于当前链表"。
第三个是死循环。如果反转链表时没有保存nextNode，或者合并有序链表时忘记推进某个指针，程序就会陷入死循环。这种情况检测起来不难：打印链表时如果一直输出同一个序列，基本可以断定成环了。还有一个隐蔽的情况是，链表本身没有环，但你的遍历终止条件写错，也会导致无限循环。建议每次写循环前，先问自己一句：这个循环靠什么退出？条件会不会一直为真？
5.2 调试链表问题的实用技巧与方法
用C++写链表题，很多初学者习惯直接在出问题的函数里加printf，但链表这种结构，打印位置信息往往比打印数值更有用。我自己的做法是：设计一个通用的debugPrint函数，除了打印节点的值，也打印当前节点的地址和next指向的地址：
cpp复制void debugPrint(Node* head) {
int index = 0;
while (head) {
std::cout << "idx=" << index
<< " addr=" << head
<< " val=" << head->val
<< " next=" << head->next << std::endl;
head = head->next;
index++;
if (index > 100) {
std::cout << "possible cycle detected" << std::endl;
break;
}
}
}
index > 100这个上限非常重要。如果链表意外成环，普通打印会无限循环，而加上这个上限保护后，你能快速发现"链表内部有环"，而不是被卡死在死循环里。调试阶段这种"防御性打印"可以大幅提升效率。
另外一个实用技巧是用断言来验证不变量。例如，每次删除完节点后，可以检查链表中不存在值为key的节点：
cpp复制// 调试用断言：遍历确认链表中没有值为key的节点
Node* cur = head;
while (cur) {
assert(cur->val != key);
cur = cur->next;
}
如果你在关键操作之后都加上这种断言，跑测试时一旦有任何异常，程序会立刻定位到出错的那一步，而不是在你手工打印完之后才反应过来。
5.3 练习题做完之后如何自己验证正确性
Algorithms_4th没有自动判题系统，这就需要你自己设计测试用例。我的经验是：每个操作至少验证四类场景——空链表、只有一个节点、两个节点、多个节点的长链表。不要觉得"空链表这种边界情况很简单就跳过"，很多指针操作是在空链表上直接崩溃的。
比如你写删除头节点的函数，传入空链表，应该返回空，不能崩溃。又比如删除尾节点时传入只有一个节点的链表，外部头指针要变成空，如果函数只是简单地delete head而没有让外部指针指向nullptr，后面再访问头节点就会出问题。
我还建议用随机数据做压测。写一个小函数生成随机长度的链表，填充随机值，然后对你的操作函数跑成千上万次，每一次跑完都检查整个链表的结构是否合法。比如删除操作后，链表长度应该减一；插入后，长度应该加一。你可以把链表长度作为校验值，配合"无环断言"一起使用，能发现大量手工测试发现不了的边界问题。
5.4 从练习题到面试题：常见扩展与考点
很多面试官喜欢从链表的练习题往外扩展。最常见的扩展包括：判断链表中点、合并K个有序链表、链表排序、复制带随机指针的链表、两两交换相邻节点、反转部分链表这些。这些题目万变不离其宗，核心仍然是那几件事：遍历、定位前驱、操作指针、构建新连接。
如果想提高练习效率，我推荐一种方式：把Algorithms_4th中所有链表题目的要求整理成一个清单，每道题分别用单链表和双链表实现一遍，遇到"给定某个节点指针"的场景，再思考一下如果没有这个限制会怎样。这样反复比较下来，你对"为什么这个操作需要前驱""什么时候能用哑节点"这类问题的理解会远超只看答案的水平。
根据我的经验，链表题在面试中"想不出来解法"的人其实很少，真正刷下人的是"写出来之后过了不了自己测试"的人。这完全可以通过大量刻意练习来弥补。每道题做完，认真跑一遍边界测试，把出过的bug记录下来，形成自己的错题本，一个月后回头看，你对链表操作的把握会和现在完全不一样。