链表 - 标签 - 豆浆小屋

Q142 环形链表II

Tue, 04 Aug 2026 00:00:00 +0000

题目：给定一个链表的头节点 head，返回链表开始入环的第一个节点。如果链表无环，返回 null。

1 我的想法

最容易踩的坑：以为快慢指针第一次相遇就是答案。第一次相遇点不是环入口——相遇后还要从头再走一遍：让 cur（从 head 出发）和 fast（停在相遇点）同步各走 1 步，两者相遇的位置才是环入口。

2 简要回答

fast 每次 2 步、slow 每次 1 步，若 fast 或 fast->next 为空 → 无环，返回 null。
第一次 fast == slow → 有环，记下相遇点。
cur = head，cur 与 fast 各走 1 步，直到 fast == cur → 返回该节点（环入口）。

时间复杂度：$O(n)$
空间复杂度：$O(1)$

3 为什么第一次相遇点不是入口

第一次相遇发生在环内，具体是环内哪个点取决于 a 和 b 的比例，没有任何规律保证它是入口。所以第二阶段必须有。

4 为什么第二轮双指针能在入口相遇

设 head→环入口距离为 a，环入口→第一次相遇点（沿前进方向）距离为 b，环长为 c。

相遇时（fast 走的路程是 slow 的 2 倍）：

1
2
3
4
5


slow 走：a + b
fast 走：2(a + b) = a + b + n·c     （fast 比 slow 多绕了 n 圈）

⇒  a + b = n·c
⇒  a = n·c - b

含义：

从 head 走 a 步 → 到达环入口；
从相遇点走 a 步 → 绕 n 圈后再退 b 步 → 也到达环入口。

所以 cur（head 出发）和 fast（相遇点出发）同步各走 1 步，恰好都在走 a 步后到达环入口，相遇。

5 代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode* fast = head;
        ListNode* slow = head;
        while (fast != nullptr) {
            if (fast->next == nullptr) {
                return nullptr;          // 无环
            }
            fast = fast->next->next;     // 走 2 步
            slow = slow->next;           // 走 1 步
            if (fast == slow) {          // 第一次相遇，说明有环
                ListNode* cur = head;
                while (fast != cur) {    // 同步走 1 步
                    cur = cur->next;
                    fast = fast->next;
                }
                return cur;              // 环入口
            }
        }
        return nullptr;                  // fast 走到末尾，无环
    }
};

用 1→2→3→4→5→(3)（3 是环入口，环长 3）验证：第一次相遇点在 5，第二阶段从 head 和 5 同步走，在 3 相遇 → 返回 3 ✓。

6 无环与空指针

无环：fast 先到末尾，fast == nullptr 退出循环，返回 null。
空链表 / 单节点：fast == nullptr 或 fast->next == nullptr，返回 null。
fast->next->next 在 fast->next == nullptr 已排除的前提下是安全的（最多为 null，下一轮循环判断）。

7 易错点

第一次 fast == slow 直接 return 是错的：那只是环内某个点，不是入口。
第二阶段不需要判空：已确认有环，cur 和 fast 必然相遇。
无环判断必须覆盖 fast == nullptr 和 fast->next == nullptr 两种。
第一阶段别把 slow 写成走 2 步——快慢都走 2 步永远追不上。

Q160 链表相交

Tue, 04 Aug 2026 00:00:00 +0000

题目：给你两个单链表的头节点 headA 和 headB，找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null。

1 我的想法

自己做出来了，但第一版踩了一个坑：提前 return nullptr 的条件写错，导致"长度不等且相交"的用例误判。

第一版：(flag1||flag2) && (cur1==nullptr||cur2==nullptr) → 只要有一个指针换过链，另一个一到 null 就返回 null，提前退出。
修正：改成 (flag1&&flag2)，两个指针都换过链之后，才可能真正没有交点。

核心：双指针各自走完自己的链后切到对方链上，把"长度差"抹平。有交点时两者会在交点相遇；没有交点时两者同时走到 null 退出。关键：提前 return 的条件必须是 flag1&&flag2，而不是 flag1||flag2。

2 简要回答

cur1、cur2 分别从 headA、headB 出发，同步一次走一个节点。
谁走到 null 就换到另一条链的头部继续走（cur1 走完 A 切到 B，cur2 走完 B 切到 A）。
相遇点就是交点；若最终都变成 null 则无交点，返回 null。

时间复杂度：$O(n + m)$（n、m 为两链长度，最坏各走两条链）
空间复杂度：$O(1)$

3 为什么"换链"能抹平长度差

两条链长度不同时，cur1、cur2 不可能在交点同步相遇。但换链之后：

cur1 总共走完 lenA + lenB 个节点；
cur2 同样总共走完 lenB + lenA 个节点。

两者总步数相同，于是：

有交点：在各自总步数到达交点时（差量被抹平）相遇。
无交点：两者在最后一步同时走到 null，cur1 == cur2 == nullptr，循环退出。

4 代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
    if (headA == nullptr || headB == nullptr) {
        return nullptr;
    }
    auto cur1 = headA;
    auto cur2 = headB;
    bool flag1 = 0;
    bool flag2 = 0;
    while (cur1 != cur2) {
        cur1 = cur1->next;
        cur2 = cur2->next;
        if ((flag1 && flag2) && (cur1 == nullptr || cur2 == nullptr)) {
            return nullptr;
        }
        if (cur1 == nullptr) {
            cur1 = headB;
            flag2 = 1;
        }
        if (cur2 == nullptr) {
            cur2 = headA;
            flag1 = 1;
        }
    }
    return cur1;
}

5 更简洁的等价写法

不需要 flag，利用"换链 + 循环退出条件"本身就覆盖了无交点的情况：

1
2
3
4
5
6
7
8
9


ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
    auto cur1 = headA;
    auto cur2 = headB;
    while (cur1 != cur2) {
        cur1 = cur1 ? cur1->next : headB;
        cur2 = cur2 ? cur2->next : headA;
    }
    return cur1;
}

无交点时两个指针同时变为 null，while 退出返回 null，天然正确。
空链也能安全处理：cur1 ? ... 不会对 null 解引用，也就不需要开头的空链判断。
注意：两个版本都只保证"相遇或同时为 null"，不能提前在某一个为 null 时就断定无交点。

6 易错点

提前 return 的条件写错是最容易犯的错：flag1||flag2 会在"长度不等且相交"时提前返回 null（先走完的那条链先到 null，但另一个指针还差几步，交点还没走到）。
换成 flag1&&flag2 后，两个指针都换过链，才开始判断 null；且两指针总步数相同，会同时为 null，判断是安全的。
flag 命名容易混淆：这里 flag1 实际记录的是"cur2 换链"，flag2 记录的是"cur1 换链"，阅读时要当心。
直接对 null 解引用 cur1->next 会段错误：若用带 flag 的写法，务必在开头判空；用三元写法则天然安全。

Q19 删除链表的倒数第N个节点

Tue, 04 Aug 2026 00:00:00 +0000

题目：给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

我的想法 自己独立做出来了。过程中解决了两个疑问：

fast 先走会不会越界？模拟后确认不会——fast 恰好走到 nullptr 这个合法终点就停。

删除后 return 不好 return？因为头可能被删，答案必须从 dummy->next 拿；而且顺序是：先重接、再删除；先读答案、再删 dummy。

这篇笔记的核心 虚拟头 + 快慢指针：fast 先走 n+1 步，再快慢一起走，slow 正好停在"目标节点的前驱"。删除顺序：先重接，再删除；先读答案，再删 dummy。

1 简要回答

fast 从 dummy 出发先走 n+1 步。
fast、slow 一起走，直到 fast == nullptr。此时 slow 是倒数第 n 个节点的前驱。
重接链表、删除目标节点，返回 dummy->next。

时间复杂度 $O(n)$，空间复杂度 $O(1)$。

2 详细回答

2.1 为什么 fast 先走 n+1 步不会越界

假设链表长度是 L，n 最大等于 L。从 dummy 出发走 n+1 步，最多走 L+1 步：

1

dummy(0) → 1(1) → 2(2) → … → nodeL(L) → nullptr(L+1)

最后一步是在 nodeL 上执行 fast = fast->next，结果是 nullptr——nullptr 是合法终点，不是越界。真正的越界只发生在对 nullptr 解引用时（比如 fast 已经是 nullptr 还写 fast->next）。只要步数设计成"恰好停在 nullptr"，并且后续循环先检查 fast != nullptr，就不会崩。

2.2 代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


ListNode* removeNthFromEnd(ListNode* head, int n) {
    ListNode* dummy = new ListNode(0, head);
    ListNode* fast = dummy;
    ListNode* slow = dummy;

    for (int i = 0; i <= n; ++i) {   // fast 先走 n+1 步
        fast = fast->next;
    }
    while (fast != nullptr) {        // 快慢一起走
        fast = fast->next;
        slow = slow->next;
    }
    // 现在 slow 是目标节点的前驱
    ListNode* target = slow->next;   // ① 记住要删的节点
    slow->next = slow->next->next;   // ② 先重接链表（摘下来）
    delete target;                   // ③ 再删除目标

    ListNode* result = dummy->next;  // ④ 先读答案
    delete dummy;                    // ⑤ 再删 dummy（可选）
    return result;
}

2.3 我的实现（验证通过）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


ListNode* removeNthFromEnd(ListNode* head, int n) {
    ListNode* dummyhead = new ListNode(-1, head);
    ListNode* fast = dummyhead;
    ListNode* slow = dummyhead;
    fast = fast->next;                 // 先手动走 1 步
    for (int i = 0; i < n; i++) {      // 再走 n 步，合计 n+1 步
        fast = fast->next;
    }
    while (fast != nullptr) {
        fast = fast->next;
        slow = slow->next;
    }
    auto temp = slow->next;
    slow->next = slow->next->next;
    delete temp;
    return dummyhead->next;
}

和标准写法等价：手动 fast = fast->next + for 循环 n 步 = 从 dummy 一共走 n+1 步。
没 delete dummyhead 也没关系（LeetCode 不检查泄漏）；如果要删，先 result = dummyhead->next 再删。

2.4 删除与返回的顺序（我卡过的地方）

先重接，再删除：必须先把 slow->next 指向目标的下一个，目标才能从链表里摘下来；先 delete target 的话，链表还挂着指向已释放内存的指针 → use-after-free（之前见过的 ASan 报错）。
先读答案，再删 dummy：result = dummy->next 必须在 delete dummy 之前；顺序反了就是读已释放内存。不删 dummy 也不会错（LeetCode 不检查泄漏），删了是好习惯。
为什么答案从 dummy->next 拿：当 n == 链表长度时，删除的是原头节点，head 指向的节点已经没了；而 dummy->next 在重接时自动更新成新头，所以它永远是"当前真实头"。

3 知识扩展

易错点

删除目标节点前，必须先重接链表。

n 等于链表长度时，删的是头：此时 slow 就是 dummy，dummy->next 自动变成原第二个节点。

先走 n 步还是 n+1 步，取决于循环条件：n+1 步 + while (fast) 和 n 步 + while (fast->next) 等价，选一种记熟。

空链表（head 为 null）时循环条件要能安全退出。

3.1 相关笔记

Q206 反转链表（dummy 的用法）
Q24 两两交换链表中的节点（先重接再删除/交换）
空指针与虚拟头节点（dummy 站岗，dummy->next 交卷）
指针交接瞬间（改指针前先防断链）
链表常用操作总结

3.2 自测

能解释 fast 先走 n+1 步为什么不会越界
能说出删除三步的顺序：记住目标 → 重接 → 删除
能解释为什么答案必须从 dummy->next 拿
能说出 n == 链表长度时，slow 停在哪里
手写一遍完整代码

Q206 反转链表

Tue, 04 Aug 2026 00:00:00 +0000

题目：给你单链表的头节点 head，请你反转链表，并返回反转后的链表。输入：1 → 2 → 3 → 4 → 5，输出：5 → 4 → 3 → 2 → 1。

1 简要回答

递归版把问题拆成两步：

1
2


反转 1→2→3→4
= 先反转 2→3→4（得到 4→3→2），再把 1 接到 2 的后面

每次递归返回：反转后链表的头节点（也就是原链表的尾节点，全程不变）。
自己这一层只做两件事：head->next->next = head（把原后继反过来指向自己）、head->next = nullptr（断开旧指针，防止成环）。
时间复杂度 $O(n)$，空间复杂度 $O(n)$（递归栈深度）。

2 递归三步法：把它当成数学归纳法

基例：空链表或只有一个节点，反转后还是它自己，直接返回。
假设子问题已解决：reverseList(head->next) 返回的 last，就是 head 后面那段链表反转后的新头。
只处理自己：把 head 挂到新链表末尾，并断开原来的 next。

关键是第 2 步的"信任"。递归不是让你跟踪每一层调用，而是假设"更短的链表已经被别人正确反转好了"。

1
2
3
4
5
6
7
8
9


ListNode* reverseList(ListNode* head) {
    if (head == nullptr || head->next == nullptr) {
        return head;                          // 基例
    }
    ListNode* last = reverseList(head->next); // 假设后面已经反转好
    head->next->next = head;                  // 把自己挂到末尾
    head->next = nullptr;                     // 断开旧指针
    return last;                              // 新头始终不变
}

2.1 为什么 head->next->next = head 就完成了"挂到末尾"

递归返回后，head->next 仍然是原来的后继节点，但它已经变成反转后子链表的最后一个节点：

1
2
3


反转前：          head → head->next → ... → last
调用后（还没处理 head 时）：
                  head → (4 → 3 → 2)        ← head->next 现在指向 2，正好是子链表尾巴

所以 head->next->next = head 的意思是：“让子链表的尾巴再指向我”，于是 head 就被接到了末尾。

2.2 完整回溯过程（1 → 2 → 3 → 4）

递归先一路走到 4，返回 4（基例）。然后从 3 开始逐层往回处理：

层	执行前	执行 `head->next->next = head`	再执行 `head->next = nullptr`	返回
head=3	`1→2→3→4→∅`	`1→2→3→4→3`（暂时成环）	`1→2→3→∅`，`4→3`	`4`
head=2	`1→2→3→∅`，`4→3`	`1→2→3→2`（暂时成环）	`1→2→∅`，`4→3→2`	`4`
head=1	`1→2→∅`，`4→3→2`	`1→2→1`（暂时成环）	`1→∅`，`4→3→2→1`	`4`

最终：4→3→2→1→∅，返回的 last 一直是 4。

关键直觉：每个节点在回溯时只做一件小事——“让后面的节点指回我，然后我断掉旧指针”。所有节点都做完，整条链就反过来了。

3 迭代版（对照组）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


ListNode* reverseList(ListNode* head) {
    ListNode* pre = nullptr;
    ListNode* cur = head;
    while (cur != nullptr) {
        ListNode* next = cur->next;  // 先保存下一个，防止断链
        cur->next = pre;             // 反转当前指针
        pre = cur;                   // pre 前进
        cur = next;                  // cur 前进
    }
    return pre;                      // 结束时 pre 是原链表尾，即新链表头
}

迭代版是"从前往后"逐条改箭头；递归版是"从后往前"逐层改箭头，顺序正好相反。

4 双指针改递归：不靠想象，靠机械改写

如果"信任"递归有困难，别急着理解经典版。把迭代版机械改写成递归，两者完全等价，每一步都摊在明面上。

改写只有四条规则：

迭代里的东西	改写成
循环变量 `pre`、`cur`	函数参数 `reverse(pre, cur)`
循环条件 `cur != nullptr`	开头 `if (cur == nullptr) return pre;`
循环体	原样搬进函数体
循环末尾 `pre = cur; cur = temp;`	递归调用 `return reverse(cur, temp);`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


ListNode* reverse(ListNode* pre, ListNode* cur) {
    if (cur == nullptr) return pre;      // 循环退出条件
    ListNode* temp = cur->next;          // 保存下一个，防止断链
    cur->next = pre;                     // 反转当前指针
    return reverse(cur, temp);           // 相当于 pre = cur; cur = temp; 进入下一轮
}

ListNode* reverseList(ListNode* head) {
    return reverse(nullptr, head);       // 相当于 pre = nullptr; cur = head;
}

把它展开看，就是一串循环：

1

reverse(NULL, 1) → reverse(1, 2) → reverse(2, 3) → reverse(3, 4) → reverse(4, NULL)

最后一层 cur == NULL 返回 pre（就是 4），一路原样传回，和迭代版 return pre 完全一致。

信任的本质：递归不需要你"想象"全过程，只需要验证两件事——基例对不对（空链表或最后一个节点返回正确），当前层在子问题正确的假设下对不对。两个都验证过，递归就永远正确。

经典版里 reverseList(head->next) 返回的 last，就是"循环跑完时的 pre"，全程不变。

5 虚拟头 + 头插法：把每个节点变成同一种节点

加一个虚拟头 dummy，每次把当前节点插到 dummy 后面（头插），所有节点的操作完全一样，不用特判头节点：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


ListNode* reverseList(ListNode* head) {
    ListNode* dummy = new ListNode(0);
    while (head != nullptr) {
        ListNode* next = head->next;   // 保存下一个，防止断链
        head->next = dummy->next;      // 把当前节点插到 dummy 后面
        dummy->next = head;
        head = next;
    }
    return dummy->next;                // dummy 站岗，dummy->next 交卷
}

用 1→2→3 走一遍：

1
2
3
4


dummy → 1              （插 1）
dummy → 2 → 1          （插 2）
dummy → 3 → 2 → 1      （插 3）
返回 3 → 2 → 1

和 pre = nullptr 的写法是同一个思想：nullptr/虚拟头让"第一个节点"也被统一处理。这套头插法也是反转区间、K 个一组反转的基础。

易错：② 让新节点先接住"当前最前面的节点"（已反转的那段链），③ 才把新节点放到最前面。顺序不能反：先 ③ 后 ② 会让新节点的 next 指向自己，成环。规则和"改指针前先保存/接好后面的链"是同一个——先接后面，再改前面。

6 易错点

忘记 head->next = nullptr：1→2→1 会成环，遍历直接死循环。head->next->next = head; 和 head->next = nullptr; 必须成对出现。
返回了 head 而不是 last：会得到"局部反转 + 后半段丢失"的错链。
基例只写 head == nullptr 不够：单节点链表也要直接返回，否则 head->next->next 会解引用空指针。
链表很长（如 $10^5$ 级）时递归会爆栈，工程上优先用迭代。

6.1 遇到 `AddressSanitizer: heap-use-after-free` 怎么定位

LeetCode 判题器跑完你的代码后会释放链表（freeList）。如果反转后的链表里有环，freeList 会先删掉某个节点，稍后又从环的另一条路走到这个已经删除的节点——于是报 heap-use-after-free（读到了已释放的内存）。

读报错三步：

看错误类型和位置：heap-use-after-free + 出错函数是 freeList → 不是你的代码当场崩，而是返回的链表结构坏了。
想 freeList 怎么写的：while (head) { next = head->next; delete head; head = next; }——它会读 head->next，只有链表成环（或一个节点被两条链指着）才会读到已删除节点的 next。
回代码找"谁可能制造环"：反转链表里制造反向指针的是 head->next->next = head，如果不同时 head->next = nullptr，就成了 1→2→1 的环。

细节：报错里的 16-byte region 正好是一个 ListNode（val + next 各 8 字节），READ of size 8 读的正是 next 指针。这些信息都在印证：freeList 走到一个被删过的节点上了。

自查方法：本地打印反转后的链表，最多走 $n+1$ 步；如果没遇到 nullptr 还在走，就是环。

Q24 两两交换链表中的节点

Tue, 04 Aug 2026 00:00:00 +0000

题目：给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。不能只改节点内部的值，必须实际交换节点。输入：1 → 2 → 3 → 4，输出：2 → 1 → 4 → 3。

1 我的想法

想写一个函数：接受一个起点，把后面的两个节点"翻转"一下。第一次草稿卡在：

while() 空条件、x 未定义，编译不过；
更关键的是：交换完一对之后，不知道这一对怎么接回前面的链、怎么连到下一对；
于是用 flag、heade 去补，越补越乱。

核心：两两交换 = 每次处理"一对"，但必须记住这一对的前一个节点 prev，否则交换完接不回去。用虚拟头 dummy 统一第一对。

2 简要回答

用虚拟头节点 dummy，维护指针 prev（当前这一对的前一个节点）。每一轮：

1

prev -> a -> b -> rest     交换成     prev -> b -> a -> rest

然后 prev 跳到 a（这一对的新尾巴），继续处理下一对。

时间复杂度 $O(n)$
空间复杂度 $O(1)$（迭代版；递归版为 $O(n)$ 栈空间）

3 为什么需要 prev

只交换 a、b 本身不难（a->next = b->next; b->next = a;），难的是把这一对接回前面的链。交换完成后，前面的链还指着原来的 a，必须把它的 next 改成 b——所以必须提前握着"这一对的前一个节点"。

这正好呼应"写一个函数接受起点"的想法：函数参数不应该是这一对的第一个节点，而应该是这一对的前一个节点。

4 虚拟头到底是不是"必须"的

不是必须的，它是把"头节点特判"变成"统一处理"的技巧。头节点特殊在：它没有前驱。凡是"通过前一个节点操作"的写法，头节点都没有前一个可用。

什么时候可以用 nullptr 当虚拟头，什么时候必须 new 一个真节点，看一件事——你要不要通过它修改 next：

场景	能不能用 nullptr	原因
反转链表：只读 pre（`cur->next = pre`）	可以	只是把 pre 的值赋给别人，pre 本身不参与修改
两两交换 / 删除节点：要写 prev->next（`prev->next = b`）	不行	`nullptr->next` 没法赋值，前一个节点必须真实存在

不引入 dummy 也能写 swapPairs，但第一对要单独特判：先手动交换 head 和 head->next，再进循环处理后面的对——多一段代码，多一个出错点。dummy 让第一对也走同一个 swapTwo，特殊 case 直接消失。

5 核心代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


// 交换 prev 后面的两个节点
// 调用前：prev -> a -> b -> rest
// 调用后：prev -> b -> a -> rest
void swapTwo(ListNode* prev) {
    ListNode* a = prev->next;
    ListNode* b = a->next;
    a->next = b->next;      // a 先接到 rest
    b->next = a;            // b 指回 a
    prev->next = b;         // 前面的链接上 b
}

ListNode* swapPairs(ListNode* head) {
    ListNode* dummy = new ListNode(0, head);  // 虚拟头，让第一对也有 prev
    ListNode* prev = dummy;
    while (prev->next != nullptr && prev->next->next != nullptr) {
        swapTwo(prev);
        prev = prev->next->next;   // 下一对的前一个节点 = a
    }
    return dummy->next;
}

用 1→2→3→4 走一遍：

1
2
3


dummy -> 1 -> 2 -> 3 -> 4
第 1 轮：dummy -> 2 -> 1 -> 3 -> 4，prev 跳到 1
第 2 轮：dummy -> 2 -> 1 -> 4 -> 3，prev 跳到 3

奇数个节点时，最后一对凑不齐（prev->next->next == nullptr），剩下的单个节点不动，天然正确。

6 递归版（呼应 Q206 的"信任"）

1
2
3
4
5
6
7


ListNode* swapPairs(ListNode* head) {
    if (head == nullptr || head->next == nullptr) return head;  // 基例
    ListNode* second = head->next;
    head->next = swapPairs(second->next);   // 信任子问题：后面的已经交换好
    second->next = head;                    // 这一层只交换前两个
    return second;
}

基例 + “假设后面已交换好” + 只做一步——和反转链表的信任模型完全一样。

6.1 递归版逐层拆解

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


swapPairs(1→2→3→4)
  ├─ head=1, second=2
  ├─ 先算 swapPairs(3→4)     ← 小问题 = 从第3个节点起的整段
  │    ├─ head=3, second=4
  │    ├─ swapPairs(nullptr)  ← 空链表 → 返回 nullptr（基例）
  │    ├─ 3->next = nullptr
  │    ├─ 4->next = 3
  │    └─ 返回 4             （3→4 已变 4→3）
  ├─ 回到第一层：1->next = 4   ← 4 接在 1 后面，链变成 1→4→3
  ├─ 2->next = 1              ← 最外层现在才交换 1 和 2
  └─ 返回 2                   （最终 2→1→4→3 ✓）

递归的箭头是从里往外接的：最深处的子调用先接好，再一层层回溯补上"前两个节点"的交换。每一层只保证前两个节点的顺序对，后面整段全部丢给子调用、信任它已排好——和反转链表、fib 是同一个归纳模型。不需要 dummy。

迭代 vs 递归的建链方向：

迭代版：从前往后建链，处理完一对推进 prev，需要 dummy 兜第一对。

递归版：从后往前组装，最深处先接好再回溯补前面的，不需要 dummy。

7 我的草稿为什么乱

1
2


while(){ ... }                    // 空条件，编译不过
new_cur->next = x;                // x 没定义

更本质的问题：交换完一对后，这一对的新尾巴（原第一个节点）必须接到下一对的头；草稿里没有 prev 这个概念，只能用 flag、heade 硬补，越补越乱。加了 prev + dummy 之后，flag 和 heade 都不需要了。

8 易错点

循环条件必须是 prev->next != nullptr && prev->next->next != nullptr：保证这一对真的有两个节点。
交换后 prev = prev->next->next，即这一对的新尾巴 a；写错位置会漏节点或死循环。
不要只交换 val：题目明确要求实际交换节点。
返回 dummy->next，不是 head（head 可能已经被换到第二位了）。

Q707 设计链表

Tue, 04 Aug 2026 00:00:00 +0000

题目：不使用内置链表，实现 get、头插、尾插、指定位置插入和指定位置删除。下标从 0 开始，非法查询返回 -1。

1 简要回答

使用一个虚拟头节点 dummyHead_ 和一个记录真实节点数量的 size_。虚拟头节点永远存在，但不存题目数据；真正的第一个节点是 dummyHead_->next。

插入和删除都先找到目标位置的前驱节点，再修改 next：

1
2


插入：prev -> next      变成      prev -> newNode -> next
删除：prev -> target -> next     变成      prev -------> next

size_ 只负责判断下标是否合法，不能让链表像数组一样随机访问。访问第 index 个节点仍然需要从头沿着 next 走过去。

操作	时间复杂度
`get(index)`	$O(index)$，最坏 $O(n)$
`addAtHead`	$O(1)$
`addAtTail`	$O(n)$
`addAtIndex`	$O(index)$，最坏 $O(n)$
`deleteAtIndex`	$O(index)$，最坏 $O(n)$

总空间复杂度为 $O(n)$。

2 详细回答

2.1 我的原始思路

我的思考顺序是：

先构造只包含 val 和 next 的单链表节点。
写 get(index) 时意识到需要判断越界，于是引入 numbers 记录节点数量。
看到 index 后联想到 operator[]，又尝试设计一层 NodeList。
为了实现按下标查找，一度考虑 vector 和 unordered_map。
随后发现：用现成容器保存节点，实际上绕开了"自己实现链表"的训练目标。
回到虚拟头节点，但不知道它应该放在哪里、怎样与真实节点连接。

当时的核心尝试大致是：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


struct st_node {
    int st_val{};
    st_node* st_next{};
};

class NodeList {
    int numbers{};
    vector<st_node> node_list_;
    unordered_map<int, st_node> select_table;
};

这段尝试的价值 方向虽然绕远了，但成功暴露出一个关键区别：下标是接口提供的查询条件，不代表底层必须支持数组式随机访问。

2.2 为什么会卡住

这里其实只需要两层结构：

1
2
3
4
5
6
7


MyLinkedList
├── dummyHead_：虚拟头节点
└── size_：真实节点数量

Node
├── val
└── next

不需要再增加 NodeList，也不需要重载 operator[]。

另外，构造函数里单独写：

1

st_node();

只会创建一个立即销毁的临时对象，并不会初始化链表成员。虚拟头节点必须成为 MyLinkedList 的成员：

1

MyLinkedList() : dummyHead_(new Node()), size_(0) {}

2.3 虚拟头节点到底解决什么

没有虚拟头节点时，头部插入和删除通常要单独修改 head：

1

head -> A -> B

加入虚拟头节点后：

1

dummy -> A -> B -> nullptr

此时 A 也有统一的前驱 dummy。所以在下标 0 处插入、删除，与中间位置的操作完全一样，不需要单独处理真实头节点。

2.4 最重要的定位规则

记住这一句 查询节点时找"目标节点"；插入和删除时找"目标位置的前驱节点"。

假设要在 index = 2 前插入：

1
2
3


dummy -> 0 -> 1 -> 2
                 ↑
               prev

从 dummy 出发移动 index 次，正好到达原下标 1 的节点，也就是插入位置的前驱。

2.5 完整实现

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79


class MyLinkedList {
private:
    struct Node {
        int val;
        Node* next;

        Node(int value = 0, Node* nextNode = nullptr)
            : val(value), next(nextNode) {}
    };

    Node* dummyHead_;  // 永远存在，不计入 size_
    int size_;         // 真实数据节点的数量

public:
    MyLinkedList()
        : dummyHead_(new Node()), size_(0) {}

    ~MyLinkedList() {
        Node* cur = dummyHead_;
        while (cur != nullptr) {
            Node* next = cur->next;
            delete cur;
            cur = next;
        }
    }

    int get(int index) {
        if (index < 0 || index >= size_) {
            return -1;
        }

        Node* cur = dummyHead_->next;
        for (int i = 0; i < index; ++i) {
            cur = cur->next;
        }
        return cur->val;
    }

    void addAtHead(int val) {
        addAtIndex(0, val);
    }

    void addAtTail(int val) {
        addAtIndex(size_, val);
    }

    void addAtIndex(int index, int val) {
        if (index < 0) {
            index = 0;
        }
        if (index > size_) {
            return;
        }

        Node* prev = dummyHead_;
        for (int i = 0; i < index; ++i) {
            prev = prev->next;
        }

        prev->next = new Node(val, prev->next);
        ++size_;
    }

    void deleteAtIndex(int index) {
        if (index < 0 || index >= size_) {
            return;
        }

        Node* prev = dummyHead_;
        for (int i = 0; i < index; ++i) {
            prev = prev->next;
        }

        Node* target = prev->next;
        prev->next = target->next;
        delete target;
        --size_;
    }
};

2.6 用示例走一遍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


初始：dummy

addAtHead(1)
dummy -> 1

addAtTail(3)
dummy -> 1 -> 3

addAtIndex(1, 2)
dummy -> 1 -> 2 -> 3

deleteAtIndex(1)
dummy -> 1 -> 3

每次成功插入后 size_ 加一，每次成功删除后 size_ 减一。

3 知识扩展

3.1 三个必须保持的不变量

dummyHead_ 永远存在，而且不计入 size_。
size_ 必须等于真实数据节点的数量。
最后一个真实节点的 next 必须是 nullptr。

3.2 易错点

边界区别 addAtIndex 允许 index == size_，因为这代表尾插；但 get 和 deleteAtIndex 要求 index < size_。

插入、删除成功后才修改 size_。
删除前先保存 target，重新连接后再 delete target。
虚拟头节点不是下标 0；真实下标 0 是 dummyHead_->next。
vector 和哈希表可以加速按下标访问，但那已经改变了题目要求的数据结构实现方式。

3.3 还能怎样优化

如果额外维护一个尾指针，可以把 addAtTail 优化为 $O(1)$。但删除最后一个节点时也必须正确更新尾指针，维护成本更高。当前版本先把"虚拟头节点 + 前驱定位"掌握牢更重要。

3.4 自测

能解释为什么 size_ 不能实现随机访问
能画出虚拟头节点与真实头节点的关系
不看答案写出指定位置插入
说清楚插入和删除的合法下标范围为什么不同

空指针与虚拟头节点

Tue, 04 Aug 2026 00:00:00 +0000

一句话 虚拟头 dummy 是真实存在的节点，有地址，所以可以通过 dummy->next 修改它指向的节点；而 nullptr 只是一个"值"，可以用它的值，但不能解引用——读不行，写也不行。

1 我卡住的点

反转链表里 pre = nullptr 没问题，为什么两两交换里必须 new 一个 dummy？
结论：区别在于有没有操作 pre->next（解引用）。

2 精确的规则

空指针的值可以用，空指针本身不能被解引用：

代码	合法吗	解释
`ListNode* pre = nullptr; cur->next = pre;`	✅	只把 nullptr 的值赋给 `cur->next`，操作的是 cur
`pre->next = cur;`	❌ 崩溃	解引用空指针并修改
`int v = pre->val;`	❌ 崩溃	解引用空指针，读取也不行
`ListNode* dummy = new ListNode(0); dummy->next = b;`	✅	dummy 是真实节点，有地址，可以修改它的 next

不要记成"可以调用但不能修改" 更准确的说法：可以用空指针的值，但不能解引用空指针。解引用不管是读还是写都会崩。cur->next = pre 之所以安全，是因为这里操作的是 cur->next（cur 是真实节点），pre 只是被当作一个值。

3 两个场景对照

场景	为什么
反转链表：`pre = nullptr` 够用	全程只把 pre 的值赋给 `cur->next`，没有 `pre->next` 这种操作
两两交换 / 删除节点：必须 new dummy	需要写 `prev->next = b`，必须通过真实节点修改

3.1 虚拟头模式的标准结构（我的理解）

1
2
3


ListNode* dummyHead = new ListNode(0);  // 虚拟头：头节点前面的哨兵
dummyHead->next = head;                 // 哨兵先挂住真实头
ListNode* cur = dummyHead;              // cur 是真正移动的工作指针

三个角色分工：

角色	干什么	位置变化
`dummyHead`	哨兵，站在头节点前面	永远不动
`cur`	干活（遍历、删除、交换）	一直往前走
`dummyHead->next`	返回用：当前的真实头节点	头被删/被换时自动跟着变

关键理解：

删除、交换过程中真实头可能会变，但不需要单独维护"头指针"——dummy 没动过，dummyHead->next 永远指向当前的真实头。
返回时用 dummyHead->next，不能用 cur：cur 走到最后已经在链表末尾（甚至 nullptr）了。
哨兵不参与数据，所以它的 val 随便给（0）；它的存在只是为了给头节点提供一个"前一个节点"。
一句话：dummy 站岗，cur 干活，dummy->next 交卷。

3.2 dummy 不一定要 new：可以用栈对象

链表连接靠的是 next 指针（存地址），但节点本身可以放在栈上，不用 new：

1
2
3
4
5
6
7


ListNode dummy(0, head);   // 栈上的虚拟头，不是指针
ListNode* prev = &dummy;   // 取地址当指针用
while (prev->next != nullptr && prev->next->next != nullptr) {
    swapTwo(prev);
    prev = prev->next->next;
}
return dummy.next;         // 注意是 dummy.next，不是 dummy->next

题解常写 new ListNode(0) 只是图省事（LeetCode 不检查内存泄漏），本地代码用栈对象更安全，不用手动 delete。
注意：不能把局部对象的地址返回出去（函数结束就销毁）——但 dummy 不会被返回，返回的是 dummy.next，安全。
反转链表反而不能用真实节点当 pre：最后链表尾巴会指向这个假节点，判题器释放时会崩。这再次印证：只读场景用 nullptr，要改 next 才用真实节点。

4 记忆

dummy = 真实节点 = 有一扇可以打开的门（可以改它的 next）。
nullptr = 值 = 可以借给别人当目标，但它自己没有任何房间，不能开门（不能解引用）。

5 相关笔记

Q206 反转链表（pre = nullptr 当虚拟头）
Q24 两两交换链表中的节点（必须 new dummy）
指针交接瞬间（复制指针 vs 插入）
Q707 设计链表
链表常用操作总结

6 自测

能说出 cur->next = pre（pre 为空）为什么合法
能说出 pre->next = cur（pre 为空）为什么崩溃
能判断一道新题：是"读前一个节点的值"还是"改前一个节点的 next"，从而决定用 nullptr 还是 dummy
能用栈对象写 dummy 版本（ListNode dummy(0); ListNode* prev = &dummy;）
能说出返回时为什么用 dummyHead->next 而不是 cur

链表常用操作总结

Tue, 04 Aug 2026 00:00:00 +0000

1 一、节点定义

1
2
3
4
5


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

2 二、虚拟头节点（dummy）

处理头节点可能变化的情况，统一操作逻辑：

1
2
3
4


ListNode* dummy = new ListNode(0);
dummy->next = head;
// ... 操作 ...
return dummy->next;

什么时候用 dummy？

删除节点（可能删头节点）
插入节点（可能插在头前面）
合并链表（新链表头不确定）

3 三、基础操作

3.1 1. 求链表长度

1
2
3
4
5
6
7
8


int getLength(ListNode* head) {
    int len = 0;
    while (head) {
        len++;
        head = head->next;
    }
    return len;
}

3.2 2. 找第 k 个节点

1
2
3
4
5
6


ListNode* findKth(ListNode* head, int k) {
    for (int i = 0; i < k - 1; i++) {
        head = head->next;
    }
    return head;
}

3.3 3. 找倒数第 k 个节点（快慢指针）

1
2
3
4
5
6
7
8
9


ListNode* getKthFromEnd(ListNode* head, int k) {
    ListNode *fast = head, *slow = head;
    for (int i = 0; i < k; i++) fast = fast->next;
    while (fast) {
        fast = fast->next;
        slow = slow->next;
    }
    return slow;
}

3.4 4. 找中间节点

1
2
3
4
5
6
7
8


ListNode* middleNode(ListNode* head) {
    ListNode *slow = head, *fast = head;
    while (fast && fast->next) {
        slow = slow->next;
        fast = fast->next->next;
    }
    return slow;
}

4 四、反转链表

4.1 1. 整个链表反转（迭代）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


ListNode* reverseList(ListNode* head) {
    ListNode* pre = nullptr;
    ListNode* cur = head;
    while (cur) {
        ListNode* next = cur->next;  // 保存下一个
        cur->next = pre;             // 反转指针
        pre = cur;                   // pre 前进
        cur = next;                  // cur 前进
    }
    return pre;
}

4.2 2. 整个链表反转（递归）

1
2
3
4
5
6
7


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

4.3 3. 反转区间 [left, right]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


ListNode* reverseBetween(ListNode* head, int left, int right) {
    ListNode* dummy = new ListNode(0);
    dummy->next = head;

    // 找到反转起点的前一个
    ListNode* pre = dummy;
    for (int i = 0; i < left - 1; i++) pre = pre->next;

    // 头插法反转
    ListNode* cur = pre->next;
    for (int i = 0; i < right - left; i++) {
        ListNode* next = cur->next;
        cur->next = next->next;
        next->next = pre->next;
        pre->next = next;
    }
    return dummy->next;
}

4.4 4. K 个一组反转

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


ListNode* reverseKGroup(ListNode* head, int k) {
    ListNode* dummy = new ListNode(0);
    dummy->next = head;
    ListNode* pre = dummy;

    while (true) {
        // 检查剩余够不够 k 个
        ListNode* check = pre;
        for (int i = 0; i < k; i++) {
            check = check->next;
            if (!check) return dummy->next;
        }

        // 反转 k 个
        ListNode* cur = pre->next;
        for (int i = 0; i < k - 1; i++) {
            ListNode* next = cur->next;
            cur->next = next->next;
            next->next = pre->next;
            pre->next = next;
        }
        pre = cur;  // 下一组的 pre 就是这组的尾
    }
}

5 五、合并链表

5.1 合并两个有序链表

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
    ListNode* dummy = new ListNode(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;
}

6 六、判断环

6.1 是否有环

1
2
3
4
5
6
7
8
9


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

6.2 找环的入口

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


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

7 七、删除节点

7.1 删除指定值的节点

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


ListNode* removeElements(ListNode* head, int val) {
    ListNode* dummy = new ListNode(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;
}

7.2 删除倒数第 n 个节点

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


ListNode* removeNthFromEnd(ListNode* head, int n) {
    ListNode* dummy = new ListNode(0);
    dummy->next = head;
    ListNode *fast = dummy, *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;
}

8 八、相交链表

找两个链表的交点：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


ListNode* getIntersectionNode(ListNode* headA, ListNode* headB) {
    ListNode *pA = headA, *pB = headB;
    // 指针 A 走完 A 走 B，指针 B 走完 B 走 A
    // 有交点会在交点相遇，没交点都走到 nullptr
    while (pA != pB) {
        pA = pA ? pA->next : headB;
        pB = pB ? pB->next : headA;
    }
    return pA;
}

9 九、链表题技巧总结

dummy 虚拟头：头节点可能变化时必用
快慢指针：找中点、找倒数第k、判环
画图：链表题一定要画图，不然容易绕晕
保存 next：改指针前先存下一个，防止断链
递归反转：理解「head->next->next = head」是关键

指针交接瞬间

Tue, 04 Aug 2026 00:00:00 +0000

一句话 a->next = b->next 只是"复制指针"（让 a->next 指向 b->next 指向的同一个节点）；“插入"是两步的组合：先让新节点接住后面的链，再让前面的节点改指新节点。两步之间，两个指针会短暂指向同一个节点——这就是交接瞬间。

1 赋值语义：先读清楚一行代码

head->next = dummy->next 的意思是：把 dummy->next 的值（一个地址）赋给 head->next。

右边是"源”，左边是"目标"。
执行完这一行，head->next 和 dummy->next 指向同一个节点。
单看这一行，它只是复制指针，不是插入。

2 为什么"插入"必须是两步

假设当前状态：

1
2


dummy → 2 → 1 → null
head → 3 → 4 → null

第 1 步 head->next = dummy->next（先接住后面的链）：

1
2


dummy → 2 → 1 → null
head → 3 → 2 → 1 → null     ← 交接瞬间：head 和 dummy 同时指着 2

第 2 步 dummy->next = head（前面的节点改指新节点）：

1

dummy → 3 → 2 → 1 → null     ← 插入完成

交接瞬间 第 1 步执行后的一瞬间，两个指针指向同一个节点，这是刻意的——新节点先"抓住"后面的链，前面的节点才敢"松手"。不是 bug。

3 顺序为什么不能反

如果先做 prev->next = newNode，再做 newNode->next = prev->next：

1
2
3


prev->next 已经变成 newNode
再执行 newNode->next = prev->next 就是 newNode->next = newNode
→ 自己指向自己，成环

所以顺序固定：先接后面，再改前面。

4 通用套路

4.1 标准插入两步

1
2


newNode->next = prev->next;   // ① 新节点接住后面的链
prev->next = newNode;         // ② 前面的节点改指新节点

4.2 反转链表头插法（Q206）

1
2
3
4


ListNode* next = head->next;   // 先保存下一个，防止断链
head->next = dummy->next;      // 接住已反转部分的头
dummy->next = head;            // 改指新节点
head = next;

4.3 两两交换（Q24 的 swapTwo）

1
2
3
4
5


ListNode* a = prev->next;
ListNode* b = a->next;
a->next = b->next;    // a 先接住 rest
b->next = a;          // b 指回 a
prev->next = b;       // 前面的链接上 b

4.4 一条总规则

改指针之前，先保证后面的链不会丢：

要读的旧指针，先存下来（next = cur->next）；
新节点要接的链，先接上（head->next = dummy->next）。

5 记忆

单行赋值 = 复制指针（两个指针指向同一个节点）。
两步组合 = 插入（先接住，再松手）。
口诀：先接后面，再改前面；改指针前，先防断链。

6 相关笔记

Q206 反转链表（头插法）
Q24 两两交换链表中的节点（swapTwo）
空指针与虚拟头节点（dummy 是什么、为什么需要真实节点）

7 自测

能说出 head->next = dummy->next 执行后，哪两个指针指向同一个节点
能把"标准插入两步"默写出来
能解释为什么顺序不能反（会成环）
能指出反转头插法和 swapTwo 里的"先接后面，再改前面"
能说出一条总规则：改指针前先防断链

链表 - 标签 - 豆浆小屋

Q142 环形链表II

1 我的想法

2 简要回答

3 为什么第一次相遇点不是入口

4 为什么第二轮双指针能在入口相遇

5 代码

6 无环与空指针

7 易错点

Q160 链表相交

1 我的想法

2 简要回答

3 为什么"换链"能抹平长度差

4 代码

5 更简洁的等价写法

6 易错点

Q19 删除链表的倒数第N个节点

1 简要回答

2 详细回答

2.1 为什么 fast 先走 n+1 步不会越界

2.2 代码

2.3 我的实现（验证通过）

2.4 删除与返回的顺序（我卡过的地方）

3 知识扩展

3.1 相关笔记

3.2 自测

Q206 反转链表

1 简要回答

2 递归三步法：把它当成数学归纳法

2.1 为什么 head->next->next = head 就完成了"挂到末尾"

2.2 完整回溯过程（1 → 2 → 3 → 4）

3 迭代版（对照组）

4 双指针改递归：不靠想象，靠机械改写

5 虚拟头 + 头插法：把每个节点变成同一种节点

6 易错点

6.1 遇到 AddressSanitizer: heap-use-after-free 怎么定位

Q24 两两交换链表中的节点

1 我的想法

2 简要回答

3 为什么需要 prev

4 虚拟头到底是不是"必须"的

5 核心代码

6 递归版（呼应 Q206 的"信任"）

6.1 递归版逐层拆解

7 我的草稿为什么乱

8 易错点

Q707 设计链表

1 简要回答

2 详细回答

2.1 我的原始思路

2.2 为什么会卡住

2.3 虚拟头节点到底解决什么

2.4 最重要的定位规则

2.5 完整实现

2.6 用示例走一遍

3 知识扩展

3.1 三个必须保持的不变量

3.2 易错点

3.3 还能怎样优化

3.4 自测

空指针与虚拟头节点

1 我卡住的点

2 精确的规则

3 两个场景对照

3.1 虚拟头模式的标准结构（我的理解）

3.2 dummy 不一定要 new：可以用栈对象

4 记忆

5 相关笔记

6 自测

链表常用操作总结

1 一、节点定义

2 二、虚拟头节点（dummy）

3 三、基础操作

3.1 1. 求链表长度

3.2 2. 找第 k 个节点

3.3 3. 找倒数第 k 个节点（快慢指针）

3.4 4. 找中间节点

4 四、反转链表

4.1 1. 整个链表反转（迭代）

4.2 2. 整个链表反转（递归）

6.1 遇到 `AddressSanitizer: heap-use-after-free` 怎么定位