注:本文适合复习者食用,初学者慎入
目录
[桶与容量(unordered 独有)](#桶与容量(unordered 独有))
[1. hash 与 equal 必须配套](#1. hash 与 equal 必须配套)
[2. rehash 做了什么](#2. rehash 做了什么)
[3. 负载因子:时间与空间的旋钮](#3. 负载因子:时间与空间的旋钮)
[4. 推论:遍历顺序不可依赖,也别持久化](#4. 推论:遍历顺序不可依赖,也别持久化)
[三、迭代器失效:unordered 最弱的一环](#三、迭代器失效:unordered 最弱的一环)
[1. 四种"字典"怎么选](#1. 四种"字典"怎么选)
[2. 平均 O(1) 的真相](#2. 平均 O(1) 的真相)
[3. 负载因子怎么调](#3. 负载因子怎么调)
[4. 实现差异与开放寻址](#4. 实现差异与开放寻址)
[5. hash flooding 与 hash 稳定性](#5. hash flooding 与 hash 稳定性)
[6. unordered_set vs unordered_map](#6. unordered_set vs unordered_map)
定位 :散列表。一个桶数组(
bucket_count()个桶)+ 每个元素一个独立节点,节点按hash(key) % bucket_count()挂进对应的桶------链地址法。标准只承诺复杂度,不规定结构;主流实现都是链地址,但桶数规则不同。
两个恒等式 :load_factor() == size() / bucket_count();bucket(key) == hash(key) % bucket_count()(取模只是示意,实现可以用掩码或乘法散列)。
一条不变量 :每次插入完成后,size() <= bucket_count() * max_load_factor()。
一条主线 :unordered 容器用"散列"把比较换成寻址,换来平均 O(1) ,代价是永久放弃顺序 ------没有有意义的lower_bound、不能sort、遍历顺序不可依赖。而"桶数组会 rehash"决定了它最特别的一组规则:迭代器失效、引用与指针稳定。
它是 list 的极端版:节点分散、插删 O(1)、引用稳定;但迭代器比 list 更弱------只是前向,顺序还是随机的。
两者只差一层:`unordered_set` 的 `value_type` 就是 `Key`,`unordered_map` 是 `pair<const Key, T>`;桶、散列、rehash、迭代器失效规则完全同构。下文除特别说明,`m` 同时代表两者
一句话:unordered 容器用顺序换平均 O(1);节点稳、桶动则迭代器灭。
一、接口速查
模板参数
template<class Key, class T,
class Hash = std::hash<Key>,
class KeyEqual = std::equal_to<Key>,
class Alloc = std::allocator<std::pair<const Key, T>>>
class unordered_map;
template<class Key,
class Hash = std::hash<Key>,
class KeyEqual = std::equal_to<Key>,
class Alloc = std::allocator<Key>>
class unordered_set;
unordered_multimap / unordered_multiset 允许重复 key,接口同构。map 的 value_type 是 pair<const Key, T>,set 的 value_type 就是 Key。
构造与赋值
| 写法 | 结果 |
|---|---|
unordered_map<K,V> m; |
空表(可能已经分配了若干空桶) |
m{``{k1,v1},{k2,v2}} |
初始化列表;重复 key 保留第一个 |
m(first, last) |
迭代器区间 |
m(src) / m = src |
深拷贝 O(n) |
m(std::move(src)) |
O(1) 窃取桶数组与节点 |
桶与容量(unordered 独有)
| 接口 | 语义 |
|---|---|
size() / empty() / max_size() |
元素数 / 是否为空 / 理论上限 |
bucket_count() |
桶数组长度,不是元素数 |
bucket(key) |
key 落在第几个桶,O(1) |
bucket_size(n) |
第 n 个桶的元素数,O(该桶大小);n 必须 < bucket_count() |
load_factor() |
size()/bucket_count(),即平均链长 |
max_load_factor() |
负载因子上限;set(z) 时若 z 小于当前 load factor 会立刻 rehash |
rehash(n) |
桶数设为 ≥ max(n, ceil(size()/max_load_factor()));迭代器全失效 |
reserve(n) |
预留"装 n 个元素不 rehash"的桶数;批量插入前先调它 |
begin(n) / end(n) |
第 n 个桶的局部迭代器(local_iterator) |
查找
| 接口 | 说明 |
|---|---|
find(k) |
平均 O(1);失败返回 end() |
count(k) |
map/set 返回 0 或 1;multi 返回个数;判断存在常用它 |
equal_range(k) |
匹配区间;multi 常用 |
at(k) |
仅 map;不存在抛 std::out_of_range |
m[k] |
仅 map;不存在则默认构造并插入 |
hash_function() / key_eq() |
取出散列函数 / 相等谓词 |
std::find(m.begin(), m.end(), k) 是 O(n) 线性扫描------它只认 operator==,不会用你的 hash。成员 find 才是 O(1)。
修改
| 接口 | 复杂度 | 返回值 / 说明 |
|---|---|---|
insert(v) / emplace(args...) |
O(1)† | pair<iterator,bool> |
erase(it) |
O(1)† | 指向下一个元素的迭代器 |
erase(k) |
O(1)† | 删除个数(map/set 为 0/1) |
erase(first, last) |
O(n) | 指向 last 的迭代器 |
clear() |
O(n) | void;桶数不变 |
swap(other) |
O(1) | void;只换桶数组、size 与函数对象 |
† 平均;最坏 O(n)。
迭代器
| 项 | unordered | 对比 vector |
|---|---|---|
| 类别 | 前向(forward) | 随机访问 |
| 支持 | ++、*、->、== |
还有 -- + - [] < |
--it |
不支持 | 支持 |
std::distance |
O(n) | O(1) |
| 遍历顺序 | 未指定,rehash 后可能全变 | 下标序 |
| 局部遍历 | begin(n) / end(n) |
无 |
标准只要求 forward:libstdc++ 的节点只有 next,没有 prev;MSVC 内部用一条双向链表装所有元素,但对外仍只暴露 forward 迭代器。所以"省一个指针"和"顺序不可用"是同一个设计的两面。
二、底层机制:散列、桶、负载因子
1. hash 与 equal 必须配套
标准要求:k1 == k2 ⇒ hash(k1) == hash(k2);反过来不要求------不同 key 落进同一个桶叫冲突 ,靠 KeyEqual 在桶内再比一次。
struct Point { int x, y; };
bool operator==(const Point& a, const Point& b) {
return a.x == b.x && a.y == b.y;
}
struct PointHash {
size_t operator()(const Point& p) const noexcept {
size_t h1 = std::hash<int>{}(p.x);
size_t h2 = std::hash<int>{}(p.y);
return h1 ^ (h2 + 0x9e3779b9 + (h1 << 6) + (h1 >> 2));
}
};
std::unordered_map<Point, int, PointHash> mp; // 顺序:Key, T, Hash, KeyEqual
- 不传
Hash就必须有std::hash<Key>特化;不传KeyEqual就必须有operator==。 - 标准库没有
std::hash<std::pair>/std::hash<std::tuple>/std::hash<std::vector>。组合键要么自己写 hash,要么编码成long long/string。 h1 ^ h2这种对称组合会让(1,2)与(2,1)同 hash,冲突成片;用移位 + 奇数乘子打散。
2. rehash 做了什么
插入时若 size() + 1 > max_load_factor() * bucket_count(),容器重建桶数组:
- 申请更大的桶数组(新
bucket_count); - 遍历所有节点,按新桶数重新计算落点;
- 把节点重新挂链------节点本身不搬家;
- 释放旧桶数组;
- 更新
bucket_count。
第 3 步是"引用/指针不失效"的根源:元素还是那批节点,变的只是桶数组和链指针。但迭代器记录的是"当前桶 + 桶内位置",桶数组一换就全废。
记忆:节点不动 → 引用稳;桶一动 → 迭代器全灭。
3. 负载因子:时间与空间的旋钮
load_factor = size / bucket_count,即平均每桶元素数,也是平均链长。max_load_factor主流实现默认 1.0。调小 → 桶多、冲突少、内存大;调大 → 省内存、链变长、查找变慢。reserve(n)按n / max_load_factor预留桶,批量插入前先 reserve 是性价比最高的优化:既避免多次 rehash,也避免"插到一半迭代器全废"。- 读多写少、key 分布不均时,可把
max_load_factor调到 0.7 左右;只在明确要省内存时才往 2.0 调。 rehash(0)可以请求 缩桶,但标准只保证桶数 ≥size()/mlf,实现可以留着不缩;clear()同样不还桶。
4. 推论:遍历顺序不可依赖,也别持久化
标准明确:迭代顺序 unspecified。rehash 会改变顺序,插入也可能改变(新节点常插在桶头)。所以:
- 不能假设"按插入顺序"或"按 key 升序";
- 同一份数据在 libstdc++ 与 MSVC 上顺序不同;
- 需要稳定输出 → 拷进
vector排序,或直接用std::map。
三、迭代器失效:unordered 最弱的一环
| 操作 | 迭代器 | 引用/指针 |
|---|---|---|
insert / emplace / operator[](map),未 rehash |
不失效(顺序可能变) | 不失效 |
| 同上,触发 rehash | 全部失效 | 不失效 |
erase(it) / erase(k) |
只失效被删元素 | 只失效被删元素 |
erase(first, last) |
失效被删区间 | 同上 |
clear() |
全部失效 | 全部失效 |
operator= |
全部失效 | 全部失效 |
rehash / reserve |
全部失效 | 不失效 |
swap |
仍有效,但归属换成另一个容器;end() 失效 |
不失效 |
对照三兄弟:
| vector | list | unordered | |
|---|---|---|---|
| 插删是否搬家 | 扩容搬全部 | 只改指针 | 只改链指针 |
| 迭代器强弱 | 随机访问,扩容全灭 | 双向,只灭被删 | 前向,rehash 全灭 |
| 引用稳定性 | 扩容全灭 | 稳定 | 稳定(除被删) |
| 顺序 | 下标序 | 链表序 | 无顺序 |
遍历中删除的唯一正确写法:
for (auto it = m.begin(); it != m.end(); )
if (cond) it = m.erase(it); // 接返回值,别 ++it
else ++it;
key 是 const :it->first 不能改,set 的 *it 也是 const;要换 key 只能 erase 旧 key 再 insert 新 key(节点会重新分配)。(这里的cond是条件condition的缩写)
四、算法常用技巧
-
批量插入先
reserve(n):把 n 次潜在 rehash 降到 0 次,也避免中途迭代器失效。 -
只读用
find/at,别用[]:[]在 key 不存在时会插入默认值,循环里误用会让表越查越大;判断存在用find(k) != end()或count(k)。 -
插入并判断结果 :
auto ret = m.insert({k, v});的ret.second表示是否真的插入;insert遇到已存在的 key 不覆盖,要覆盖写m[k] = v。emplace(args...)原地构造,省一次临时对象;insert先构造pair再拷贝/移动。 -
避免二次查找 :
auto it = m.find(k); if (it != m.end()) use(it->second);,别find完再m[k]。 -
计数/去重 :
unordered_map<int,int> cnt; ++cnt[x];;unordered_set<int> seen; if (!seen.insert(x).second) 重复;。 -
两数之和、前缀和、图邻接 :hash 表当"值 → 下标/次数"的字典,是 O(n) 解法的标准件;前缀和配
unordered_map<long long,int>时记得m[0] = 1。 -
需要顺序就别用 unordered :按 key 有序、
lower_bound、范围查询 →std::map/std::set;只是"排序后输出" → 拷进vector排。 -
需要插入顺序 → 额外记一个 vector :
unordered_map<K,int> pos+vector<K> order;小表干脆用vector<pair<K,V>>线性查。 -
LRU 的标准组合 :
list<pair<K,V>>+unordered_map<K, list::iterator>。命中后lst.splice(lst.begin(), lst, it)是 O(1);map 里存的是 list 迭代器,map 自己 rehash 也不影响它。 -
自定义 hash 要"打散" :移位 + 奇数乘子(如
0x9e3779b9),别用x ^ y这种对称组合;多字段可参考boost::hash_combine。 -
小整数域别用哈希 :key 范围是
[0, 10^6]时,直接vector<int> cnt(n)比unordered_map快一个量级------没有 hash,没有指针追逐。 -
多值优先
unordered_map<K, vector<V>>:比unordered_multimap+equal_range更好控(后者等价键的顺序也不保证)。 -
传参
const unordered_map<K,V>&,返回靠移动;大对象装unique_ptr。
五、权衡利弊
1. 四种"字典"怎么选
| 点查 | 有序 / 范围 | 迭代器 | 内存 | 适用 | |
|---|---|---|---|---|---|
unordered_map |
平均 O(1) | ❌ | forward,rehash 全灭 | 大 | 只点查、计数 |
map |
O(log n) | ✅ | 双向,稳定 | 中大 | 要顺序 / 范围 |
vector<pair> 线性 |
O(n) | ❌ | 随机访问 | 最小 | n 小(几十以内) |
排序 vector + 二分 |
O(log n) | ✅ | 随机访问 | 最小 | 静态数据、一次建表多次查 |
n 很小时(几十以内)vector 线性扫描常常最快:连续内存、零分配、无 hash 计算。n 大且只做点查 → unordered;要顺序、范围、稳定遍历 → map;数据静态且 key 可排序 → 排序 vector + 二分。
2. 平均 O(1) 的真相
- "平均"建立在均匀散列上;hash 差或恶意构造,退化成一条 O(n) 的链。
- 常数不小:一次查找 = 算 hash + 取模/掩码 + 读桶指针 + 追节点链,至少 2~3 次 cache miss;小表上未必赢过 vector 的顺序扫描。
- 每个元素独立
new:节点至少带一个 next 指针,libstdc++ 还会按需缓存 hash 值,再叠加分配器块头;负载因子 1.0 时桶数组本身又是 8 字节/桶。内存通常不低于map,小元素时二者接近,别把它当省内存容器。
3. 负载因子怎么调
max_load_factor |
桶数 | 冲突 | 内存 | 场景 |
|---|---|---|---|---|
| 0.5 ~ 0.7 | 多 | 少 | 大 | 读多写少、延迟敏感 |
| 1.0(默认) | 中 | 中 | 中 | 通用 |
| 2.0+ | 少 | 多 | 小 | 内存受限、能接受链变长 |
调参要在批量插入前 做完:m.max_load_factor(0.7); m.reserve(n);。遍历过程中改 max_load_factor 可能立刻触发 rehash,迭代器当场失效。
4. 实现差异与开放寻址
| libstdc++(GCC) | MSVC | |
|---|---|---|
| 桶数 | 质数序列 | 2 的幂(掩码取桶) |
| 桶内结构 | 全局一条单链表,桶数组指向各桶段的前驱 | 全局一条 std::list,桶数组另存各桶的边界迭代器 |
| 扩容 | 约 2 倍,取下一个质数 | 约 2 倍 |
| 迭代顺序 | 由质数桶 + 头插决定 | 由 2 的幂 + 分段顺序决定 |
默认 max_load_factor |
1.0 | 1.0 |
质数桶让"取模"对烂 hash 更宽容;2 的幂用掩码换速度,但要求 hash 本身混合得好。标准只要求"平均 O(1)",不规定桶数、不规定链地址还是开放寻址,因此 bucket_count() 的具体值、遍历顺序、rehash 时机都不可移植。想要可复现的顺序,自己排序。
主流标准库都是链地址;absl::flat_hash_map、boost::unordered_flat_map、folly::F14 用开放寻址把桶与元素放进连续内存,点查常快 2~3 倍。代价是 rehash 时引用也不再稳定,删除要留 tombstone。标准容器给的是接口与复杂度承诺,不是性能上限;性能敏感时可以换,但别把替代品的语义套回标准容器。
5. hash flooding 与 hash 稳定性
std::hash<std::string> 在实践中是确定性的(同一实现、同一版本内稳定),攻击者可以构造大量同桶 key,把 O(1) 打成 O(n²)。不可信输入(HTTP 参数、用户 ID)当 key 时:限制数量、换带随机种子的 keyed hash,或退回 std::map。
另外,std::hash 不保证跨实现、跨版本稳定------不能把 hash 值存盘,也不能拿它当跨进程 ID。
6. unordered_set vs unordered_map
- 只需要"在不在" →
unordered_set,省掉 value 与pair包装。 - 需要"key → 附加信息" →
unordered_map;只查存在性时用 set 更省。 - 需要计数 →
unordered_map<K,int>通常比unordered_multiset直观。 - key 是
[0, N)的小整数 → 直接数组 / bitset,别用哈希。
| 需求 | unordered_map |
unordered_set |
|---|---|---|
| 插入 | insert({k,v}) / emplace(k,v) |
insert(k) |
| 取值 | m[k] / at(k) |
无(解引用 find(k)) |
| 判断存在 | count(k) / find(k) != end() |
count(k) / find(k) != end() |
| 删除 | erase(k) |
erase(k) |
六、易错速答
-
迭代器是前向的 :
it + 1、--it、it1 < it2、std::sort(m.begin(), m.end())全部编译不过;++it单步最坏要跨过一串空桶(O(bucket_count)),整趟遍历是 O(n + bucket_count)。 -
遍历顺序不可依赖:不是插入序、不是 key 序;rehash、插入、换实现都会变。要顺序自己排序。
-
m[k]会插入 :只读用find/at;at不存在抛out_of_range,[]不存在默认构造。因此operator[]还要求T可默认构造,T没有默认构造就编不过,改用insert/emplace。另外insert遇到已存在的 key 不覆盖,要覆盖写m[k] = v。 -
key 是 const :
it->first = ...编不过,set的迭代器连*it都是 const;要换 key 只能erase旧 key 再insert新 key。 -
自定义 key 三件套 :
std::hash特化(或传 Hash)、operator==(或传 KeyEqual)、两者一致。少一个就编不过或查不到。 -
const char*当 key 比的是指针 :unordered_map<const char*, int>用"abc"查多半失败;std::hash<const char*>哈希的是地址。用std::string。 -
std::hash不保证稳定 :跨编译器、跨版本可能不同;不能存盘,也不能当跨进程 ID;std::hash<std::string>也不抗碰撞攻击。 -
rehash 失效迭代器但不失效引用/指针 :别把"引用稳定"误当成"迭代器稳定";
reserve/rehash本身也会让迭代器失效。 -
reserve(n)不是resize(n):只改桶数,不创建元素;reserve之后size()仍是 0,m[0]仍是插入。 -
max_load_factor(z)可能立刻 rehash:设完 z 后原有迭代器可能已失效;要在批量插入前设置,别在遍历中设置。 -
count对 map/set 只有 0/1 :判断存在用count/find(k) != end(),取值用find;只有 multi 容器的count才可能 > 1,且 multi 没有operator[]/at。 -
erase(k)返回删除个数 :不是迭代器;erase(it)才返回下一个迭代器,遍历删除必须用后者。 -
clear()不释放桶 :要真正还内存,unordered_map<K,V>().swap(m);rehash(0)只是"请求"缩桶。 -
swap后迭代器归属变了 :仍有效但指向另一个容器;end()确定失效。 -
bucket_count()不是size():空 map 也可能已有桶;判断空用empty()。 -
std::find不是成员find:前者 O(n) 线性扫,后者才用 hash。