链表算法刷题核心技巧：虚拟头节点与双指针实战解析

链表这玩意儿，我在第一次系统性刷算法题的时候，其实是有抵触情绪的。数组它不香吗？随机访问 O(1)，缓存友好，写起来还简单。但真把“代码随想录Day2链表”这个专题完整过了一遍之后，我才意识到，链表根本不是用来替代数组的，它是用来训练“指针思维”和“边界意识”的最佳教具。这个专题里没有一道题是白给的，每道题都在逼你回答同一个问题：当内存里的数据不是连续排列的时候，你的操作到底在改什么东西？

这份 Day2 专题笔记，按我个人的理解，就是彻底搞定单链表、双链表和循环链表的增删改查，外加一系列以链表为载体的经典算法题，比如移除元素、反转链表、两两交换、删除倒数第 N 个节点、链表相交、环形链表。这些题看起来是六道独立的 LeetCode 题目，但内核其实是两三个技巧在不同场景下的反复变体：虚拟头节点、双指针、快慢指针。如果你之前刷链表题总是“看题解秒懂，自己写就卡住”，那问题大概率不是题目难，而是你缺一套统一的解题框架。

这篇文章就是想把 Day2 链表专题里那些“题解里不会细讲，但实际写代码时一定会踩”的东西拆开揉碎。我会先说清楚这个专题为什么要这样编排，然后逐个拆解核心技巧和经典题目的实现细节，最后把我自己刷题时遇到的高频 bug 和排查思路整理成一份速查手册。适合刚入门数据结构、准备面试算法、或者刷 LeetCode 卡在链表关卡的同学，也适合那些已经刷过一遍但总觉得“差点意思”的人。

1. 链表专题的整体设计思路与核心知识点拆解

1.1 数组与链表的本质差异——理解链表为什么存在

很多新手学链表的第一反应是：这东西操作那么麻烦，到底图什么？我的答案是，图的是“插入和删除不需要搬动其他元素”。数组在内存里是一块连续空间，插入一个新元素在中间，意味着后面所有元素都要往后挪一位，时间开销 O(N)。链表的每个节点是独立分配的，节点之间用指针串起来，所以插入和删除只需要修改相邻节点的指针指向，时间复杂度 O(1)——前提是你已经站在了目标节点旁边。

但链表付出的代价同样明显：随机访问不行。数组用下标访问是 O(1)，链表要第 k 个节点，只能从头往后走 k 步，O(N)。而且链表每个节点还要额外存一个指针字段，内存开销更大。再加上节点在内存里不连续，遍历时 CPU 缓存命中率也不如数组。这就是为什么在实际工程里，大部分场景数组仍然是默认选择，链表只在特定场景（比如 LRU 缓存、操作系统内核的任务队列、频繁在头部插入删除的场景）才有优势。

从算法训练角度，链表的最大价值在于强制你建立“引用（指针）”意识。数组操作你可以不去想“这个东西现在指向谁”，但链表里每个操作都是指针的重新绑定。一旦指针指错了，整个链就断了——这个过程对培养严谨的边界思维极其有效。Day2 里所有题目的设计，本质上就是围绕“指针操作的安全性”展开的。

1.2 单链表、双链表与循环链表的定位

先明确三种链表形态的区别。单链表每个节点只有一个 next 指针，只能从前往后走，删除某个节点时必须知道它的前驱节点，否则没法把前驱的 next 跳过当前节点。双链表每个节点有 prev 和 next 两个指针，可以双向遍历，删除节点时不需要额外找前驱，但代价是每个节点多一个指针字段，插入和删除时需要注意更新的指针数量更多，容易乱。

循环链表则是把尾节点的 next 重新指向头节点，形成一个环。它的核心价值在于：从任意节点出发都能遍历整个链表，适合处理“需要循环调度”的场景（比如操作系统的进程调度时间片轮转）。在算法题里，循环链表最常以“判断链表中是否有环”的形式出现，对应到 Day2 里的环形链表相关题目。

这里有一个很重要的认知：绝大多数链表算法题，考点都是单链表。因为单链表操作最受限，最能暴露你对“前驱、后继、当前节点”关系的理解。双链表虽然在工程里更常用，但在算法面试里反而题目较少，因为它降低了解题难度，考察不出边界处理能力。

1.3 本专题的题目编排逻辑：不是刷题，是搭积木

我把 Day2 链表专题的这组题按依赖关系排了一下序，你会发现一个很有意思的规律：它们是层层递进的。

• 第一步，移除链表元素，学会最基本的“遍历链表 + 处理头节点特例”，为后面所有链表遍历打下基础。
• 第二步，设计链表，把所有基础操作（get、addAtHead、addAtTail、addAtIndex、deleteAtIndex）完整实现一遍，这是综合大练习。
• 第三步，反转链表，引入“三指针迭代法”或者“递归法”，开始练习指针重绑定的节奏，这是链表题里最重要的基础功。
• 第四步，两两交换节点，是把反转链表的指针操作复杂化，同时引入“虚拟头节点”这个神器。
• 第五步，删除倒数第 N 个节点，经典的双指针（快慢指针）应用，一快一慢，拉开距离。
• 第六步，链表相交，另一个双指针应用，处理两个链表长度不一致的问题。
• 第七步，环形链表，快慢指针的巅峰应用，相遇判环 + 数学推导找入口。

看到没有，前面的题目反复练习遍历和指针操作，后面的题目在同一个基本功上叠加不同的“解题策略”。如果你按这个顺序刷，每道题不是孤立的，它是在给下一道题做铺垫。这也是为什么我强烈不建议跳着刷链表题——跳着刷容易每道题都从零开始，没有积累感。

2. 核心细节解析：虚拟头节点与双指针技巧

2.1 虚拟头节点：为什么能统一删除和插入操作

链表操作里最烦人的问题是什么？头节点。删除一个普通节点，只需要让前驱节点的 next 指向当前节点的 next；但删除头节点时，它没有前驱，你只能单独处理 head = head->next。这就导致每个删除函数里都要写一个 if 判断 head 是否为目标节点，逻辑分支多，容易漏。

虚拟头节点（dummy head）的做法是：在真正的头节点前面多加一个哨兵节点，它的 next 指向原链表的头节点。这样原来链表的每一个节点（包括原头节点）都有了前驱，删除操作就完全统一了：一律通过“前驱节点的 next 跳过当前节点”，不需要再单独判断是不是头节点。

这个技巧看起来简单，但很多人在实际写代码时容易犯两个错。第一，忘了返回值问题：如果链表被删空了，返回值应该是 dummy->next，而不是 head，因为原 head 可能已经被删除。第二，遍历指针的初始位置：应该从 dummy 开始还是从 dummy->next 开始？答案是看你要不要“当前节点”本身参与操作。如果是删除类操作，遍历指针从头节点开始，但记录前驱指针 pre 从 dummy 开始，每步让 pre 跟上 cur，这样 cur 就是待判断的节点，pre 始终是它的前驱。如果是查找类操作（比如 get），遍历指针从头节点开始即可，不需要 pre。

我个人的习惯是：只要题目涉及“在链表头部做增删”，无脑加虚拟头节点。加了之后不需要动脑思考特殊情况，直接把注意力集中在核心逻辑上。

2.2 双指针法在链表操作中的三种典型用法

双指针在链表题里简直是无处不在，我把它归纳成三种典型形态。

第一种是“一前一后型”，也叫前后指针。典型场景是反转链表：cur 指向当前要处理的节点，pre 指向前一个节点，每次把 cur->next 指回 pre，然后 pre 和 cur 同时后移。这个过程中你必须保证在修改 cur->next 之前，先用临时变量暂存 cur 原来的下一个节点，否则指针就丢了。这属于链表操作的“基本功中的基本功”。

第二种是“一快一慢型”，典型场景是找链表中点、判断环、找倒数第 k 个节点。快指针每次走两步，慢指针每次走一步。在找倒数第 N 个节点时，先让快指针走 N 步，然后两个指针一起走，快指针走到末尾时，慢指针恰好指向倒数第 N 个节点的前驱。用图片想象一下：快指针和慢指针之间的距离始终等于 N，快指针到末尾后，慢指针和末尾的距离也就是 N。

第三种是“两个链表各一个指针型”，典型场景是求两个链表的交点。做法是先分别算出两个链表的长度，然后让长链表的指针先走长度差步，之后两个指针同步前进，第一个相遇的节点就是交点。如果遍历完都没有相遇，就说明两个链表不相交。这种用法的核心思想是“对齐尾部”或“对齐起点”，保证两个指针在剩余步数相同的前提下开始比较。

很多新手容易把三种形态搞混，我建议每道题先在纸上画出指针的相对位置变化，再写代码。指针题的 bug，九成出在“画图的时候明白，一写代码就乱”上面。

2.3 快慢指针判断环形链表的原理推导

环形链表的检测是快慢指针最经典的场景。慢指针每次走一步，快指针每次走两步，快慢指针都从 head 出发。如果链表没有环，快指针会先走到空节点，直接返回 null。如果有环，快指针会在环里“套圈”追上慢指针，两个指针必然相遇。这是常识，但很多人不知道为什么要用 2 倍速而不是 3 倍速或 4 倍速。

核心原因是可靠性。慢指针每次走 1 步，快指针走 2 步，两个指针的相对速度是 1，意味着每走一轮，距离缩短 1，所以快指针一定会恰好追上慢指针，不会跳过。如果快指针走 3 步，相对速度是 2，当两个指针距离为奇数时，快指针可能正好越过慢指针，导致一次错过，要再转一圈才能相遇——虽然最终也会相遇，但推导更复杂，而且要额外考虑节点数为偶数的环和平移情况。用 2 倍速是最简洁、最不容易出错的方案。

找环的入口需要一点数学推导。设 head 到环入口的距离为 A，入口到相遇点的距离为 B，相遇点继续走到入口的距离为 C（也就是环中剩余部分）。慢指针从 head 到相遇点走了 A + B。快指针从 head 到相遇点走了 A + B + n*(B+C)，因为它在环里可能转了 n 圈才追上。由于快指针速度是慢指针的 2 倍，所以有：

2(A + B) = A + B + n(B + C)

化简得 A = n(B+C) - B。当 n = 1 时，A = C。也就是说，从相遇点走 C 步到达环入口，而从 head 走 A 步也到达环入口，两者同步出发，第一个重逢的节点就是入口。这就是为什么环形链表 II 的标准解法里，快慢指针相遇后，再让一个新的指针从 head 出发，另一个指针从相遇点出发，同步一次走一步，相遇点就是环的入口。

这个推导最关键的点是 n 不一定是 1，但无论 n 是多少，同步出发的解法都成立，因为从相遇点出发的指针绕的圈数只会增加，不会影响首次相遇的位置。我在刷这题时犯过错误：我一开始用公式的时候忽略了相遇点并不一定在环入口的“剩余长度”概念，导致同步出发后的第一个相遇位置理解错了。后来我画了几个不同入口位置和环长度的示例图，才真正把 A = C 这个结论吃透。

3. 实操过程与核心环节实现

3.1 链表定义与基础操作模板

先把代码骨架搭好。这里我用 C++ 定义单链表节点结构，这是后面所有题的基础。

struct ListNode { int val; ListNode *next; ListNode() : val(0), next(nullptr) {} ListNode(int x) : val(x), next(nullptr) {} ListNode(int x, ListNode *next) : val(x), next(next) {} };

注意 C++ 里定义结构体后，使用类型名时不需要像 C 语言那样加 struct 关键字。如果你在使用这个结构体的文件里写了 typedef，那也没问题，但是 LeetCode 环境里通常直接使用 ListNode 即可。

然后是设计链表这道题的实现。我建议认真手写完整版本，因为它会把所有最基础的操作串一遍，是检验你链表基本功的标准。以下是我整理出的一套模板代码。

class MyLinkedList { private: int size; ListNode* dummyHead; public: MyLinkedList() { dummyHead = new ListNode(0); size = 0; } int get(int index) { if (index < 0 || index >= size) return -1; ListNode* cur = dummyHead->next; while (index--) { cur = cur->next; } return cur->val; } void addAtHead(int val) { ListNode* newNode = new ListNode(val); newNode->next = dummyHead->next; dummyHead->next = newNode; size++; } void addAtTail(int val) { ListNode* cur = dummyHead; while (cur->next != nullptr) { cur = cur->next; } cur->next = new ListNode(val); size++; } void addAtIndex(int index, int val) { if (index > size) return; if (index < 0) index = 0; ListNode* cur = dummyHead; while (index--) { cur = cur->next; } ListNode* newNode = new ListNode(val); newNode->next = cur->next; cur->next = newNode; size++; } void deleteAtIndex(int index) { if (index < 0 || index >= size) return; ListNode* cur = dummyHead; while (index--) { cur = cur->next; } ListNode* tmp = cur->next; cur->next = cur->next->next; delete tmp; size--; } };

这段代码里面有几个细节值得反复琢磨。第一，size 为什么一定要维护？因为有 get 和 deleteAtIndex 需要判断 index 合法性，没有 size 你每次都要遍历到目标位置才知道越界没有。第二，addAtIndex 为什么 index > size 才返回，而不是 >= ?因为 index = size 表示在尾部追加，是合法操作。第三，addAtHead 里先 newNode->next = dummyHead->next，再 dummyHead->next = newNode，这个顺序不能反。如果先把 dummyHead->next 指向 newNode，原头节点就找不到了，新节点就成了孤岛。

3.2 核心技巧实操一：移除链表元素

题目是 LeetCode 203，删除链表中所有值为 val 的节点。第一反应可能是：直接遍历，遇到目标值就跳过。但因为没有虚拟头节点，头节点的删除需要单独处理，逻辑会比较麻烦。所以这里直接采用虚拟头节点。

ListNode* removeElements(ListNode* head, int val) { ListNode* dummyHead = new ListNode(0, head); ListNode* cur = dummyHead; while (cur->next != nullptr) { if (cur->next->val == val) { ListNode* tmp = cur->next; cur->next = cur->next->next; delete tmp; } else { cur = cur->next; } } return dummyHead->next; }

注意这个循环里，cur 不能一上来就 cur = cur->next，否则会漏判连续相同值的情况。比如链表是 1 -> 2 -> 2 -> 1，要删除 2，你在第一个 2 的位置跳过了它，cur 还停在它前面的节点，这样下一个 2 才能继续被检查。只有当前节点的下一个节点不是目标值时，cur 才右移。这是一个容易忽略的细节，也是很多人写着写着就死循环或漏删的根源。

还有一种写法是不用虚拟头节点，先循环删掉头部的目标节点，再处理中间部分。但这种写法需要写两遍循环逻辑，代码冗余且容易出错。我强烈建议养成“虚拟头节点 + 统一逻辑”的习惯，因为后续很多题目都能复用。

3.3 核心技巧实操二：反转链表

LeetCode 206。反转整个链表，可以说是链表题里最经典的指针操作练习。目标是把 1 -> 2 -> 3 -> 4 -> 5 变成 5 -> 4 -> 3 -> 2 -> 1。

迭代法的核心逻辑是三个指针：pre 初始为 nullptr，cur 初始为 head。每次循环做四件事：

1. 用临时变量 tmp 保存 cur->next（因为马上要改 cur->next 了，不改就找不到了）。
2. 把 cur->next 指向 pre（反转当前节点的指针方向）。
3. pre 移动到 cur 的位置（pre = cur）。
4. cur 移动到 tmp 的位置（cur = tmp）。

ListNode* reverseList(ListNode* head) { ListNode* pre = nullptr; ListNode* cur = head; while (cur != nullptr) { ListNode* tmp = cur->next; cur->next = pre; pre = cur; cur = tmp; } return pre; }

这个代码看起来简单，但实际写的时候最容易犯的错是第 3、4 步顺序颠倒：先 pre = cur 再 cur = tmp，这样没问题；但如果先 cur = tmp 再 pre = cur，那 pre 就会指向 tmp 而不是原来的 cur，整个链就断错了。还有就是忘了 tmp 保存下一个节点，直接 cur = cur->next，结果 cur->next 早就被指向 pre 了，cur 会回到前一个节点，导致无限循环或反转出环。

我用一种生活化类比来理解这个流程：想象一排多米诺骨牌，你要让每块骨牌改变倒向方向。你不能一次性把所有骨牌都推倒，必须从左往右，一块一块来，每块骨牌在改变方向前，你得记清楚它原本指向哪块。tmp 就是那个记录原本方向的“记忆卡”。

3.4 核心技巧实操三：两两交换链表中的节点

LeetCode 24。要求两两交换相邻节点，比如 1 -> 2 -> 3 -> 4 变成 2 -> 1 -> 4 -> 3，不允许修改节点内部的值，必须真实地改指针。

这道题建议用虚拟头节点。你想象一下，交换一对相邻节点，涉及的关系有四个：前驱节点 pre、节点 one、节点 two、以及 two 后面的节点 three。交换操作的正确顺序是：

1. one->next = three（one 先指向 two 后面的节点）。
2. two->next = one（two 反过来指向 one）。
3. pre->next = two（前驱节点指向新的头节点 two）。
4. pre = one（pre 前移，准备处理下一对）。

ListNode* swapPairs(ListNode* head) { ListNode* dummyHead = new ListNode(0, head); ListNode* pre = dummyHead; while (pre->next != nullptr && pre->next->next != nullptr) { ListNode* one = pre->next; ListNode* two = pre->next->next; ListNode* three = two->next; one->next = three; two->next = one; pre->next = two; pre = one; } return dummyHead->next; }

这个顺序我一开始总是记不住，后来总结了一条规律：先处理“内圈”的指向变更，再处理“外圈”的接入，最后移动傀儡指针。什么意思呢？one 和 two 的指针关系是内圈，pre 接入 two 是外圈，pre 移动到 one 是为了下一轮。如果你先执行 pre->next = two，虽然不会立刻出错，但如果你在三步之内顺序搞混，后面 one->next = three 就可能把链搞乱。

这道题还有个高频考点：奇数长度链表怎么办？比如 1 -> 2 -> 3，交换后是 2 -> 1 -> 3，最后一个节点 3 不动。这个逻辑在循环条件里已经处理了：pre->next->next 不存在时，循环结束。所以判断条件一定是 &&，两个条件缺一不可。

3.5 核心技巧实操四：删除链表的倒数第 N 个节点

LeetCode 19。删除链表的倒数第 N 个节点，并且要求一趟遍历完成。如果允许两趟遍历，可以先算长度，再走 size - N 步找到前驱。但一趟遍历需要用快慢指针。

思路是：快指针先往前走 N 步，然后快慢指针同步前进，当快指针走到尾部（next 为空）时，慢指针停留的位置恰好是被删节点的前驱节点。为什么是前驱而不是被删节点？因为要删除节点，不管是直接用前驱跳过，还是用“删除当前节点需要知道前驱”的思路，我们最好直接定位到前驱，这样操作最干净。

ListNode* removeNthFromEnd(ListNode* head, int n) { ListNode* dummyHead = new ListNode(0, head); ListNode* fast = dummyHead; ListNode* slow = dummyHead; while (n-- && fast != nullptr) { fast = fast->next; } while (fast->next != nullptr) { fast = fast->next; slow = slow->next; } ListNode* tmp = slow->next; slow->next = slow->next->next; delete tmp; return dummyHead->next; }

注意这里 fast 和 slow 都从 dummyHead 出发。为什么不让 fast 也从 head 出发？因为这样当 fast 走到末尾时，slow 会正好指着被删节点而不是前驱。从 dummyHead 出发相当于慢指针天然比实际头节点多看了一个节点，这正好让最终 slow 停在被删节点的前驱位置。

还要注意 n 保证有效（1 <= n <= size），所以第一个循环里 fast 不会越界，但为了鲁棒性，还是建议加上 fast != nullptr 的判断。我自己在这个题里踩过的坑是：忘了再定义一个临时变量保存要删除的节点，直接用 slow->next = slow->next->next，结果内存泄漏（在 C++ 里）。虽然 LeetCode 不查内存泄漏，但真实工程里这是不容忽视的问题。

3.6 核心技巧实操五：链表相交

LeetCode 160。求两个链表相交的起始节点。链表相交后，从交点开始后面的部分完全共享，所以两个链表的总长度差存在于交点之前。

最直觉的思路是先求出两个链表的长度差，然后长链表的指针先走长度差步，之后两个指针同步前进，第一个相等的节点就是交点。

ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) { ListNode* a = headA; ListNode* b = headB; int lenA = 0, lenB = 0; while (a != nullptr) { lenA++; a = a->next; } while (b != nullptr) { lenB++; b = b->next; } a = headA; b = headB; if (lenA > lenB) { int diff = lenA - lenB; while (diff--) a = a->next; } else { int diff = lenB - lenA; while (diff--) b = b->next; } while (a != nullptr && b != nullptr) { if (a == b) return a; a = a->next; b = b->next; } return nullptr; }

这道题有一个很关键的认知：代码里比较的是指针本身（a == b），而不是指针指向的值（a->val == b->val）。因为相交的定义是“两个链表在某个节点开始共用同一块内存”，链表相交后，节点地址必然相同。如果只比较值，两个链表有相同值的节点但不相交，会出现误判。

我还见过有人用另一种写法：双指针同时从两个链表头部出发，一个走完 A 后去走 B，另一个走完 B 后去走 A，这样相当于两个指针都走了 lenA + lenB 的长度，最终会在交点或者 null 相遇。这种写法不需要求长度，但理解起来稍微绕一点，适合作为进阶理解，面试时两种能讲清楚一种就够。

3.7 核心技巧实操六：环形链表 II

LeetCode 142。找到环的入口节点。这道题的完整解法是：先判断有没有环，有环则找入口。思路我在 2.3 已经推导过了，这里直接看代码。

ListNode *detectCycle(ListNode *head) { ListNode* fast = head; ListNode* slow = head; while (fast != nullptr && fast->next != nullptr) { fast = fast->next->next; slow = slow->next; if (fast == slow) { ListNode* index1 = fast; ListNode* index2 = head; while (index1 != index2) { index1 = index1->next; index2 = index2->next; } return index1; } } return nullptr; }

注意循环条件里必须同时判断 fast != nullptr 和 fast->next != nullptr。如果 fast->next 为空，说明链表没有环，快指针已经走到尾部了，再取 fast->next->next 就会对空指针解引用，直接崩溃。

这个题还有一个容易想不通的点：在找入口阶段，为什么 index1 从相遇点出发，index2 从 head 出发，两者都一次走一步，第一次相遇就是入口？关键在于前面推导出的 A = C（当 n=1 时）。如果 n > 1，实际情况是 index1 绕了 n-1 圈之后再和 index2 相遇，但由于 index1 从相遇点出发走 C 步必然到达入口，走 C + (B+C) 步也到达入口（因为多走一整圈），所以仍然是在入口首次相遇。这个“多走整圈不影响结果”的性质要认真体会，面试时有可能会被追问。

4. 常见问题与排查技巧实录

4.1 指针丢失：几乎所有链表 bug 的根源

刷链表题的时候，我见过最多的问题就是指针丢失。具体表现为：链表断成两截、出现环、输出为空、死循环。本质原因几乎都是同一个——在修改某个节点的 next 之前，没有先保存它原本指向的节点。

典型错误代码：

// 错误示例：删除 cur 的下一个节点 cur->next = cur->next->next; // 没问题 // 但如果你想删除 cur->next 后还要访问它，就必须先保存 ListNode* tmp = cur->next; cur->next = cur->next->next; // 后续操作里用 tmp

我的排查口诀是：“改谁之前，先保谁”。比如反转链表要改 cur->next，所以在改之前先保存 cur->next 到 tmp；两两交换要改 one->next、two->next、pre->next，所以在改动之前，把 three 保存好；删除倒数第 N 个节点要改 slow->next，所以在改之前，把 tmp 保存好。这套思路练熟了，指针丢失问题基本能消灭 90%。

另一个常见的指针相关 bug 是：把赋值语句理解反了。node1->next = node2的意思是“让 node1 的下一个指向 node2”，而不是“让 node2 等于 node1 的下一个”。很多新手会在两两交换里把方向写反，然后怎么跑都不对。建议每道题写完后，自己用纸笔画一遍指针变化，确认逻辑方向正确。

4.2 边界条件：空链表、单节点、双节点

链表题的边界条件就那么几种，但每种都能单独考倒一群人。我把典型的边界场景和对应的处理策略整理成了一张表。

边界条件之所以容易出错，是因为很多人在真正写代码之前没有想清楚“我的循环终止条件是什么”。链表题里最常见的循环条件是 while (cur != nullptr) 和 while (cur->next != nullptr)，这两者意义完全不同：前者是处理当前节点，后者是处理当前节点的下一个节点。选错一个，代码就会差出“一个节点”的误差。我刷完这一系列题后，每道题都会先问自己：我要处理的是 cur 还是 cur->next？然后再写循环。

4.3 不同语言实现差异与注意事项

虽然链表题的逻辑和语言无关，但不同语言写起来还是有明显区别。我用 C++ 和 Java 刷这两组题时感受最深。

C++ 需要手动管理内存。new 出来的节点用完要 delete，否则即使 LeetCode 不查，你也会在本地调试时发现内存占用一直涨。而且 delete 之后，原指针变成“悬空指针”，不能再访问其 next 或 val，否则是未定义行为。我用指针变量 tmp 保存被删节点后，一般三步走：先改前驱指针，再 delete tmp，最后把 tmp 置空（帮助排查悬空指针问题）。

Java 里虽然不用手动 delete（有垃圾回收），但链表的引用操作和 C++ 指针本质一样，同样存在“改引用之前先保存”的问题。Java 里空指针异常 NPE 出现的频率，和 C++ 里段错误出现的频率一样高，排查方法也类似：在关键节点打印日志或断点检查，看是哪个引用变成 null 了。

Python 的链表题我没怎么用，不过 Python 里一切皆对象，节点是对象引用，操作逻辑一样。但 Python 没有指针语法，画图理解很重要，因为代码上看起来“不太像指针操作”。

我推荐至少用 C++ 和 Java 各刷一遍这几道题。两种语言的风格差异能帮你更好地理解指针和引用的区别。只刷一种语言，有些概念会停留在“哦，这样写能过”的层面，换一种语言可能就崩了。

4.4 实战排查步骤：从报错到修复的完整流程

最后分享我的链表题 debug 标准流程，这套流程我用了很多次，效率比无头苍蝇式调试高很多。

第一步，定位出错区间。在每次循环开头打印当前节点的值，或者用断点观察，确认死循环发生在哪一轮。第二步，检查指针指向。把每一步操作后 pre、cur、tmp 的地址和值都打印出来，对照自己手画的指针变化图，找到第一个不一致的地方。第三步，检查循环条件。重点确认 while 条件里的判断对象是 cur 还是 cur->next，以及是否存在对空指针的 next 访问。第四步，检查返回值。看最终 return 的是 head 还是 dummyHead->next 还是 pre，确认当前算法返回的节点确实是题目要求的节点。

这套流程最核心的一点是“对比图”，而不是“看代码”。我见过程序员盯着代码反复看，就是看不出问题，因为有些 bug 是逻辑层面的，代码层面看起来完全正常。你只要把你对链表结构的预期画出来，再和实际运行结果对比，位置偏差立刻暴露。

5. 从 Day2 到后续进阶：链表能力的扩展设计

5.1 递归视角：反转链表和更大的图景

Day2 里反转链表是用迭代法做的，但面试时经常会追问“你能用递归实现吗”。递归反转链表的代码特别短，但理解起来反而更难。

ListNode* reverseList(ListNode* head) { if (head == nullptr || head->next == nullptr) return head; ListNode* newHead = reverseList(head->next); head->next->next = head; head->next = nullptr; return newHead; }

递归的思路是：假设当前节点 head 之后的子链表已经反转好了，现在只需要把 head 接到子链表的末尾。head->next 原本指向子链表的第一个节点，同时也是反转后子链表的最后一个节点，所以执行 head->next->next = head 把自己接上去。然后 head->next = nullptr 断开原来的指向。返回值是反转后的新头 newHead。

很多人在递归里绕不清楚。我的建议是：不要在脑子里模拟每一层递归，而是信任“递归函数就是已经完成了它的任务”，只需要思考当前这一层怎么做。这是掌握递归的关键心态。如果你能把迭代反转和递归反转都讲清楚，链表这块面试基本稳了。

5.2 复杂度分析：为什么链表题的时间复杂度不是重点

链表题的复杂度分析相对固定，但很多新手还是会算错。遍历一次是 O(N)，遍历两次是 O(N)，但常数不同。反转链表 O(N)，因为每个节点只访问一次；两两交换 O(N)，同理；删除倒数第 N 个节点虽然用了双指针，但两个指针加起来也只遍历了一次，O(N)；环形链表判断 O(N)，因为快慢指针总步数不超过链表长度的常数倍。

空间复杂度方面，迭代法一般 O(1)（只用了几个指针变量），递归法会用到 O(N) 的递归栈。这也就是为什么在实际刷题中，递归法虽然代码优雅，但要考虑递归深度过大导致栈溢出的风险。如果链表长度是百万级，递归反转直接爆栈，迭代法毫发无损。面试时如果提到递归解法，最好顺带说明它的空间复杂度代价。

链表题很少出现特别高的复杂度，重点考察的还是指针操作的准确性和边界处理能力。所以不要纠结于“有没有更快的算法”，先把 O(N) 的正确解法写利索。

5.3 刷题建议与后续规划

代码随想录的 Day2 做完之后，下一步应该怎么走？我给三条具体建议。

第一，重复练习“设计链表”这道题，用不同方法实现至少三遍。每次写完后，把删除、添加、查找的每一条分支逻辑口头讲一遍，讲不出来就说明还有盲区。这是最笨但最有效的方式。

第二，把反转链表的所有变体全部做一遍：反转前 N 个节点、反转区间 [left, right] 内的节点、K 个一组反转链表。这些题目是同一个模板加了些变化，做的时候会发现自己已经能很自然地想到怎么调整指针。

第三，在真实项目中找一个使用链表的场景。比如实现一个最简单的 LRU 缓存，用双向链表 + 哈希表。做这种项目比刷十道题都管用，因为它逼着你在真实约束下设计数据结构，而不是在 LeetCode 编辑器里“过题”。

从我个人的经验来看，链表章节是算法学习里少有的“付出和回报绝对成正比”的部分。你花三天把指针操作练到肌肉记忆，后面学树、图、堆，很多地方都会顺手很多。那些复杂的树旋转、图遍历，本质上都是“指针的重新指向”，和链表里练的东西一脉相承。

最后再聊一个我自己的习惯：我刷链表题时会专门准备一个本子，每道题画三个图——初始状态、中间步骤、最终状态。一开始很费时间，但画到第五道题的时候，我发现自己在脑内就能完成这个过程，写代码的时候思路清晰得不像话。如果你也在链表上反复卡壳，我真心建议你试试这个方法。它不需要任何工具，一支笔一张纸，就能帮你把那个抽象的 next 指针，变成一个触手可及的真实结构。