std::unordered_map 与 std::unordered_set:接口、算法技巧与权衡 (速查)

注:本文适合复习者食用,初学者慎入

目录

一、接口速查

模板参数

构造与赋值

[桶与容量(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(),容器重建桶数组:

  1. 申请更大的桶数组(新 bucket_count);
  2. 遍历所有节点,按新桶数重新计算落点;
  3. 把节点重新挂链------节点本身不搬家;
  4. 释放旧桶数组;
  5. 更新 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的缩写)

四、算法常用技巧

  1. 批量插入先 reserve(n):把 n 次潜在 rehash 降到 0 次,也避免中途迭代器失效。

  2. 只读用 find / at,别用 [] :[] 在 key 不存在时会插入默认值,循环里误用会让表越查越大;判断存在用 find(k) != end() 或 count(k)。

  3. 插入并判断结果 :auto ret = m.insert({k, v}); 的 ret.second 表示是否真的插入;insert 遇到已存在的 key 不覆盖,要覆盖写 m[k] = v。emplace(args...) 原地构造,省一次临时对象;insert 先构造 pair 再拷贝/移动。

  4. 避免二次查找 :auto it = m.find(k); if (it != m.end()) use(it->second);,别 find 完再 m[k]。

  5. 计数/去重 :unordered_map<int,int> cnt; ++cnt[x];;unordered_set<int> seen; if (!seen.insert(x).second) 重复;。

  6. 两数之和、前缀和、图邻接 :hash 表当"值 → 下标/次数"的字典,是 O(n) 解法的标准件;前缀和配 unordered_map<long long,int> 时记得 m[0] = 1。

  7. 需要顺序就别用 unordered :按 key 有序、lower_bound、范围查询 → std::map / std::set;只是"排序后输出" → 拷进 vector 排。

  8. 需要插入顺序 → 额外记一个 vector :unordered_map<K,int> pos + vector<K> order;小表干脆用 vector<pair<K,V>> 线性查。

  9. LRU 的标准组合 :list<pair<K,V>> + unordered_map<K, list::iterator>。命中后 lst.splice(lst.begin(), lst, it) 是 O(1);map 里存的是 list 迭代器,map 自己 rehash 也不影响它。

  10. 自定义 hash 要"打散" :移位 + 奇数乘子(如 0x9e3779b9),别用 x ^ y 这种对称组合;多字段可参考 boost::hash_combine。

  11. 小整数域别用哈希 :key 范围是 [0, 10^6] 时,直接 vector<int> cnt(n) 比 unordered_map 快一个量级------没有 hash,没有指针追逐。

  12. 多值优先 unordered_map<K, vector<V>> :比 unordered_multimap + equal_range 更好控(后者等价键的顺序也不保证)。

  13. 传参 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)

六、易错速答

  1. 迭代器是前向的 :it + 1、--it、it1 < it2、std::sort(m.begin(), m.end()) 全部编译不过;++it 单步最坏要跨过一串空桶(O(bucket_count)),整趟遍历是 O(n + bucket_count)。

  2. 遍历顺序不可依赖:不是插入序、不是 key 序;rehash、插入、换实现都会变。要顺序自己排序。

  3. m[k] 会插入 :只读用 find / at;at 不存在抛 out_of_range,[] 不存在默认构造。因此 operator[] 还要求 T 可默认构造,T 没有默认构造就编不过,改用 insert / emplace。另外 insert 遇到已存在的 key 不覆盖,要覆盖写 m[k] = v。

  4. key 是 const :it->first = ... 编不过,set 的迭代器连 *it 都是 const;要换 key 只能 erase 旧 key 再 insert 新 key。

  5. 自定义 key 三件套 :std::hash 特化(或传 Hash)、operator==(或传 KeyEqual)、两者一致。少一个就编不过或查不到。

  6. const char* 当 key 比的是指针 :unordered_map<const char*, int> 用 "abc" 查多半失败;std::hash<const char*> 哈希的是地址。用 std::string。

  7. std::hash 不保证稳定 :跨编译器、跨版本可能不同;不能存盘,也不能当跨进程 ID;std::hash<std::string> 也不抗碰撞攻击。

  8. rehash 失效迭代器但不失效引用/指针 :别把"引用稳定"误当成"迭代器稳定";reserve / rehash 本身也会让迭代器失效。

  9. reserve(n) 不是 resize(n) :只改桶数,不创建元素;reserve 之后 size() 仍是 0,m[0] 仍是插入。

  10. max_load_factor(z) 可能立刻 rehash:设完 z 后原有迭代器可能已失效;要在批量插入前设置,别在遍历中设置。

  11. count 对 map/set 只有 0/1 :判断存在用 count / find(k) != end(),取值用 find;只有 multi 容器的 count 才可能 > 1,且 multi 没有 operator[] / at。

  12. erase(k) 返回删除个数 :不是迭代器;erase(it) 才返回下一个迭代器,遍历删除必须用后者。

  13. clear() 不释放桶 :要真正还内存,unordered_map<K,V>().swap(m);rehash(0) 只是"请求"缩桶。

  14. swap 后迭代器归属变了 :仍有效但指向另一个容器;end() 确定失效。

  15. bucket_count() 不是 size() :空 map 也可能已有桶;判断空用 empty()。

  16. std::find 不是成员 find:前者 O(n) 线性扫,后者才用 hash。

相关推荐
上海潭龙东海科技有限公司2 小时前
智慧堆场动态模型三维实时孪生重构智能管控
大数据·网络·数据库·算法·重构
一拳一个呆瓜2 小时前
【STL】头文件:<cmath>
c++·stl
草莓熊Lotso3 小时前
【C++ 基于微服务的即时通讯系统】ElasticSearch 用户数据管理实现
linux·数据库·c++·elasticsearch·微服务·架构
慧都产品智能化3 小时前
Qt 开发 CAD/CAM 工序表的隐性成本分析
c++·qt·qt5·qt6.3
阿庆_AI研发工程师4 小时前
Stanford CS336 Lecture 10:大语言模型推理与性能优化
算法
用户7341681035484 小时前
基于MindSpore的深度残差收缩网络程序
算法
Pniubi4 小时前
力扣239.滑动窗口最大值(优先队列)
算法·leetcode·职场和发展
eggwyw5 小时前
linux下的C\C++多进程多线程编程实例详解
开发语言·c++
青少儿编程课堂6 小时前
第十八届蓝桥杯青少组图形化真题 + 全国青少年信息素养大赛 + 电子学会图形化考级:校园泡泡堂大挑战解析
c++·python·算法·bfs·信息学竞赛