C++ 关联容器(map、multimap 、set、multiset)详解
续上一篇：C++ 顺序容器(vector、list、deque、array、forward_list)详解
一、概述
关联式容器是非线性的树结构，更准确的说是二叉树结构。各元素之间没有严格的物理上的顺序关系，也就是说元素在容器中并没有保存元素置入容器时的逻辑顺序。但是关联式容器提供了另一种根据元素特点排序的功能，这样迭代器就能根据元素的特点“顺序地”获取元素。元素是有序的集合，默认在插入的时候按升序排列。关联容器包括：map（集合）、set（映射）、multimap（多重集合）、multiset（多重映射）。
1、map(需要导入头文件#include )
C++中map容器提供一个键值对（key/value）容器，map与multimap差别仅仅在于multiple允许一个键对应多个值。对于迭代器来说，可以修改实值，而不能修改key。Map会根据key自动排序。
map 是键－值对的集合。map 类型通常可理解为关联数组：可使用键作为下标来获取一个值，正如内置数组类型一样。而关联的本质在于元素的值与某个特定的键相关联，而并非通过元素在数组中的位置来获取。
1.定义与初始化
map<int,string> map1; //空map
map<k, v>m
创建一个名为m的空map对象，其键和值的类型分别为k和v
map<k, v>
m(m2)
创建m2的副本m，m与m2必须有相同的键类型和值类型
map<k, v>
m(b, e)
创建map类型的对象m，存储迭代器b和e标记的范围内所有元素的副本。元素的类型必须能转换为pair<const k, v>
在使用关联容器时，它的键不但有一个类型，而且还有一个相关的比较函数。所用的比较函数必须在键类型上定义严格弱排序（strict weak ordering）：可理解为键类型数据上的“小于”关系，虽然实际上可以选择将比较函数设计得更复杂。
对于键类型，唯一的约束就是必须支持 < 操作符，至于是否支持其他的关系或相等运算，则不作要求。
2.常用的操作方法
添加元素有两种方法：
- 先用下标操作符获取元素，然后给获取的元素赋值
- 使用insert成员函数实现
下标操作添加元素：如果该键已在容器中，则 map 的下标运算与 vector 的下标运算行为相同：返回该键所关联的值。只有在所查找的键不存在时，map 容器才为该键创建一个新的元素，并将它插入到此 map 对象中。此时，所关联的值采用值初始化：类类型的元素用默认构造函数初始化，而内置类型的元素初始化为 0。
insert 操作：
| 函数名 | 意义 |
|---|---|
| m.insert(e) | e是一个用在m上的value_type 类型的值。如果键（e.first不在m中，则插入一个值为e.second 的新元素；如果该键在m中已存在，则保持m不变。该函数返回一个pair类型对象，包含指向键为e.first的元素的map迭代器，以及一个 bool 类型的对象，表示是否插入了该元素 |
| m.insert(beg,end) | beg和end是标记元素范围的迭代器，其中的元素必须为m.value_type 类型的键－值对。对于该范围内的所有元素，如果它的键在 m 中不存在，则将该键及其关联的值插入到 m。返回 void 类型 |
| m.insert(iter,e) | e是一个用在m上的 value_type 类型的值。如果键（e.first）不在m中，则创建新元素，并以迭代器iter为起点搜索新元素存储的位置。返回一个迭代器，指向m中具有给定键的元素 |
例1：
word_count.insert(map<string, int>::value_type("Anna", 1));
word_count.insert(make_pair("Anna", 2));//返回false，且键值仍为1.
word_count[“Anna”] = 2;//键值变为2
insert的返回值：包含一个迭代器和一个bool值的pair对象，其中迭代器指向map中具有相应键的元素，
而bool值则表示是否插入了该元素。如果该键已在容器中，则其关联的值保持不变，返回的bool值为false。
在这两种情况下，迭代器都将指向具有给定键的元素。
例2：
pair<map<string, int>::iterator, bool> ret =
word_count.insert(make_pair(word, 1));
ret存储insert函数返回的pair对象。该pair的first成员是一个map迭代器，指向插入的键。
ret.first从insert返回的pair对象中获取 map 迭代器；ret.second从insert返回是否插入了该元素。
例3：
map1[3] = "Saniya"; //添加元素
map1.insert(map<int,string>::value_type(2,"Diyabi"));//插入元素
map1.insert(pair<int,string>(1,"Siqinsini"));
map1.insert(make_pair<int,string>(4,"V5"));
string str = map1[3]; //根据key取得value，key不能修改
map<int,string>::iterator iter_map = map1.begin();//取得迭代器首地址
int key = iter_map->first; //取得key
string value = iter_map->second; //取得value
map1.erase(iter_map); //删除迭代器数据
map1.erase(3); //根据key删除value
map1.size(); //元素个数
map1.empty(); //判断空
map1.clear(); //清空所有元素
3. 遍历
map中使用下标存在一个很危险的副作用：如果该键不在 map 容器中，那么下标操作会插入一个具有该键的新元素。所以map 容器提供了两个操作：count 和 find，用于检查某个键是否存在而不会插入该键。
| 函数名 | 意义 |
|---|---|
| m.count(k) | 返回 m 中 k 的出现次数 |
| m.find(k) | 如果m容器中存在按k索引的元素，则返回指向该元素的迭代器。如果不存在，则返回超出末端迭代器。 |
例1：
int occurs = 0;
if (word_count.count("foobar"))occurs = word_count["foobar"];
map<string,int>::iterator it = word_count.find("foobar");
if (it != word_count.end())occurs = it->second;
例2：
for(map<int,string>::iterator iter = map1.begin();iter!=map1.end();iter++)
{
int keyk = iter->first;
string valuev = iter->second;
}
4. 从map对象中删除元素
| 函数名 | 意义 |
|---|---|
| m.erase(k) | 删除m中键为k的元素。返回size_type类型的值，表示删除的元素个数 |
| m.erase§ | 从m中删除迭代器p所指向的元素。p必须指向m中确实存在的元素，而且不能等于m.end()。返回void |
| m.erase(b,e) | 从m中删除一段范围内的元素，该范围由迭代器对b和e标记。b和e必须标记m中的一段有效范围：即b和e都必须指向m中的元素或最后一个元素的下一个位置。而且，b和e要么相等（此时删除的范围为空），要么b所指向的元素必须出在e所 |
指向的元素之前。返回 void 类型
string removal_word = "a";
if (word_count.erase(removal_word))
cout << "ok: " << removal_word << " removed\n";
else cout << "oops: " << removal_word << " not found!\n";
2、set(需要导入头文件#include )
set的含义是集合，它是一个有序的容器，里面的元素都是排序好的，支持插入，删除，查找等操作，就像一个集合一样。所有的操作的都是严格在logn时间之内完成，效率非常高。set和multiset的区别是：set插入的元素不能相同，但是multiset可以相同。Set默认自动排序。使用方法类似list。
1. set容器的定义和使用
set 容器的每个键都只能对应一个元素。以一段范围的元素初始化set对象，或在set对象中插入一组元素时，对于每个键，事实上都只添加了一个元素。
vector<int> ivec;
for (vector<int>::size_type i = 0; i != 10; ++i) {
ivec.push_back(i);
ivec.push_back(i);
}
set<int> iset(ivec.begin(), ivec.end());
cout << ivec.size() << endl; //20个
cout << iset.size() << endl; // 10个
2. 在set中添加元素
set<string> set1;
set1.insert("the"); //第一种方法：直接添加
set<int> iset2;
iset2.insert(ivec.begin(), ivec.end());//第二中方法：通过指针迭代器
3. 从set中获取元素
set 容器不提供下标操作符。为了通过键从 set 中获取元素，可使用 find运算。
如果只需简单地判断某个元素是否存在，同样可以使用 count 运算，返回 set 中该键对应的元素个数。
当然，对于 set 容器，count 的返回值只能是1（该元素存在）或 0（该元素不存在）。
set<int> iset;
for(int i = 0; i<10; i++)iset.insert(i);
iset.find(1) // 返回指向元素内容为1的指针
iset.find(11) // 返回指针iset.end()
iset.count(1) // 存在，返回1
iset.count(11) // 不存在，返回0
set<int>::iterator it=iset.begin()
*it就是当前迭代器指向的值
set默认是从小到大排列值，定义时set
4. 迭代器的关联容器操作
| 函数名 | 意义 |
|---|---|
| m.lower_bound(k) | 返回一个迭代器，指向键不小于 k 的第一个元素 |
| m.upper_bound(k) | 返回一个迭代器，指向键大于 k 的第一个元素 |
| m.equal_range(k) | 返回一个迭代器的 pair 对象。它的 first 成员等价于 m.lower_bound(k)。而 second 成员则等价于 m.upper_bound(k) |
二、各种容器的元素在内存中的储存方式
1、vector（向量）：
相当于数组，但其大小可以不预先指定，并且自动扩展。它可以像数组一样被操作，由于它的特性我们完全可以将vector 看作动态数组。在创建一个vector 后，它会自动在内存中分配一块连续的内存空间进行数据存储，初始的空间大小可以预先指定也可以由vector 默认指定，这个大小即capacity （）函数
的返回值。当存储的数据超过分配的空间时vector 会重新分配一块内存块，但这样的分配是很耗时的，效率非常低。
2、deque（队列）：
它不像vector 把所有的对象保存在一块连续的内存块，而是采用多个连续的存储块，并且在一个映射结构中保存对这些块及其顺序的跟踪。向deque 两端添加或删除元素的开销很小，它不需要重新分配空间。
3、list（列表）：
是一个线性链表结构，它的数据由若干个节点构成，每一个节点都包括一个信息块（即实际存储的数据）、一个前驱指针和一个后驱指针。它无需分配指定的内存大小且可以任意伸缩，这是因为它存储在非连续的内存空间中，并且由指针将有序的元素链接起来。
4、set, multiset, map, multimap
是一种非线性的树结构，具体的说采用的是一种比较高效的特殊的
平衡检索二叉树—— 红黑树结构。
三、各种容器优劣分析
1. 顺序容器
1、Vector：
优点：
A、支持随机访问，访问效率高和方便，它像数组一样被访问，即支持[ ] 操作符和vector.at()。
B、节省空间，因为它是连续存储，在存储数据的区域都是没有被浪费的，但是要明确一点vector 大多情况下并不是满存的，在未存储的区域实际是浪费的。
缺点：
A、在内部进行插入、删除操作效率非常低。
B、只能在vector 的最后进行push 和pop ，不能在vector 的头进行push 和pop 。
C、 当动态添加的数据超过vector 默认分配的大小时要进行内存的重新分配、拷贝与释放，这个操作非常消耗能。
2、List：
优点：
不使用连续的内存空间这样可以随意地进行动态操作，插入、删除操作效率高；
缺点：
A、不能进行内部的随机访问，即不支持[ ] 操作符和vector.at()，访问效率低。
B、相对于verctor 占用更多的内存。
3、Deque：
优点：
A、支持随机访问，方便，即支持[ ] 操作符和vector.at() ，但性能没有vector 好；
B、可以在两端进行push 、pop 。
缺点：
在内部进行插入、删除操作效率低。
综合：
vector 的查询性能最好，并且在末端增加数据也很好，除非它重新申请内存段；适合高效地随机存储。
list 是一个链表，任何一个元素都可以是不连续的，但它都有两个指向上一元素和下一元素的指针。所以它对插入、删除元素性能是最好的，而查询性能非常差；适合 大量地插入和删除操作而不关心随机存取的需求。
deque 是介于两者之间，它兼顾了数组和链表的优点，它是分块的链表和多个数组的联合。所以它有被list 好的查询性能，有被vector 好的插入、删除性能。 如果你需要随即存取又关心两端数据的插入和删除，那么deque 是最佳之选。
2. 关联容器
3、关联容器的特点是明显的，相对于顺序容器，有以下几个主要特点：
A， 其内部实现是采用非线性的二叉树结构，具体的说是红黑树的结构原理实现的；
B， set 和map 保证了元素的唯一性，mulset 和mulmap 扩展了这一属性，可以允许元素不唯一；
C， 元素是有序的集合，默认在插入的时候按升序排列。
基于以上特点，
A， 关联容器对元素的插入和删除操作比vector 要快，因为vector 是顺序存储，而关联容器是链式存储；比list 要慢，是因为即使它们同是链式结构，但list 是线性的，而关联容器是二叉树结构，其改变一个元素涉及到其它元素的变动比list 要多，并且它是排序的，每次插入和删除都需要对元素重新排序；
B， 关联容器对元素的检索操作比vector 慢，但是比list 要快很多。vector 是顺序的连续存储，当然是比不上的，但相对链式的list 要快很多是因为list 是逐个搜索，它搜索的时间是跟容器的大小成正比，而关联容器 查找的复杂度基本是Log(N) ，比如如果有1000 个记录，最多查找10 次，1,000,000 个记录，最多查找20 次。容器越大，关联容器相对list 的优越性就越能体现；
C， 在使用上set 区别于vector,deque,list 的最大特点就是set 是内部排序的，这在查询上虽然逊色于vector ，但是却大大的强于list 。
D， 在使用上map 的功能是不可取代的，它保存了“键- 值”关系的数据，而这种键值关系采用了类数组的方式。数组是用数字类型的下标来索引元素的位置，而map 是用字符型关键字来索引元素的位置。在使用上map 也提供了一种类数组操作的方式，即它可以通过下标来检索数据，这是其他容器做不到的，当然也包括set 。（STL 中只有vector 和map 可以通过类数组的方式操作元素，即如同ele[1] 方式）。
四、关于容器的sizeof、size()、capacity问题
vector<int> ivec;
cout<<sizeof(ivec)<<endl; // 12
cout<<ivec.size()<<endl; // 0
cout<<ivec.capacity()<<endl; // 0
for(int i=0;i<10;i++)
ivec.push_back(1);
cout<<sizeof(ivec)<<endl; // 12
Cout<<ivec.size()<<endl; // 10
cout<<ivec.capacity()<<endl; // 16
这是container的实现问题，container肯定有些数据成员什么的，这可以是auto_ptr或者是普通的ptr指向一块内存区域，或者还有可能（应该）包括这个内存区域的长度，现在已经用的长度。sizeof操作符统计的只是数据成员的长度，不会与堆里面的数据长度有关，所以会出现你看到的结果。即作sizeof操作的大小是相同的。而vector::size()操作，才反映了具体数据长度。Capacity求的是容器（vector）的容量。
五、其它
1、STL中hashtable,hashset,hashmap,set,map,unordered_map、unordered_set的区别
- hashtable,hashset,hashmap,unordered_map、unordered_set与set,map的根本区别在于底层的实现不同，前者底层都是由hashtable来提供的，后者都是由红黑树来提供；前者查询时间虽然是O（1），但是并不是前者查询时间一定比后者短，因为实际情况中还要考虑到数据量，而且前者的hash函数的构造速度也没那么快，所以不能一概而论，应该具体情况具体分析。后者保证了一个稳定的动态操作时间，查询、插入、删除都是O（logN），最坏和平均都是。
- unordered_map、unordered_set在C++11的时候被引入标准库了，而hashset,hashmap没有，所以建议还是使用unordered_map比较好。
- hashset与set相比较，它里面的元素不一定是经过排序的，而是按照所用的hash函数分派的，它能提供更快的搜索速度（当然跟hash函数有关）。（hashmap与map区别一样）