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

1 我的想法

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

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

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

2 简要回答

1. cur1、cur2 分别从 headA、headB 出发，同步一次走一个节点。
2. 谁走到 null 就换到另一条链的头部继续走（cur1 走完 A 切到 B，cur2 走完 B 切到 A）。
3. 相遇点就是交点；若最终都变成 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 的写法，务必在开头判空；用三元写法则天然安全。

题目：给你单链表的头节点 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 递归三步法：把它当成数学归纳法

1. 基例：空链表或只有一个节点，反转后还是它自己，直接返回。
2. 假设子问题已解决：reverseList(head->next) 返回的 last，就是 head 后面那段链表反转后的新头。
3. 只处理自己：把 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 开始逐层往回处理：

最终：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 双指针改递归：不靠想象，靠机械改写

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

改写只有四条规则：

 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（读到了已释放的内存）。

读报错三步：

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

题目：给定一个升序整数数组 nums 和目标值 target。如果目标值存在，返回它的下标；否则返回 -1。题目保证数组中的元素不重复。

1 简要回答

二分查找适用于有序数组。每次比较中间元素与目标值，根据大小关系排除一半搜索范围，直到找到目标值或区间为空。

真正容易出错的地方不是算法思想，而是区间边界。写代码前必须先确定搜索区间是 [left, right] 还是 [left, right)，并让循环条件与边界更新始终遵守这个定义，这就是循环不变量。

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

2 核心思想

设数组为：

1
2
3

下标：  0   1   2   3   4   5
数组： -1   0   3   5   9  12
目标： target = 9

查找过程：

1
2
3
4
5

第 1 次：[0, 5]，mid = 2，nums[2] = 3 < 9
         排除下标 0～2，下一轮搜索 [3, 5]

第 2 次：[3, 5]，mid = 4，nums[4] = 9
         找到目标，返回下标 4

每次至少排除当前区间的一半，所以最多查找约 $\log_2 n$ 次。

3 什么是循环不变量

在循环开始、执行过程中和结束时，搜索目标所在区间的定义始终不变。

例如选择左闭右闭区间 [left, right] 后：

• left 指向的元素在搜索范围内。
• right 指向的元素也在搜索范围内。
• 每次更新后，新的区间仍然必须是左闭右闭。

因此不能一会儿按照闭区间写 right = mid - 1，一会儿又按照开区间写 right = mid。

4 size 与 size - 1 的区别

假设数组中有 6 个元素：

1
2
3

元素个数 size = 6
有效下标：0、1、2、3、4、5
最后一个有效下标：size - 1 = 5

因此，size 表示的是元素个数，而 size - 1 才是最后一个元素的下标。

4.1 为什么左闭右闭使用 size - 1

左闭右闭区间 [left, right] 包含 right：

1
2

数组有效下标：[0, 5]
搜索区间：    [0, 5]

所以 right 必须指向最后一个有效元素：

1

int right = static_cast<int>(nums.size()) - 1;

如果这里写成 right = nums.size()，就会把不存在的 nums[6] 也放进搜索范围，可能造成越界。

4.2 为什么左闭右开使用 size

左闭右开区间 [left, right) 不包含 right：

1
2

数组有效下标：[0, 5]
搜索区间：    [0, 6)

虽然 right = 6，但右端点不参与搜索，真正包含的仍然是下标 0～5：

1

int right = static_cast<int>(nums.size());

记忆方法：

• 右边界包含在区间里：它必须是有效下标，所以使用 size - 1。
• 右边界不包含在区间里：它可以指向末尾元素的后一个位置，所以使用 size。

5 写法一：左闭右闭区间

因为左右端点都有效，所以：

• 初始化：right = nums.size() - 1
• 循环条件：left <= right
• 去左半边：right = mid - 1
• 去右半边：left = mid + 1

 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:
    int search(vector<int>& nums, int target) {
        int left = 0;
        int right = static_cast<int>(nums.size()) - 1;

        // 搜索区间始终是 [left, right]
        while (left <= right) {
            int mid = left + (right - left) / 2;

            if (nums[mid] == target) {
                return mid;
            }
            if (nums[mid] < target) {
                left = mid + 1;   // 下一轮：[mid + 1, right]
            } else {
                right = mid - 1;  // 下一轮：[left, mid - 1]
            }
        }

        return -1;
    }
};

初学时可以先固定使用左闭右闭写法。循环条件和边界更新比较对称：<=、mid + 1、mid - 1。

6 写法二：左闭右开区间

因为右端点不在搜索范围内，所以：

• 初始化：right = nums.size()
• 循环条件：left < right
• 去左半边：right = mid
• 去右半边：left = mid + 1

 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:
    int search(vector<int>& nums, int target) {
        int left = 0;
        int right = static_cast<int>(nums.size());

        // 搜索区间始终是 [left, right)
        while (left < right) {
            int mid = left + (right - left) / 2;

            if (nums[mid] == target) {
                return mid;
            }
            if (nums[mid] < target) {
                left = mid + 1;  // 下一轮：[mid + 1, right)
            } else {
                right = mid;     // 下一轮：[left, mid)
            }
        }

        return -1;
    }
};

7 两种写法对照

不要混用：[left, right] 配套的是 left <= right 和 right = mid - 1；[left, right) 配套的是 left < right 和 right = mid。混用会漏查元素、越界或造成死循环。

8 为什么这样计算 mid

推荐写法：

1

int mid = left + (right - left) / 2;

不推荐：

1

int mid = (left + right) / 2;

数学结果相同，但当 left 和 right 很大时，left + right 可能发生整数溢出。先计算差值更加安全。

9 二分查找的真正前提

基础二分查找需要搜索空间具有单调性。在本题中表现为数组升序，因此比较 nums[mid] 与 target 后能够确定目标只可能位于哪一半。

数组中有重复元素还能二分吗？可以。重复元素不会让普通二分查找失效，但返回的可能是任意一个匹配位置。如果题目要求第一个或最后一个匹配位置，就需要使用边界二分（lower_bound / upper_bound）。

9.1 常见应用

• 在有序数组中查找某个值。
• 查找第一个大于等于目标值的位置，即 lower_bound。
• 查找最后一个小于等于目标值的位置。
• 对具有单调性的答案范围进行"二分答案"。

相关练习：LeetCode 35 搜索插入位置、LeetCode 34 查找元素首末位置、LeetCode 69 x 的平方根、LeetCode 367 有效的完全平方数。

10 空数组的细节

vector::size() 返回无符号整数。如果直接计算 nums.size() - 1，空数组时会发生无符号下溢。因此左闭右闭版本先转换为有符号整数：

1

int right = static_cast<int>(nums.size()) - 1;

11 易错点

• 没先定义搜索区间，就开始拼凑边界代码。
• 左闭右闭写成 while (left < right)，漏掉只剩一个元素的情况。
• 左闭右开写成 right = mid - 1，额外漏掉一个元素。
• 写成 left = mid 或 right = mid 时没有证明区间一定缩小，可能死循环。
• 使用 (left + right) / 2，忽略整数溢出风险。
• 看到重复元素就认为不能二分；真正的问题是返回哪一个匹配位置。