目录
一、关联式容器
在C++STL中实际上存在结构的容器，分别为序列式容器和关联式容器。
- 序列式容器：仅仅只是单纯的进行数据存储，数据与数据之间没有任何关联。如：vector、list、stack等等
- 关联式容器：不仅仅是存储数据，数据和数据之间的关联性很强，因为其底层实际上存的是<Key,Value>结构的键值对，所以数据检索的效率要比序列式容器要高。
而STL中关联式容器有两种结构：树形结构和哈希结构 。
树形结构：底层就是红黑树结构，如set/map/multi_set/multi_map
哈希结构：底层就是哈希表，如unordered_set/unordered_map等(后续介绍)
二、键值对
实际上就是一种一一对应的关系的结构，一个关键字都有一个对应的值，该结构中有两个成员变量，即Key和Value，Key代表关键字(键值)，Value表示与Key对应的信息。
比如：英汉字典，英文和中文都有一一对应的关系。
结构可如下所示：
template<class T1,class T2>
struct pair
{
typedef T1 first_type;
typedef T2 second_type;
//成员变量
first_type first;
second_type second;
//构造
pair()
:first(first_type())
,second(second_type())
{}
};三、set
介绍
-
set 是按照一定次序存储元素的容器，有序序列
-
在 set 中，元素的 value 也标识它 (value 就是 key ，类型为 T) ，并且每个 value 必须是唯一的set中的元素不能在容器中修改 (元素总是const) ，但是可以从容器中插入或删除它们。
为何不能修改呢?就是因为其底层是红黑树，二叉搜索树，这棵树的结构是通过Key建立起来的，如若修改，那这棵红黑树的结构就乱了！
-
set 容器通过 key 访问单个元素的速度通常比 unordered_set 容器慢，但它们允许根据顺序对子集进行直接迭代。
注意：
- set只放value，但底层实际是<value,value>的键值对，也就是个K模型的红黑树
- set插入元素时，只需插入value即可，如insert(3)
- set可以去重，也就是不允许数据冗余
- 中序遍历得到的结果就是一个有序序列，默认是升序序列，因为底层是二叉平衡搜索树(红黑树)
- 在使用set需要包含头文件set
简单使用
T：元素的类型。实际底层就是<value，value>的键值对
Compare：仿函数，默认升序
Alloc：空间配置器
1.构造
set<int> s;//无参构造
set<int> s1={3,6,1,2,2};//初始化列表
set<int> s2(s);//拷贝构造
string st = "asdasdsad";
set<char> s3(st.begin(), st.end());//迭代器区间构造
set<int, greater<int>> s4;//自定义仿函数2.相关迭代器
| iterator begin() | 返回起始位置元素的迭代器 |
| iterator end() | 返回最后元素下一个位置的迭代器 |
| reverse_iterator rbegin() | 返回起始位置的反向迭代器 |
| reverse_iterator rend() | 返回最后元素下一个位置的反向迭代器 |
举例
set<int> s = { 3,6,1,2,2 };
set<int>::iterator it = s.begin();
while (it != s.end())
{
cout << *it << " ";
it++;
}//1,2,3,6
set<int> s1 = { 3,6,1,2,2 };
set<int>::reverse_iterator it = s1.rbegin();
while (it != s1.rend())
{
cout << *it << " ";
it++;
}//6,3,2,13.容量
| size() | 返回有效元素个数 |
| empty() | 判空，空为true，不空为false |
s.size();
s.empty();4.修改
| pair<iterator,bool> insert(const value _type& x) | 插入数据x,实际上插入的是<x,x>键值对，返回的是pair对象，插入成功返回<该元素新插入位置，true>，若失败，说明已存在，返回<该元素的位置，false> |
| erase | 删除数据 |
| swap | 交换两个set中的数据 |
| clear | 清空set的数据 |
| find(x) | 返回x在set中的位置，返回类型为迭代器 |
| count(x) | 返回set中值为x的数据个数 |
示例：
set<int> s;
s.insert(2);
s.insert(1);
s.insert(1);
s.insert(3);
s.insert(4);
set<int>::iterator it=s.find(2);//查找一般配合插入删除操作
s.insert(it, 6);//在指定位置前插入数据,但是打印出来的结果还是有序的。也看不出来，没啥意义
cout << endl;
s.erase(6);
set<int> s1;
s1.swap(s);//交换
cout << s.count(1) << endl;//这个没什么意义，因为set去重的，存在的元素的个数都是1，不存在就是0
//1四、multiset
这个在使用上和set没啥区别 ，和set的最大区别就是multiset不可以去重，允许数据冗余！仅此而已！这里就不重复给出常用接口了，详情请看set
注意：使用它时头文件也是set
使用实例：
multiset<int> s;//无参构造
multiset<int> s1 = { 3,6,1,2,2 };//初始化列表
multiset<int> s2(s);//拷贝构造
string st = "asdasdsad";
multiset<char> s3(st.begin(), st.end());//迭代器区间构造
multiset<int, greater<int>> s4;//自定义仿函数
s.insert(2);
s.insert(2);
s.insert(1);
s.insert(1);
s.insert(3);
s.insert(4);
for (auto a : s)
{
cout << a << " ";//这里的结果为1 1 2 3 4
}
cout << endl;
multiset<int>::iterator it = s.find(2);
s.insert(it, 6);
for (auto a : s)
{
cout << a << " ";
}
cout << endl;
s.erase(6);
cout << s.count(2) << endl;//这个函数在这里有意义，能够统计容器中值为value的个数，因为该容器不去重值得一提的是：multiset中的find和set有点不一样，因为multiset不去重，所以可能会存在一个元素出现多次的情况，那么find返回的是中序遍历的第一个值的位置。
为什么插入在左边和右边都一样呢？因为它底层是红黑树，二叉搜索树，要保持平衡，所以需要旋转处理，旋转后都一样，原本插入在右边的，旋转过后可能又回到左边！
五、map
介绍
- map是关联式容器，它的每一个元素都是一对键值对，也就是pair。底层是KV模型红黑树
- map中，键值Key用于排序和唯一标识的元素，而值value中存储与对应的Key相关联的内容
- 键值Key和值Value类型可能不同，两者内部通过value_type绑定，别名为pair。
value_type原型：
typedef pair<const K,V> value_type
可以看出Key一定不能修改的，唯一标识！
- map支持下标访问，即重载了operator[]，在【】中放入Key，就能找到相应的value。
- 默认升序，从小到大排，先比键值Key，Key一样比Value。
使用
1.定义的方式
map<string, int> m1;//构造一个Key类型为string，value类型为int的空容器
map<string, int> m2(m1);//拷贝构造
map<string, int> m3(m2.begin(), m2.end());//迭代器区间构造
map<string, int, greater<int>> m4;//指定比较方式的构造2.迭代器相关
| iterator begin() | 返回起始位置元素的迭代器 |
| iterator end() | 返回最后元素下一个位置的迭代器 |
| reverse_iterator rbegin() | 返回起始位置的反向迭代器 |
| reverse_iterator rend() | 返回最后元素下一个位置的反向迭代器 |
| const_iterator cbegin()+cend() | 操作和begin，end一样，区别就是cbegin+cend指向元素不能修改，因为是const |
m4.begin();
m4.end();3.容量与operator【】(重点)
| empty | 判空 |
| size | 有效元素个数 |
| operator【Key】 | 返回的是key对应的value的引用 |
值得一提的是operator【】，这个的原型如下：
调用这个函数等价于：
可以看到，它等价于调用insert函数，如何理解上面这段等价关系呢？先来解读一下insert函数
这段话的含义就是：
- Key存在，插入失败，返回->pair<Key所在位置的迭代器,false>
- Key不存在，插入成功,返回->pair<Key新插入位置的迭代器,true>
也就是说不管插入是否成功，最终都会返回Key所在位置的迭代器。即pair中的iterator始终都指向Key所在的位置。插入成功与否主要看false和true，即pair中的bool
所以等价拆分就是：
V& operator[](const Key& k)
{
pair<iterator, bool> ret = insert(make_pair(K, V()));
iterator it = ret.first;
return it->second;
}所以实际上operator[]功能十分强大，不仅能查找，当Key不存在时，还能插入，同时因为它返回的是value的引用，还能够修改value的值。
map<string, int> m;
m.insert({ "string",1 });
//Key不存在就插入
m["好的"];
//修改
m["好的"]++;
//插入+修改
m["你好"]++;
//查找
cout << m["string"] << endl;
实际上，map中的operator【】实际中用得十分的普遍，比如最常见的统计次数等等
注意区分这里operator[]和vector等序列式容器的区别，vector是下标访问，这里是键值Key！
4.修改
| pair<iterator,bool> insert(const value _type& x) | 插入数据 |
| erase | 删除数据 |
| swap | 交换两个map的数据 |
| clear | 清空的数据 |
| find(x) | 返回x在map中位置的迭代器，找到则返回迭代器，否则返回end()。x为key |
| count(x) | 返回Key为x的键值在map中的个数，注意map中Key是唯一的，返回值要么是0，要么是1。 |
使用举例：
一定要注意insert插入数据的写法，map中每一个元素都是一个pair，即键值对。
map<string, string> m;
//插入写法一：有名对象
pair<string, string> kv("string", "字符串");
m.insert(kv);
//写法二：匿名对象
m.insert(pair<string, string>("left", "左边"));
//写法三：使用make_pair函数来构造键值对
m.insert(make_pair("right", "右边"));
//写法四：隐式类型转化，常用写法
m.insert({ "love","爱" });//注意是大括号括起来
//遍历写法一:迭代器
//map<string, string>::iterator it = m.begin();
auto it = m.begin();
while (it != m.end())
{
//cout << (*it).first << " :" << (*it).second << endl;
cout << it->first<< " :" << it->second << endl;
it++;
}
//遍历写法二：范围for
for (auto a : m)
{
cout << a.first << " :" << a.second << endl;//可以理解为从结构体中取出变量，a就是一个pair
}
cout << endl;
map<string, string> m1;
m1.swap(m);
auto it1 = m1.find("love");
if (it1 != m1.end())
{
m1.erase(it);
}
m1.count("love");
m1.clear();小总结：
- map的元素是键值对，kv模型的红黑树
- key唯一不能修改
- 默认升序，按键值key比较大小，key同再比value
- 支持operator【】，实际用得多
六、multimap
同样和map操作上也没区别，唯一的区别就是：map的key是唯一的，multimap的key可以是重复的。允许数据冗余。
实例：
multimap<string, string> m;
//插入写法一：有名对象
pair<string, string> kv("string", "字符串");
m.insert(kv);
//写法二：匿名对象
m.insert(pair<string, string>("left", "左边"));
//写法三：使用make_pair函数来构造键值对
m.insert(make_pair("right", "右边"));
//写法四：隐式类型转化，常用写法
m.insert({ "love","爱" });//注意是大括号括起来
//遍历写法一:迭代器
//multimap<string, string>::iterator it = m.begin();
auto it = m.begin();
while (it != m.end())
{
//cout << (*it).first << " :" << (*it).second << endl;
cout << it->first << " :" << it->second << endl;
it++;
}
//遍历写法二：范围for
for (auto a : m)
{
cout << a.first << " :" << a.second << endl;//可以理解为从结构体中取出变量，a就是一个pair
}
cout << endl;
multimap<string, string> m1;
m1.swap(m);
//auto it1 = m1.find("love");
//if (it1 != m1.end())
//{
// m1.erase(it);
//}
m1.count("love");
m1.clear();
}注意：
①multimap的insert是这样的：
②multimap没有operator【】重载，因为multimap允许数据冗余，会存在相同的Key，若重载【】，编译器不知道具体访问Key的哪个value，也不知道要返回哪一个value的引用，因此而产生歧义。所以不重载。
好了兄弟们，今天的内容就分享到这里，如果对你有用，欢迎三连，你的支持永远是我前进的动力！
扫一扫
830
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
