中等 - 标签 - 豆浆小屋

Q1314 矩阵区域和

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

![](Pasted image 20260605194937.png)

题目类型：前缀和

当你发现是在求某个大的集合下一系列具体的子集时，你可以考虑下前缀和，它可以把遍历，变成值相减。

我的写法是：

 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


#include 
#include  // for std::max, std::min
using namespace std;

// 二维前缀和类，用于快速计算任意矩形子矩阵的和
class SumMatrix {
public:
    // preSum[i][j] 表示原始矩阵中前 i 行、前 j 列（即区域 [0, i) × [0, j)）所有元素的和
    // 维度为 (m+1) x (n+1)，其中 m、n 为原始矩阵的行数和列数
    vector<vector<int>> preSum;

    // 构造函数：根据原始矩阵 matrix 构建前缀和数组
    SumMatrix(vector<vector<int>>& matrix) {
        int m = matrix.size();          // 原始矩阵的行数
        int n = matrix[0].size();       // 原始矩阵的列数
        // 初始化前缀和数组，多一行一列用于简化边界处理
        preSum.resize(m + 1, vector<int>(n + 1, 0));

        // 计算前缀和：preSum[i][j] = preSum[i-1][j] + preSum[i][j-1] - preSum[i-1][j-1] + matrix[i-1][j-1]
        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                preSum[i][j] = preSum[i - 1][j] + preSum[i][j - 1]
                               + matrix[i - 1][j - 1] - preSum[i - 1][j - 1];
            }
        }
    }

    // 计算原始矩阵中闭区间 [x1, x2] 行、[y1, y2] 列所围成的子矩阵的和
    // 注意：x1, x2, y1, y2 都是原始矩阵的有效索引（0-based）
    int Addmatrix(int x1, int x2, int y1, int y2) {
        // 利用前缀和公式：sum = preSum[x2+1][y2+1] - preSum[x1][y2+1] - preSum[x2+1][y1] + preSum[x1][y1]
        // 因为 preSum 的行/列索引比原始矩阵大 1，所以需要 +1 转换
        return preSum[x2 + 1][y2 + 1] - preSum[x1][y2 + 1]
               - preSum[x2 + 1][y1] + preSum[x1][y1];
    }
};

class Solution {
public:
    // 计算矩阵区域和：对于每个位置 (i, j)，求以该位置为中心、边长为 2k+1 的正方形区域的和
    // （边界超出矩阵时只取有效部分）
    vector<vector<int>> matrixBlockSum(vector<vector<int>>& mat, int k) {
        int m = mat.size();      // 矩阵行数
        int n = mat[0].size();   // 矩阵列数
        // 结果矩阵，大小与原始矩阵相同
        vector<vector<int>> answer(m, vector<int>(n, 0));
        // 构建原始矩阵的前缀和对象
        SumMatrix mt = SumMatrix(mat);
        // 遍历每个位置 (i, j)
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                // 计算以 (i, j) 为中心、半径为 k 的矩形区域的边界（需限制在矩阵范围内）
                int x1 = max(i - k, 0);        // 上边界（行最小索引）
                int x2 = min(i + k, m - 1);    // 下边界（行最大索引）
                int y1 = max(j - k, 0);        // 左边界（列最小索引）
                int y2 = min(j + k, n - 1);    // 右边界（列最大索引）

                // 通过前缀和快速得到该区域的和，并填入结果矩阵
                answer[i][j] = mt.Addmatrix(x1, x2, y1, y2);
            }
        }
        return answer;
    }
};

这题说白了就是：给你一个矩阵，对于每个格子 (i,j)，把它周围 k 圈范围内的所有数加起来，填回去。

暴力做法也简单，每个格子都去遍历它的 k 邻域，但那是 $O(m \cdot n \cdot k^2)$，k 一大直接炸。

关键思路就是——前缀和把遍历变成值相减。

二维前缀和的构造其实就一句话：preSum[i][j] 表示从 (0,0) 到 (i-1, j-1) 这片矩形区域的和。多开一圈 m+1 × n+1 是为了省掉边界判空。

构造公式拆开看很直观：

1
2
3
4


preSum[i][j] = preSum[i-1][j]        // 上面那块
             + preSum[i][j-1]        // 左边那块
             + matrix[i-1][j-1]      // 当前这个数
             - preSum[i-1][j-1]      // 左上角被算了两次，扣掉

画个图就是：上加左，减重叠，加自己。

查子矩阵和也一个道理。想求 (x1,y1) 到 (x2,y2) 这个矩形（闭区间，0-index）的和：

1
2
3
4


sum = preSum[x2+1][y2+1]      // 整块从原点到右下
    - preSum[x1][y2+1]        // 砍掉上面
    - preSum[x2+1][y1]        // 砍掉左边
    + preSum[x1][y1]          // 左上角被砍了两次，补回来

就是大减小，补重叠，对称得很。

最后一步，每个格子的 k 邻域怎么定界？用 max/min 把越界的部分夹住就行——左边界不能小于 0，右边界不能超过 m-1，上下同理。这样每个格子 O(1) 就能出结果，总复杂度 $O(m \cdot n)$。

一句话总结：构造一次前缀和，然后每个格子的答案就是四次查表加减。前缀和的本质就是预计算，用空间换掉内层遍历。

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 步永远追不上。

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 停在哪里
手写一遍完整代码

Q238 除自身以外数组的乘积

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

1 题目类型：前缀和

本题本质上是 前缀积 + 后缀积 问题，属于前缀和思想在乘法上的扩展。

![](Pasted image 20260605202341.png)

这也是道前缀和类型的题，准确的说，这是一道前缀乘积。

我们看题，可以得到，他想要的效果其实就是把除了自身以外的数的积求出。

假设某个数组为 [a, b, c, d, e]
要求 answer[c]，则有
answer[c] = a * b * d * e
即 前缀乘积 × 后缀乘积。

 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


class PrefixSuffixProduct
{public:
    vector<int> prefix;
    vector<int> suffix;
    PrefixSuffixProduct(vector<int>& nums)
    {
        int sz = nums.size();
        prefix.resize(sz+1,1);
        suffix.resize(sz+1,1);
        for(int i=1;i<=sz;i++)
        {
            prefix[i] = prefix[i-1] * nums[i-1];
        }
        for(int i=sz-1;i>=0;i--)
        {
            suffix[i] = suffix[i+1] * nums[i];
        }
    }
    int plus_matrix(int x1)
    {
        return prefix[x1] * suffix[x1+1];
    }
};

class Solution {
public:
    vector<int> productExceptSelf(vector<int>& nums) {
        vector<int> res;
        PrefixSuffixProduct am(nums);
        int sz = nums.size();
        res.resize(sz,1);
        for(int i = 0;i<sz;i++)
        {
           res[i] = am.plus_matrix(i);
        }
        return res;
    }
};

2 优化说明与复杂度分析

算法思想

prefix[i] 表示 nums[0] * nums[1] * ... * nums[i-1]（前 i 个元素的乘积）
suffix[i] 表示 nums[i] * nums[i+1] * ... * nums[n-1]（从 i 到末尾的乘积）
对于下标 i，答案 = prefix[i] * suffix[i+1]，即左边所有数的乘积 × 右边所有数的乘积。

时间复杂度

构建前缀/后缀数组：O(n)
计算每个位置的答案：O(n)
总复杂度：O(n)

空间复杂度

前缀/后缀数组各 O(n)，结果数组 O(n)（不计入输出时可选 O(1) 额外空间）
当前实现：O(n)

改进建议

可以只用一个输出数组，先从左到右累乘，再从右到左乘一次，将空间优化到 O(1)（不含输出数组）。

示例验证
输入：nums = [1,2,3,4]

prefix = [1, 1, 2, 6, 24]
suffix = [24, 24, 12, 4, 1]
计算结果：
- i=0 → 1 * 24 = 24
- i=1 → 1 * 12 = 12
- i=2 → 2 * 4 = 8
- i=3 → 6 * 1 = 6
  输出 [24,12,8,6]，正确。

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_ 不能实现随机访问
能画出虚拟头节点与真实头节点的关系
不看答案写出指定位置插入
说清楚插入和删除的合法下标范围为什么不同

Q525 连续数组（前缀和 + 哈希）

Fri, 17 Jul 2026 00:00:00 +0000

来源：本题是 LeetCode 525，前缀和 + 哈希表的典型应用。这篇是我从 Obsidian 笔记整理过来的第一篇博客文章。

1 一、解题核心转化

1.1 1. 数值映射（关键技巧）

0 → -1，1 → 1

子数组 0、1 数目相等 ⇨ 子数组所有元素相加 = 0
问题转化：找最长区间和 = 0 的连续子数组

1.2 2. 前缀和公式

$$preSum[r] - preSum[l] = 0 \iff preSum[r] = preSum[l]$$

若两个位置前缀和相等：区间 $[l, r-1]$ 和为 0，满足题意
区间长度：$r - l$

2 二、易错点：vector 初始化大坑（踩坑记录）

1
2
3
4


// ❌ 错误写法：{n+1,0} 是初始化列表，生成【两个元素：n+1、0】
vector<int> preSum{n+1,0};
// ✅ 正确写法：(容量,初始值)，开辟 n+1 个空间全部赋值 0
vector<int> preSum(n+1,0);

报错原因：vector 实际只有 2 个元素，循环访问 preSum[i+1] 下标越界 → heap-buffer-overflow 堆溢出

3 三、算法步骤

构造前缀和数组：$preSum[0]=0，preSum[i]=preSum[i-1]+(nums[i-1]==0?-1:1)$
哈希表 unordered_map<前缀和, 首次下标>，预先存入：map[0]=0（处理从数组开头就满足条件的子数组）
遍历前缀和：
- 前缀和未出现：存入哈希（只存第一次下标，保证最长区间）
- 前缀和已存在：计算区间长度 i - map[preSum[i]]，更新最大值

4 四、C++ 完整 AC 代码

 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


#include 
#include 
#include 
using namespace std;

class Solution {
public:
    int findMaxLength(vector<int>& nums) {
        int n = nums.size();
        vector<int> preSum(n + 1, 0); // 重点：圆括号初始化
        // 构建前缀和
        for(int i = 0; i < n; ++i){
            preSum[i+1] = preSum[i] + (nums[i]==0 ? -1 : 1);
        }
        unordered_map<int, int> mp;
        mp[0] = 0; // 初始化边界
        int res = 0;
        for(int i = 1; i <= n; ++i){
            auto it = mp.find(preSum[i]);
            if(it == mp.end()){
                mp[preSum[i]] = i; // 首次出现才保存
            }else{
                res = max(res, i - it->second);
            }
        }
        return res;
    }
};

5 五、复杂度分析

时间：$O(n)$，两次线性遍历
空间：$O(n)$，前缀和数组 + 哈希表

6 六、同类题型总结（前缀和 + 哈希通用模板）

LeetCode560 和为 K 的子数组：pre[r] - pre[l] = K
LeetCode974 和可被 K 整除子数组：同余前缀和配对

通用套路：前缀和做差转化区间条件 + 哈希存首次下标

7 七、精简优化版（不开前缀和数组，原地累加 sum 省空间）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


int findMaxLength(vector<int>& nums) {
    unordered_map<int,int> mp;
    mp[0]=-1;
    int sum=0,maxlen=0;
    for(int i=0;i<nums.size();i++){
        sum += nums[i]==1?1:-1;
        if(mp.count(sum)) maxlen=max(maxlen,i-mp[sum]);
        else mp[sum]=i;
    }
    return maxlen;
}

Q560 和为 K 的子数组

Fri, 17 Jul 2026 00:00:00 +0000

题目：给你一个整数数组 nums 和一个整数 k，请你统计并返回该数组中和为 k 的连续子数组的个数。

1 解题核心思路

1.1 1. 为什么用前缀和？

题目要求相邻子数组的和等于 K，前缀和天然适合处理区间和：

$$preSum[r] - preSum[l] = K \iff preSum[l] = preSum[r] - K$$

1.2 2. 为什么用哈希表？

要从大量子数组中快速找出满足条件的数量。暴力双 for 循环复杂度 $O(n^2)$，哈希表可以降到 $O(n)$。

哈希表的核心作用：空间换时间——当题目既要计算子数组情况，又要从子数组中快速查找满足条件的项时，哈希表是首选工具。

1.3 3. 哈希表存什么？

场景	哈希表记录
求数量（本题）	`val → count`（前缀和 → 出现次数）
求最大/最小长度	`val → index`（前缀和 → 首次下标）

2 算法步骤

遍历数组，维护当前前缀和 sum
计算 need = sum - K，在哈希表中查找 need 出现的次数，累加到结果
将当前 sum 存入哈希表（次数 +1）
关键初始化：map[0] = 1，处理从数组开头就满足条件的子数组

3 C++ 完整 AC 代码

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


#include 
#include 
using namespace std;

class Solution {
public:
    int subarraySum(vector<int>& nums, int k) {
        unordered_map<int, int> valToCount; // 前缀和 → 出现次数
        valToCount[0] = 1;                  // 边界初始化
        int sum = 0, res = 0;

        for (int num : nums) {
            sum += num;                     // 累加当前前缀和
            int need = sum - k;
            if (valToCount.find(need) != valToCount.end()) // 此处为满足需求
            {
                res += valToCount[need];
            }
            valToCount[sum]++;
        }
        return res;
    }
};

4 复杂度分析

时间复杂度：$O(n)$，一次遍历
空间复杂度：$O(n)$，哈希表最坏存 n 个不同前缀和

5 精简优化版（不开前缀和数组，一次遍历）

原代码先构造完整 preSum 数组再遍历，多了一次 $O(n)$ 的预处理。改为一边累加一边查哈希表，只扫一遍。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


int subarraySum(vector<int>& nums, int k) {
    unordered_map<int, int> mp;
    mp[0] = 1;
    int sum = 0, ans = 0;
    for (int x : nums) {
        sum += x;
        if (mp.count(sum - k)) ans += mp[sum - k];
        mp[sum]++;
    }
    return ans;
}

6 同类题型总结（前缀和 + 哈希通用套路）

题目	转化条件	哈希表记录
LeetCode 560 和为 K 的子数组	`pre[r] - pre[l] = K`	前缀和 → 出现次数
LeetCode 525 连续数组	`pre[r] = pre[l]`（0→-1, 1→1）	前缀和 → 首次下标
LeetCode 974 和可被 K 整除	同余前缀和配对	余数 → 出现次数

通用套路：前缀和做差转化区间条件 → 哈希表快速查找 → 根据题目要求决定存次数还是存下标。

7 易错提醒

valToCount[0] = 1 不能漏：当 sum == k 时，need = 0，此时应计为一种合法方案。
先查哈希表再更新：避免 k = 0 时当前前缀和自己匹配（空子数组不算）。