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

1 我卡住的点

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

2 精确的规则

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

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

3 两个场景对照

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

1
2
3

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

三个角色分工：

关键理解：

• 删除、交换过程中真实头可能会变，但不需要单独维护"头指针"——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

一句话 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 里的"先接后面，再改前面"
• 能说出一条总规则：改指针前先防断链