哈希表 - 标签 - 豆浆小屋

哈希表知识点

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

哈希表 (Hash Table)

1 核心思想

哈希表通过哈希函数将键映射到桶中，实现 $O(1)$ 平均时间复杂度的插入、删除和查找。

本质：用空间换时间，将遍历查找的 $O(n)$ 降为 $O(1)$。

2 常见使用场景

2.1 1. 两数之和 / 存在性判断

1
2
3
4
5
6


// 经典：是否存在两数和为 target
unordered_set<int> seen;
for (int x : nums) {
    if (seen.count(target - x)) return true;
    seen.insert(x);
}

2.2 2. 计数 / 频率统计

1
2


unordered_map<int, int> freq;
for (int x : nums) freq[x]++;

2.3 3. 下标映射 / 最近出现位置

1
2
3
4
5
6
7


unordered_map<int, int> pos;  // 值 → 最后一次出现的下标
for (int i = 0; i < n; i++) {
    if (pos.count(nums[i])) {
        // 之前出现过
    }
    pos[nums[i]] = i;
}

2.4 4. 字符/模式映射（同构问题）

1
2
3
4
5
6
7
8
9


// 双射：两个方向都要映射
unordered_map<char, char> s2t, t2s;
for (int i = 0; i < s.size(); i++) {
    char a = s[i], b = t[i];
    if ((s2t.count(a) && s2t[a] != b) || (t2s.count(b) && t2s[b] != a))
        return false;
    s2t[a] = b;
    t2s[b] = a;
}

3 处理哈希冲突

3.1 开放定址法（推荐）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


// 拉链法替代方案，缓存友好
const int N = 20007;  // 质数，开 2~3 倍
int h[N], nil = 0x3f3f3f3f;

int find(int x) {
    int k = (x % N + N) % N;
    while (h[k] != nil && h[k] != x) {
        if (++k == N) k = 0;
    }
    return k;
}

3.2 字符串哈希（Rabin-Karp 思想）

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


// 滚动哈希：用于字符串匹配 / 最长重复子串
typedef unsigned long long ull;
const ull P = 131;  // 基数，131 或 13331

vector<ull> h(n + 1), p(n + 1);
p[0] = 1;
for (int i = 0; i < n; i++) {
    h[i+1] = h[i] * P + s[i];
    p[i+1] = p[i] * P;
}
// 子串 [l, r] 的哈希值
ull hash = h[r+1] - h[l] * p[r - l + 1];

4 C++ 常用操作速查

 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


// --- unordered_map ---
unordered_map<int, int> mp;
mp.count(key);        // 是否存在（0 或 1）
mp[key] = val;        // 插入/修改
mp.erase(key);        // 删除
mp.find(key);         // 返回迭代器，不存在返回 mp.end()
for (auto& [k, v] : mp) { }  // 遍历

// --- unordered_set ---
unordered_set<int> st;
st.insert(x);
st.erase(x);
st.count(x);

// 自定义哈希（pair 等）
struct pair_hash {
    template<class T1, class T2>
    size_t operator()(const pair<T1, T2>& p) const {
        return hash<T1>{}(p.first) ^ (hash<T2>{}(p.second) << 1);
    }
};
unordered_map<pair<int,int>, int, pair_hash> mp;

// 用数组替代哈希表（值域小时更快）
int cnt[100001] = {0};  // 省去哈希开销

5 经典题目

题目	关键点	笔记
1. 两数之和	哈希表入门，边遍历边查	—
3. 无重复字符的最长子串	滑动窗口 + 哈希表存位置	—
49. 字母异位词分组	排序后字符串作 key	—
128. 最长连续序列	只从序列起点开始计数	—
146. LRU 缓存	哈希表 + 双向链表	—
205. 同构字符串	双射映射	—
347. 前 K 个高频元素	频率统计 + 堆/桶排序	—
454. 四数相加 II	分组 + 哈希表，$O(n^2)$	—
560. 和为 K 的子数组	前缀和 + 哈希表	题解
705. 设计哈希集合	手写哈希表实现	—
525. 连续数组	0→-1 转化 + 哈希表	题解
1124. 表现良好的最长时间段	前缀和 + 哈希表	—

6 注意事项

哈希表 vs 数组：值域小（< 10^6）时优先用数组，常数小且无冲突
unordered_map vs map：不需要有序时用 unordered_map，$O(1)$ vs $O(\log n)$
key 不存在时 mp[key] 会插入默认值，判断存在用 count() 或 find()
避免哈希退化：unordered_map 最坏 $O(n)$，竞赛中可能被卡，可自定义哈希函数
两数之和类问题，先查再插，避免自己和自己配对
双射问题（同构、单词模式），必须同时维护两个方向的映射

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 时当前前缀和自己匹配（空子数组不算）。