双指针 - 标签 - 豆浆小屋

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 可能已经被换到第二位了）。

滑动窗口模板

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

1 核心思想

维护一个窗口 [left, right]，right 不断向右扩展，满足条件时 left 向右收缩，窗口内的元素始终满足某个条件。

适用场景： 子数组 / 子串问题，求最长 / 最短 / 数量

2 一、模板框架

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


int slidingWindow(vector<int>& nums) {
    int left = 0, ans = 0;
    // 窗口状态变量（计数、求和等）

    for (int right = 0; right < nums.size(); right++) {
        // 1. 右端点进入窗口，更新窗口状态

        while (窗口不满足条件) {  // 或 if，看题目
            // 2. 左端点移出窗口，更新窗口状态
            left++;
        }

        // 3. 此时窗口是合法的，更新答案
        ans = max(ans, right - left + 1);
    }
    return ans;
}

3 二、经典题型

3.1 题型 1：最长无重复子串（LeetCode 3）

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


int lengthOfLongestSubstring(string s) {
    unordered_map<char, int> window;
    int left = 0, ans = 0;

    for (int right = 0; right < s.size(); right++) {
        char c = s[right];
        window[c]++;

        while (window[c] > 1) {  // 出现重复，收缩
            char d = s[left];
            window[d]--;
            left++;
        }

        ans = max(ans, right - left + 1);
    }
    return ans;
}

3.2 题型 2：最小覆盖子串（LeetCode 76）

找 s 中包含 t 所有字符的最短子串。

 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


string minWindow(string s, string t) {
    unordered_map<char, int> need, window;
    for (char c : t) need[c]++;

    int left = 0, valid = 0;
    int start = 0, minLen = INT_MAX;

    for (int right = 0; right < s.size(); right++) {
        char c = s[right];
        if (need.count(c)) {
            window[c]++;
            if (window[c] == need[c]) valid++;
        }

        while (valid == need.size()) {  // 满足条件，收缩找最小
            if (right - left + 1 < minLen) {
                minLen = right - left + 1;
                start = left;
            }

            char d = s[left];
            if (need.count(d)) {
                if (window[d] == need[d]) valid--;
                window[d]--;
            }
            left++;
        }
    }
    return minLen == INT_MAX ? "" : s.substr(start, minLen);
}

3.3 题型 3：和为 K 的子数组个数（前缀和+哈希）

注意：有负数时不能用滑动窗口，因为窗口不单调，要用前缀和+哈希。

4 三、什么时候用滑动窗口？

4.1 能用滑动窗口的条件

数组元素都是正数（窗口扩展和增大，收缩和减小）
求子数组的最长 / 最短 / 数量
条件具有单调性：窗口变大条件从满足变不满足（或反过来）

4.2 不能用滑动窗口

有负数（窗口增大和不一定增大）
求子序列（不连续）
条件不单调

5 四、固定窗口大小

窗口大小固定为 k，滑动遍历：

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


// 大小为 k 的子数组最大和
int maxSum(vector<int>& nums, int k) {
    int sum = 0;
    for (int i = 0; i < k; i++) sum += nums[i];  // 第一个窗口

    int ans = sum;
    for (int i = k; i < nums.size(); i++) {
        sum += nums[i] - nums[i - k];  // 滑一格：加新的，减出去的
        ans = max(ans, sum);
    }
    return ans;
}

6 五、题目分类速查

类型	代表题	思路
最长无重复	LeetCode 3	哈希表计数，重复就收缩
最小覆盖子串	LeetCode 76	need + window + valid
字母异位词	LeetCode 438	固定窗口，比较计数
最长重复字符替换	LeetCode 424	窗口内最多字符数 + k
水果成篮	LeetCode 904	最多两种水果，最长子数组
和为 s 的最短子数组	LeetCode 209	正整数，收缩求最短
乘积小于 K 的子数组	LeetCode 713	正数，收缩计数

7 六、解题步骤

初始化 left = 0，答案变量
遍历 right 从 0 到 n-1
右端点加入窗口，更新状态
窗口不合法时，while 循环收缩左端点
窗口合法时，更新答案

口诀：右扩左缩，边扩边更，缩完算答

双指针技巧总结

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

1 一、快慢指针（Floyd 判圈算法）

一个快指针走两步，一个慢指针走一步，常用于链表问题。

1.1 应用 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;
}

1.2 应用 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;
}

1.3 应用 3：找链表中点

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;
}

1.4 应用 4：找倒数第 k 个节点

快指针先走 k 步，然后同速走，快到末尾时慢就是倒数第 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;
}

2 二、左右指针（对撞指针）

一个在头，一个在尾，往中间走。

2.1 应用 1：两数之和 II（有序数组）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


vector<int> twoSum(vector<int>& numbers, int target) {
    int left = 0, right = numbers.size() - 1;
    while (left < right) {
        int sum = numbers[left] + numbers[right];
        if (sum == target) return {left + 1, right + 1};
        else if (sum < target) left++;
        else right--;
    }
    return {-1, -1};
}

2.2 应用 2：盛最多水的容器

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


int maxArea(vector<int>& height) {
    int left = 0, right = height.size() - 1;
    int ans = 0;
    while (left < right) {
        int area = min(height[left], height[right]) * (right - left);
        ans = max(ans, area);
        // 移动矮的那边才有可能更大
        if (height[left] < height[right]) left++;
        else right--;
    }
    return ans;
}

2.3 应用 3：三数之和

排序 + 固定一个数 + 双指针找另外两个：

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


vector<vector<int>> threeSum(vector<int>& nums) {
    sort(nums.begin(), nums.end());
    vector<vector<int>> ans;

    for (int i = 0; i < nums.size(); i++) {
        if (i > 0 && nums[i] == nums[i-1]) continue;  // 去重
        int left = i + 1, right = nums.size() - 1;
        while (left < right) {
            int sum = nums[i] + nums[left] + nums[right];
            if (sum == 0) {
                ans.push_back({nums[i], nums[left], nums[right]});
                while (left < right && nums[left] == nums[left+1]) left++;   // 去重
                while (left < right && nums[right] == nums[right-1]) right--; // 去重
                left++; right--;
            } else if (sum < 0) left++;
            else right--;
        }
    }
    return ans;
}

2.4 应用 4：反转字符串 / 回文判断

1
2
3
4
5
6
7
8


bool isPalindrome(string s) {
    int left = 0, right = s.size() - 1;
    while (left < right) {
        if (s[left] != s[right]) return false;
        left++; right--;
    }
    return true;
}

3 三、滑动窗口指针

本质也是双指针，left 和 right 维护一个窗口。详见「滑动窗口模板」。

4 四、快慢指针在数组中的应用

4.1 原地删除重复元素（LeetCode 26）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


int removeDuplicates(vector<int>& nums) {
    if (nums.empty()) return 0;
    int slow = 0;
    for (int fast = 1; fast < nums.size(); fast++) {
        if (nums[fast] != nums[slow]) {
            slow++;
            nums[slow] = nums[fast];
        }
    }
    return slow + 1;
}

4.2 移动零（LeetCode 283）

1
2
3
4
5
6
7
8
9


void moveZeroes(vector<int>& nums) {
    int slow = 0;
    for (int fast = 0; fast < nums.size(); fast++) {
        if (nums[fast] != 0) {
            swap(nums[slow], nums[fast]);
            slow++;
        }
    }
}

5 五、双指针题型速查

类型	指针运动方式	典型题
快慢指针	同方向，速度不同	链表环、中点、倒数第k个
左右指针	两端向中间	两数之和、盛水、三数之和、回文
滑动窗口	同方向，维护窗口	子串、子数组问题
原地修改	慢存快扫	去重、移动零

6 六、判断技巧

链表问题 → 先想快慢指针
有序数组求和 → 先想左右指针
子数组/子串 → 先想滑动窗口
原地修改数组 → 先想快慢指针（慢存快扫）

双指针 - 标签 - 豆浆小屋

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 易错点

滑动窗口模板

1 核心思想

2 一、模板框架

3 二、经典题型

3.1 题型 1：最长无重复子串（LeetCode 3）

3.2 题型 2：最小覆盖子串（LeetCode 76）

3.3 题型 3：和为 K 的子数组个数（前缀和+哈希）

4 三、什么时候用滑动窗口？

4.1 能用滑动窗口的条件

4.2 不能用滑动窗口

5 四、固定窗口大小

6 五、题目分类速查

7 六、解题步骤

双指针技巧总结

1 一、快慢指针（Floyd 判圈算法）

1.1 应用 1：判断链表是否有环

1.2 应用 2：找环的入口

1.3 应用 3：找链表中点

1.4 应用 4：找倒数第 k 个节点

2 二、左右指针（对撞指针）

2.1 应用 1：两数之和 II（有序数组）

2.2 应用 2：盛最多水的容器

2.3 应用 3：三数之和

2.4 应用 4：反转字符串 / 回文判断

3 三、滑动窗口指针

4 四、快慢指针在数组中的应用

4.1 原地删除重复元素（LeetCode 26）

4.2 移动零（LeetCode 283）

5 五、双指针题型速查

6 六、判断技巧

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