链表算法题核心技巧：反转、快慢指针与虚拟头节点实战解析

1. 先把链表题的核心思路理清楚

说真的，链表算法题是我刷题时候又爱又恨的一部分。爱的是题目套路相对固定，翻来覆去就那么几类；恨的是边界条件一多，稍微手滑就是空指针、死循环、断链。但只要把链表的数据结构本质、指针操作习惯、虚拟头节点这几个基础认知建立起来，后面再刷反转、环、合并、删除这些题，其实就是套框架。

这篇文章适合这么几类人：准备笔试面试但链表题还没形成体系的；工作中偶尔要写驱动、写缓存、写内存池，跟指针打交道的；还有刚学完数据结构想找点经典题练手的。我不打算把题解从头到尾贴一遍，而是把每道题背后的思考过程和踩坑点讲清楚，这样你换一种语言、换一个变体，也能照样写出来。

1.1 链表到底是个什么结构

链表和数组最大的区别，是它在内存里不连续。数组像电影院连排座位，找第 5 个座位直接走过去就行；链表像寻宝游戏，每个盒子里面藏着一张线索，指向下一个盒子，你必须一个接一个地找。

对应到代码，单链表节点通常长这样：

cpp复制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) {}
};

每个节点存两个东西：数据值 val，以及指向下一个节点的指针 next。这个 next 就是整个链表题的核心战场。多一个前驱指针就是双向链表，尾节点指向头节点就是循环链表，面试里很多题都是从这些基础形态上变形出来的。

链表题之所以容易写错，是因为它的访问方式太受限制了：你只知道当前节点，想找前一个节点只能从头再走一遍。所以很多算法的设计动机，本质上都是在弥补“不能回头”这个短板。理解了这一点，你再看快慢指针、递归反转、虚拟头节点这些技巧，就会觉得它们都是自然而然长出来的。

1.2 指针操作三板斧

我刷了几十道链表题之后，发现所有指针操作都可以归成三个基本动作：改指向、移指针、留备份。

改指向是最容易出问题的。比如要把 cur 的 next 指向 prev，你直接写 cur->next = prev，如果后面还要用 cur->next，那原来的后继节点就丢了。所以动手之前先问自己一句：这个节点的 next 被覆盖之后，我还需要原来的 next 吗？需要就先拿临时变量存起来。就像搬家先拍照记录插座位置，不然搬完东西就忘了。

移指针是循环里最常见的操作：cur = cur->next。这个动作本身没难度，难的是移动的顺序。反转链表里如果先改了 cur->next，再执行 cur = cur->next，那 cur 就跑到一个错误的位置去了。所以我习惯在每次循环开头，先把当前状态画出来，确认节点之间的箭头方向，再决定操作顺序。

留备份是这三板斧里最容易被忽略的。很多提交上去报错“member access within null pointer of type 'struct ListNode'”，就是因为某个节点的 next 是空指针，你还往它身上挂东西。写链表操作的时候，凡是涉及“可能为空”的节点，要么提前判空，要么用虚拟头节点兜底，要么备份一份备用。

1.3 虚拟头节点：写链表题的“安全气囊”

虚拟头节点（dummy node）是我个人最推荐的编码习惯。它就是一个额外创建的节点，next 指向真正的头节点，然后你所有操作都从 dummy 开始，最后返回 dummy->next。

为什么要这么干？因为头节点是一个很特殊的位置：它没有前驱。删除头节点和删除中间节点，处理方式完全不同；插入到头节点和插入到中间，处理方式也不同。如果用一个 dummy 虚拟节点垫在头节点前面，那所有节点都变成“有前驱”了，代码逻辑统一，很多 if 判断可以直接省掉。

cpp复制ListNode* deleteNode(ListNode* head, int val) {
    ListNode dummy(0);
    dummy.next = head;
    ListNode* cur = &dummy;
    while (cur->next) {
        if (cur->next->val == val) {
            cur->next = cur->next->next;
        } else {
            cur = cur->next;
        }
    }
    return dummy.next;
}

这一段代码里，dummy 帮我们解决了一个大麻烦：假如 head 本身就是要删的节点，如果不加 dummy，你得单独写一段“删头节点”的逻辑。加了 dummy，所有删除都统一成“让 cur->next 跳过目标节点”，非常干净。另一个好处是，不管中途怎么操作，函数返回的时候一定是 dummy.next，不会因为 head 被删了而丢链表。

2. 链表反转：从单链表逆序到 K 个一组翻转

反转类问题是链表题里最基础也是最重要的模块。面试官问链表，十次里有五次会从反转开始。热门搜索词里那个“python单链表逆序”，其实就是这一类。我见过很多同学迭代版能默写出来，但递归版一写就卡壳，更别说 K 个一组翻转这种综合题。这一节把三个层次讲透。

2.1 反转整个链表：迭代版和递归版

先看迭代版。核心思路是遍历时不断把当前节点的 next 指向前驱节点。这里需要一个 prev 初始为 nullptr，一个 cur 初始为 head。每一步先保存 next 备份，然后把 cur->next 指向 prev，再让 prev 和 cur 同时前进。

cpp复制ListNode* reverseList(ListNode* head) {
    ListNode* prev = nullptr;
    ListNode* cur = head;
    while (cur) {
        ListNode* next = cur->next;
        cur->next = prev;
        prev = cur;
        cur = next;
    }
    return prev;
}

这个逻辑可以类比成翻扑克牌：你手里一摞牌，每次从顶部取一张，放到另一摞的顶部，最后整摞顺序就反了。代码里 prev 就是“已经翻好的那一摞”，cur 是“还没翻的这一摞”，每次把 cur 这张牌放到 prev 堆上面去。

递归版怎么写？先明确递归函数的定义：给定一个头节点 head，返回反转之后的新头节点。假设 head 之后的子链表已经反转好了，那么我只需要把当前的 head 接到子链表的末尾后面。

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

很多人不理解为什么是 head->next->next = head。你可以倒着想：head 后面的链表已经反转过来了，原来的 head->next 现在是反转后链表的尾节点。要把 head 接上去，就应该让这个“尾节点”的 next 指向 head，所以是 head->next->next = head。最后 head->next 置空，因为 head 现在是整个链表的尾节点。

递归版的优点是思路优雅，缺点是递归深度等于链表长度，链表特别长时可能爆栈。工程上我一般用迭代版，面试时如果面试官想看递归思维，再切换到递归版。

2.2 反转链表的前 N 个节点

反转整个链表搞清楚之后，可以加一个限制：只反转前 N 个节点，后面的保持原样。这就是 LeetCode 92 反转链表 II 的中间步骤，也是 K 个一组翻转的前置技能。

迭代实现需要记录四个关键位置：前驱节点 pre、反转区间的起点 start、反转区间的终点 end、以及终点后面的后继节点 tail。反转完之后，让 pre->next 指向新的区间头，让区间尾指向 tail。

递归写法更简洁。定义一个函数 reverseN(head, n)，返回反转前 n 个节点后的新头，并且在递归到第 n 层时把第 n+1 个节点用后继指针记下来。

cpp复制ListNode* successor = nullptr;

ListNode* reverseN(ListNode* head, int n) {
    if (n == 1) {
        successor = head->next;
        return head;
    }
    ListNode* newHead = reverseN(head->next, n - 1);
    head->next->next = head;
    head->next = successor;
    return newHead;
}

关键点在第 n=1 层：此时 head 是第 n 个节点，它的下一个节点是不能动的，所以要存到 successor 里。等递归一层层往上返回时，每一层都会把 head->next 重新指向 successor，最终保证反转后的尾部能接上后续链表。

2.3 K 个一组翻转链表：分组反转的经典实现

K 个一组翻转链表是反转类问题的综合题。它要求每 K 个节点一组做反转，如果剩余节点不足 K 个就保持原样。第一次刷这道题的时候，我写了一个多小时还报错，后来总结出套路就顺手多了。

建议用一个哨兵节点 dummy 接在 head 前面，然后不断循环处理每一组。每一轮先尝试走 K 步，看看够不够一组；如果够，就记录组内头节点 start，然后用前面 2.2 的方法把这一组反转；如果不够，直接退出循环。

cpp复制ListNode* reverseKGroup(ListNode* head, int k) {
    ListNode dummy(0);
    dummy.next = head;
    ListNode* pre = &dummy;

    while (head) {
        ListNode* tail = pre;
        for (int i = 0; i < k; i++) {
            tail = tail->next;
            if (!tail) return dummy.next;
        }
        ListNode* start = pre->next;
        ListNode* next = tail->next;
        reverseRange(start, tail);
        pre->next = tail;
        start->next = next;
        pre = start;
        head = start->next;
    }
    return dummy.next;
}

其中 reverseRange 负责把 start 到 tail 这一段的指针全部反转。这里有一个容易犯的错误：反转完一段之后，原来的 start 变成了段的尾部，所以要让它指向 next，不然这一段就和后面的链表断开了。同理，pre 要更新为 start，因为 start 现在是下一段的前驱。

这道题做熟了之后，我最大的收获是对“分组”的敏感度。以后看到任何“按组处理链表”的题，第一反应都是：先找组边界，再操作组内，最后接回上下文。这个思路在区间反转、按段重排这些变题里都通用。

3. 快慢指针：环与相交两根指针走天下

如果说反转是“把箭头掉头”，那快慢指针就是“让两根指针跑出不同的速度”，专门用来解决链表里的位置探测问题。环形链表、链表中点、相交链表，全是这一套。它最巧妙的地方在于，不需要额外空间，只在原地用两根指针就能判断出很多结构性质。

3.1 环形链表检测

判断一个链表有没有环，最直观的方法是用哈希表记录访问过的节点，如果某个节点被访问两次，说明有环。这个思路没问题，但空间复杂度 O(n)。快慢指针可以把空间优化到 O(1)。

慢指针每次走一步，快指针每次走两步。如果链表没有环，快指针会先到达 nullptr；如果有环，两根指针会进入环里无限走，最终一定会相遇。这个结论可以理解为操场跑圈：一个人跑得快，一个人跑得慢，只要沿着同一个环形跑道跑，快的人迟早会追上慢的人。

cpp复制bool hasCycle(ListNode* head) {
    ListNode* slow = head;
    ListNode* fast = head;
    while (fast && fast->next) {
        slow = slow->next;
        fast = fast->next->next;
        if (slow == fast) return true;
    }
    return false;
}

一个很容易踩的坑是 while 条件里的 fast->next 判空。因为快指针一次走两步，fast 本身不为空还不够，还要确保 fast->next 不为空，否则 fast->next->next 就会访问空指针。这个细节写代码的时候一定要记得。

3.2 找到环的入口

判断有环只是第一步，面试往往还会追问：环的入口在哪里？这道题要做的是“找到 meet 点之后，再走多少步能回到入口”。结论非常优美：从相遇点出发和从头节点出发，各走一步，相遇的位置就是环的入口。

为什么？简单推导一下。设链表头到环入口的距离是 a，环入口到相遇点的距离是 b，相遇点绕环一圈再回到入口还要走 c，那么环的长度就是 b + c。快指针走的距离是慢指针的两倍，慢指针走了 a + b，快指针走了 a + b + n*(b+c)。由 2*(a+b) = a+b+n*(b+c)，得到 a = c + (n-1)*(b+c)。也就是说，从头节点走到入口的距离，等于从相遇点继续走到入口的距离（可能绕了很多圈）。所以两根指针从头和相遇点同时出发，第一次相遇一定在入口。

cpp复制ListNode* detectCycle(ListNode* head) {
    ListNode* slow = head;
    ListNode* fast = head;
    bool hasCycle = false;
    while (fast && fast->next) {
        slow = slow->next;
        fast = fast->next->next;
        if (slow == fast) {
            hasCycle = true;
            break;
        }
    }
    if (!hasCycle) return nullptr;
    fast = head;
    while (slow != fast) {
        slow = slow->next;
        fast = fast->next;
    }
    return slow;
}

这个推导过程不需要死记，理解之后面试时能现场讲出来，是很加分的。我最开始刷这道题的时候，记过一句口诀“一快一慢先相遇，从头再走必入环”，后来发现理解了推导，比口诀靠谱得多。

3.3 相交链表：双指针换路走

相交链表是另一个靠双指针解决的经典题。两条链表可能在某一点之后合并成同一条链表，要求找出第一个相交节点。最朴素的思路是双重循环逐个比较，复杂度 O(m*n)，显然不够好。

标准解法是用两根指针 a 和 b，分别从 headA 和 headB 出发。a 走完 headA 之后，换到 headB 继续走；b 走完 headB 之后，换到 headA 继续走。当两根指针相遇时，就是第一个相交节点；如果不相交，最终会同时走到 nullptr。

cpp复制ListNode* getIntersectionNode(ListNode* headA, ListNode* headB) {
    ListNode* a = headA;
    ListNode* b = headB;
    while (a != b) {
        a = a ? a->next : headB;
        b = b ? b->next : headA;
    }
    return a;
}

为什么能相遇？因为两根指针走过的总长度最终都是 lenA + lenB。如果两条链表相交，它们会在交点处相遇；如果不想交，则会在 nullptr 处相遇。相当于两个人分别走两条路，走到尽头再换到对方那条路上，路的长度一样，所以一定会在某个点碰上。

这道题给我的启发是：有时候不需要额外记录长度，换路走一遍就能绕开“先求长度差”的繁琐步骤。这类“交叉换路”的思路在后面的链表重排、轮转中也会用到。

4. 合并与排序：有序链表问题的主线

链表相关的题目里，凡是牵扯到“有序”二字的，十有八九和合并、排序相关。归并排序的思想在链表场景下特别自然，因为链表不支持随机访问，但支持在头部高效插入，归并只需要比较节点值、调整指针，不需要额外搬移数据。

4.1 合并两个有序链表

这是最基础的一道题，但也是后面很多难题的地基。合并两个有序链表，可以用迭代，也可以用递归。

迭代的思路是维护一个哨兵节点 dummy 和一个尾指针 cur，然后双指针遍历 l1 和 l2，谁的值小，就把它接在 cur 后面，然后对应指针前进一步。

cpp复制ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
    ListNode dummy(0);
    ListNode* cur = &dummy;
    while (l1 && l2) {
        if (l1->val <= l2->val) {
            cur->next = l1;
            l1 = l1->next;
        } else {
            cur->next = l2;
            l2 = l2->next;
        }
        cur = cur->next;
    }
    cur->next = l1 ? l1 : l2;
    return dummy.next;
}

注意最后那行 cur->next = l1 ? l1 : l2，这一步很关键：当某个链表遍历完了，直接把另一个链表剩余部分接上，不需要再逐个拼接。很多新手会在这里写一个 while 循环去继续接，其实完全没必要，因为链表本身就是一条连好的链，接上头部就全接上了。

递归版的核心就是那句公式：merge(l1, l2) = 较小者 + merge(较小者的 next, 另一条链表)。代码更短，但递归深度受链表长度影响，链表很长时不如迭代稳。

cpp复制ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
    if (!l1) return l2;
    if (!l2) return l1;
    if (l1->val <= l2->val) {
        l1->next = mergeTwoLists(l1->next, l2);
        return l1;
    } else {
        l2->next = mergeTwoLists(l1, l2->next);
        return l2;
    }
}

4.2 合并 K 个有序链表

合并 K 个有序链表是 4.1 的进阶版。粗暴的做法是每两个合并一次，重复 K-1 轮，但这样会反复扫描某些节点，整体复杂度偏高。更好的做法有两种：分治合并和优先队列。

分治合并的思路和归并排序一模一样：把 K 条链表分成两组，每组递归合并，最后再把两个结果合并起来。这样每个节点参与的合并次数是 O(log K) 次，总复杂度 O(N log K)，N 是所有节点总数。

优先队列的写法也很直观：把所有链表的头节点丢进一个小顶堆，每次弹出最小的节点加入结果链表，然后把该节点的 next 入堆。

cpp复制struct cmp {
    bool operator()(ListNode* a, ListNode* b) {
        return a->val > b->val;
    }
};

ListNode* mergeKLists(vector<ListNode*>& lists) {
    priority_queue<ListNode*, vector<ListNode*>, cmp> pq;
    ListNode dummy(0);
    ListNode* cur = &dummy;
    for (ListNode* head : lists) {
        if (head) pq.push(head);
    }
    while (!pq.empty()) {
        ListNode* node = pq.top();
        pq.pop();
        cur->next = node;
        cur = cur->next;
        if (node->next) pq.push(node->next);
    }
    return dummy.next;
}

优先队列方案的时间复杂度也是 O(N log K)，代码比分治好写。面试时可以优先说优先队列思路，再顺手提一下分治也可以，显得你对复杂度有完整认知。

4.3 排序链表：归并排序在链表上的落地

排序链表是一道更综合的题，要求对单链表排序，进阶要求是 O(n log n) 时间复杂度和 O(1) 空间复杂度。既然数组排序的 O(n log n) 算法有快排、堆排、归并，链表场景下最适合的其实是归并排序。

归并排序在链表上的步骤很固定：先用快慢指针找到中点，把链表切成两半；递归排序两半；然后调用 mergeTwoLists 合并。切链时要记得把左半部分的尾节点 next 置空，不然递归排序时还带着后半段，结果会乱。

cpp复制ListNode* sortList(ListNode* head) {
    if (!head || !head->next) return head;
    ListNode* slow = head;
    ListNode* fast = head->next;
    while (fast && fast->next) {
        slow = slow->next;
        fast = fast->next->next;
    }
    ListNode* mid = slow->next;
    slow->next = nullptr;
    ListNode* left = sortList(head);
    ListNode* right = sortList(mid);
    return mergeTwoLists(left, right);
}

这里一个细节是 fast 初始化为 head->next，而不是 head。这样当 fast 走到链表末尾时，slow 会落在中间偏左的位置，切出来的两半更均衡。如果你把 fast 初始化为 head，找中点时也会工作，但边界处理起来容易多切一个节点。

如果要满足严格的 O(1) 空间复杂度，递归不适合，因为递归栈本身是 O(log n)。追求 O(1) 空间得用自底向上的归并：先按长度为 1 的小段两两合并，再按长度为 2 的两两合并，直到合并完整个链表。工程上很少写这种版本，但面试时能说出来，会显得功底扎实。

5. 删除与重排：边界条件最容易翻车

删除类题目看起来简单，实际上是最容易出 bug 的一类，因为空指针、头节点特殊处理、断链时机全在这类题里集中爆发。重排类题目则更考验综合能力，经常是“找中点 + 反转 + 合并”三合一。

5.1 删除倒数第 N 个节点

删除倒数第 N 个节点，最 naive 的做法是先遍历一遍算长度，再走 len - n 步找到目标节点的前驱。这个做法没问题，但只遍历一遍的双指针解法更优雅，也更常被问到。

双指针的思路是：设置 fast 和 slow，都从 dummy 出发。fast 先走 n+1 步，然后 fast 和 slow 同时每次走一步。当 fast 走到 nullptr 时，slow 刚好停在要删除节点的前一个位置，直接执行 slow->next = slow->next->next。

cpp复制ListNode* removeNthFromEnd(ListNode* head, int n) {
    ListNode dummy(0);
    dummy.next = head;
    ListNode* fast = &dummy;
    ListNode* slow = &dummy;
    for (int i = 0; i <= n; i++) {
        fast = fast->next;
    }
    while (fast) {
        fast = fast->next;
        slow = slow->next;
    }
    slow->next = slow->next->next;
    return dummy.next;
}

这段代码我最初写的时候犯过一个错误：fast 先走 n 步，而不是 n+1 步。那样当 fast 到末尾时，slow 停在目标节点本身而不是它的前驱，删除的时候就没有前驱可用，处理起来非常麻烦。所以记住一个关键点：你的目标是让 slow 停在目标节点的前驱，因此 fast 要比目标位置多走一步。

5.2 删除排序链表中的重复元素

这个题有两种变体。第一种是“保留一个”，也就是把重复元素去重，每个值只留一个；第二种是“一个不留”，重复的都删掉。两个都值得做一遍，因为它们对边界的考验完全不同。

先看保留一个的版本。因为是排序链表，重复元素一定连续出现，所以只需要从头遍历，发现 cur->val == cur->next->val 就跳过 cur->next，否则正常前进。

cpp复制ListNode* deleteDuplicates(ListNode* head) {
    ListNode* cur = head;
    while (cur && cur->next) {
        if (cur->val == cur->next->val) {
            cur->next = cur->next->next;
        } else {
            cur = cur->next;
        }
    }
    return head;
}

注意这里当发现重复时，cur 不需要移动，因为 cur->next 被替换成了新的节点，需要再比较一次。很多新手在这里手一滑就写了 cur = cur->next，结果连续出现三个相同值的时候只删了一个，第二个重复值没删掉。

再看一个不留的版本。这个版本必须使用虚拟头节点，因为头节点本身也可能是重复值。判断条件要改成：当 cur->next 和 cur->next->next 都存在且值相等时，记下这个重复值，然后把后面所有等于这个值的节点全部跳过。

cpp复制ListNode* deleteAllDuplicates(ListNode* head) {
    ListNode dummy(0);
    dummy.next = head;
    ListNode* cur = &dummy;
    while (cur->next && cur->next->next) {
        if (cur->next->val == cur->next->next->val) {
            int val = cur->next->val;
            while (cur->next && cur->next->val == val) {
                cur->next = cur->next->next;
            }
        } else {
            cur = cur->next;
        }
    }
    return dummy.next;
}

这种“先记录重复值，再循环跳过所有相同节点”的技巧，在很多字符串处理题里也会见到，值得记下来。

5.3 重排链表与回文链表：一道题的双重体验

重排链表（L0 -> Ln -> L1 -> Ln-1 -> ...）和回文链表（判断链表是否对称）其实是一对孪生题。它们的核心思路都一样：先找中点，再把后半段反转，最后交替操作或逐个比较。做完一道，另一道就顺手了。

先说重排链表。如果用数组存所有节点，这道题就是双指针从头尾往中间扫，没有任何难度。但进阶要求是原地修改，那步骤就变成三步：

1. 用快慢指针找到链表中点；
2. 反转后半段链表；
3. 把前半段和反转后的后半段交替合并。

cpp复制void reorderList(ListNode* head) {
    if (!head || !head->next) return;
    ListNode* slow = head;
    ListNode* fast = head;
    while (fast->next && fast->next->next) {
        slow = slow->next;
        fast = fast->next->next;
    }
    ListNode* second = reverseList(slow->next);
    slow->next = nullptr;
    ListNode* first = head;
    while (second) {
        ListNode* tmp1 = first->next;
        ListNode* tmp2 = second->next;
        first->next = second;
        second->next = tmp1;
        first = tmp1;
        second = tmp2;
    }
}

交替合并这个循环非常容易写错。我建议每次都先备份两个节点的 next，即 tmp1 和 tmp2，再做交叉连接。否则你改了 first->next 之后，原本的后继节点就找不到了。

回文链表的写法更简单：找中点、反转后半段，然后一个指针从头开始，一个指针从中点开始，逐个比较值。注意比较完之后，最好把链表恢复原样，虽然很多在线评测不检查，但这是个好习惯。

cpp复制bool isPalindrome(ListNode* head) {
    ListNode* slow = head;
    ListNode* fast = head;
    while (fast && fast->next) {
        slow = slow->next;
        fast = fast->next->next;
    }
    ListNode* second = reverseList(slow);
    ListNode* first = head;
    while (second) {
        if (first->val != second->val) return false;
        first = first->next;
        second = second->next;
    }
    return true;
}

这两道题做完，你会发现自己对“快慢指针找中点”和“原地反转”这两个工具已经非常熟练了。它们出现频率极高，几乎可以当作链表综合题的组合积木。

6. 刷链表题的高频错误与个人调试技巧

刷到最后，我发现链表题真正难的不是思路，而是“手一抖就写错”的细节。这里帮大家把我踩过的坑集中整理一下，还有一些怎么排查问题的经验。

6.1 那些年我们一起踩过的指针坑

第一个高频错误是空指针访问。在循环里访问 cur->next->next 之前，永远先确认 cur->next 不为空。这个问题在快慢指针、删除节点、反转操作里都会出现，尤其是边界情况，比如链表只有一个节点或者两个节点的时候。

第二个高频错误是断链。删除节点后没有重新接上前后部分，或者反转过程中覆盖了 next 之前没有备份，导致链表断成两截。记住我前面说的“三板斧”：改指向之前先备份，改完之后再把备份用上。

第三个高频错误是死循环。常见于反转链表时，某个节点的 next 没有正确置空，或者循环退出条件写错了。判断链表有没有环的代码，如果循环条件写成 while (fast != nullptr)，快指针本身不为空时没问题，但快指针一次走两步，可能跳过尾节点，导致越界。一定要写 while (fast && fast->next)。

我整理了一个速查表，刷题时对照着检查很管用：

6.2 我的调试三板斧

我早期刷链表题，最痛苦的不是提交报错，而是报错之后不知道错在哪。后来总结出一个很实用的调试流程。

第一板斧：写一个打印函数。把链表从头到尾的节点值打印出来，做任何复杂操作之前先打印一遍，操作后再打印一遍，肉眼对比差异。很多指针问题立刻现原形。

cpp复制void printList(ListNode* head) {
    while (head) {
        cout << head->val << " -> ";
        head = head->next;
    }
    cout << "nullptr" << endl;
}

第二板斧：画图。我到现在刷链表题还是先画图再写代码。画图不用多精细，能看出谁指向谁就行。反转链表这种题，画两三个节点，把每个步骤的箭头变化标出来，几乎不会写错。

第三板斧：用几个固定测试用例过一遍。我的常用测试集合是：空链表、单节点链表、两个节点的链表、头节点需要操作的链表、尾节点需要操作的链表、所有节点都重复的链表。这六种情况能覆盖 90% 的边界问题。

6.3 几道题做完之后，再想点什么

如果你按照上面的顺序把反转、环、合并、删除、重排这些题都刷完，你会发现它们之间是相互连接的。反转链表是 K 个一组翻转的地基；合并两个有序链表是合并 K 个链表和排序链表的地基；快慢指针找中点是重排链表和回文链表的地基。

我个人刷题的经验是，不要追求一天刷很多道，而是把同类型的题目放在一起做，做一道就把这一类题的套路总结出来。链表题的套路其实很有限：虚拟头、双指针、快慢指针、递归、归并。把这五个工具装进脑子里，遇到新题先想清楚属于哪一类，再动手写代码，正确率会高很多。

最后再分享一个工程上的小建议。工作中真正操作链表的机会可能没有刷题这么多，但链表题的思维方式依然很有用：比如做内存池管理、LRU 缓存、任务队列调度的时候，本质都是在操作节点指针。把刷题时养成的“先考虑边界、再考虑主流程、最后考虑异常”的习惯带到工程代码里，写出来的代码会稳健很多。如果你刚开始刷链表题，我建议就把这五类题目刷透，不要贪多，每道题至少保证一次性 bug-free 通过，再进入下一类。