set类 & map类

这里先写上所有 \(STL\) 容器共有函数

复杂度都为常数

1. a.empty()

   判空，空返回 \(1\)，否则为 \(0\)。

2. a.size()

   返回元素个数。

3. swap(a,b) || a.swap(b)

   交换 \(a,b\)，要求 \(a,b\) 同一类型。

---

以下内容容器适配器没有：

1. a.begin() || a.cbegin()

   返回指向第一个元素的迭代器。

2. a.end() || a.cend()

   返回指向最后一个元素下一个的迭代器。

\(set,multiset\&unordered\_set,unordered\_multiset\)

unordered_multiset 不做详细介绍，类比 multiset 和 unordered_set 可知。

定义

1. set<T,cmp> a

   \(a\) 有序，\(T\) 为类型，\(cmp\) 是仿函数（比较函数）默认是 less<T>，\(a\) 中元素不重复。

2. multiset<T,cmp> a

   \(a\) 有序，\(T\) 为类型，\(cmp\) 是仿函数（比较函数）默认是 less<T>，\(a\) 中元素可以重复。

3. unordered_set<T,hh> a

   \(a\) 无序，\(T\) 为类型，\(hh\) 是哈希函数，默认是 hash<T>，\(a\) 中元素不重复。

初始化

这里以 set 为例，multiset 和 unordered_set 类似。

1. set<T,cmp> a{k1,k2,k3,...,kn}

   将 \(k1,k2,k3,...,kn\) 初始化入 \(a\) 中。

2. set<T,cmp> a(b)

   将 \(b\) 拷贝进 \(a\)，要求 \(a,b\) 类型一致。

3. set<T,cmp> a(bg,ed)

   将 \([bg,ed)\) 拷贝进 \(a\)，\(bg,ed\) 为迭代器。

插入

1. a.insert(x)

   插入一个值 \(x\)。

2. a.insert(bg,ed)

   插入 \([bg,ed)\) 里的所有数，\(bg,ed\) 为迭代器。

3. a.insert({x1,x2,x3,...,xn})

   插入 \(x1,x2,x3,...,xn\) 。

删除

1. a.erase(pos)

   删除 \(pos\) 位置元素，\(pos\) 为迭代器。

2. a.erase(x)

   删除所有等于 \(x\) 的数。

3. a.erase(bg,ed)

   删除 \(a\) 中在 \([bg,ed)\) 的数，\(bg,ed\) 为迭代器。

4. a.clear()

   清空 \(a\)。

查找

1. a.count(x)

   返回 \(a\) 中等于 \(x\) 的个数，在 set 中只为 \(0,1\)。

2. a.find(x)

   返回指向 \(a\) 中等于 \(x\) 的数的一个迭代器，如果没找见，返回 a.end()。

3. a.lower_bound(x)

   返回指向 \(a\) 中第一个大于 \(x\) 的数的迭代器。

4. a.upper_bound(x)

   返回指向 \(a\) 中第一个大于等于 \(x\) 的数的迭代器。

注 ：

\(3\) 和 \(4\) 都是基于二分查找的算法，所以对于 unordered_set 不适用。

如果用 algorithm 的算法，复杂度则是 \(\mathrm O(n)\) 。

复杂度

set 和 multiset 除了 a.count(x) 都是 \(\mathrm O (\log n)\)

set 的 a.count(x) 是 \(\mathrm O (\log n)\)，但 multiset 是 \(\mathrm O (\log n) + k\) 的，其中 \(k\) 是相同元素个数。

unordered_set 理论都是 \(\mathrm O (1)\)，但可能被卡成 \(\mathrm O (n)\)（因为基于哈希。

\(map,multimap\&unordered\_map,unordered\_multimap\)

unordered_multimap 不做详细介绍，类比 multimap 和 unordered_map 可知。

定义：

1. map<Tk,Tv,cmp> a

   \(a\) 有序，按键大小排序，\(Tk\) 为键类型，\(Tv\) 为值类型，\(cmp\) 是仿函数（比较函数）默认是 less<Tk>，\(a\) 中同一个键只对应一个值。

2. multimap<Tk,Tv,cmp> a

   \(a\) 有序，按键大小排序，\(Tk\) 为键类型，\(Tv\) 为值类型，\(cmp\) 是仿函数（比较函数）默认是 less<Tk>，\(a\) 中同一个键可对应多个值。

3. unordered_set<Tk,Tv,hh> a

   \(a\) 无序，\(Tk\) 为键类型，\(Tv\) 为值类型，\(hh\) 是哈希函数，默认是 hash<Tk>，\(a\) 中同一个键只对应一个值。

初始化

这里以 map 为例，multiset 和 unordered_set 类似。

1. map<Tk,Tv,cmp> a{{k1,v1},{k2,v2},{k3,v3},...,{kn,vn}}

   将 \(k1:v1,k2:v2,k3:v3,...,kn:vn\) 初始化入 \(a\) 中，\(k\) 是键，\(v\) 是值。

   等同于 map<Tk,Tv,cmp> a{make_pair(k1,v1),...,make_pair(kn,vn)}

   和 map<Tk,Tv,cmp> a{pair<Tk,Tv>{k1,v1},...,pair<Tk,Tv>{kn,vn}}

2. map<Tk,Tv,cmp> a(b)

   将 \(b\) 拷贝进 \(a\)，要求 \(a,b\) 类型一致。

3. map<Tk,Tv,cmp> a(bg,ed)

   将 \([bg,ed)\) 拷贝进 \(a\)，\(bg,ed\) 为迭代器。

查询：

multimap 没有通过键查询的操作，因为一个键对应多个值。

1. a.at(k)

   返回 \(a\) 中键 \(k\) 对应的值，如果未找到，返回异常：out_of_range。

2. a[k]

   返回 \(a\) 中键 \(k\) 对应的值，如果未找到，就添加键 \(k\)，值为 \(0\)。

插入：

1. a.insert({k,v})

   插入一对键值，分别为 \(k:v\)。

   类似初始化，也可用 make_pair() 和 pair<Tk,Tv>{}。

   如果键重复，就会插入失败，不会覆盖。

2. a.insert(bg,ed)

   插入 \([bg,ed)\) 里的所有键和值，\(bg,ed\) 为迭代器。

   如果键重复，就会插入失败，不会覆盖。

3. a.insert({{k1,v1},{k2,v2},...,{kn,vn}})

   插入 \(n\) 对键值，分别为 \(k1:v1,k2:v2,...,kn:vn\)，其中 \(ki\) 对应 \(vi\)。

   类似初始化，也可用 make_pair() 和 pair<Tk,Tv>{}。

   如果键重复，就会插入失败，不会覆盖。

4. a[k]=v

   插入一对键值，分别为 \(k:v\)。

   如果键重复，会覆盖 当前键所对应的值。

   multimap 也不支持这种插入。

删除：

1. a.erase(pos)

   删除 \(pos\) 位置元素，\(pos\) 为迭代器。

2. a.erase(k)

   删除所有键等于 \(k\) 的数。

3. a.erase(bg,ed)

   删除 \(a\) 中在 \([bg,ed)\) 的数，\(bg,ed\) 为迭代器。

4. a.clear()

   清空 \(a\)。

查找：

1. a.count(k)

   返回 \(a\) 中键等于 \(k\) 的个数，在 map 中只为 \(0,1\)。

2. a.find(k)

   返回指向 \(a\) 中键等于 \(k\) 的数的一个迭代器，如果没找见，返回 a.end()。

3. a.lower_bound(k)

   返回指向 \(a\) 中第一个键大于 \(k\) 的数的迭代器。

4. a.upper_bound(k)

   返回指向 \(a\) 中第一个键大于等于 \(k\) 的数的迭代器。

注 ：

\(3\) 和 \(4\) 都是基于二分查找的算法，所以对于 unordered_map 不适用。

如果用 algorithm 的算法，复杂度则是 \(\mathrm O(n)\) 。

复杂度

map 和 multimap 除了 a.count(x) 都是 \(\mathrm O (\log n)\)

map 的 a.count(x) 是 \(\mathrm O (\log n)\)，但 multimap 是 \(\mathrm O (\log n) + k\) 的，其中 \(k\) 是相同元素个数。

unordered_map 理论都是 \(\mathrm O (1)\)，但可能被卡成 \(\mathrm O (n)\)（因为基于哈希。