关于C++的STL中的容器，之前我们已经说过了部分容器，比如：vector，list，forward_list......
这些容器统称为序列式容器，其底层的都是线性序列的数据结构，里面存储的是元素本身。
那么下面我们要说的是关联式容器，两者又有什么差距呢？
关联式容器也是存储数据的，不过其中存储的是<key,value>结构的键值对，关联式容器在数据检索式比序列式容器的效率高。
那么什么是键值对呢？
键值对是用来表示具有一一对应关系的一种结构，该结构一般只包含key和value两个成员变量，key表示键值，value表示与key对应的信息。
STL一共实现了两种不同结构的关联式容器：树形结构和哈希结构。
树形结构的容器主要有四种：map、set、multimap、multiset。
它们的共同点：使用平衡搜索树（红黑树）座位其底层结构。
下面介绍一下map：
1. map是关联容器，它按照特定的次序(按照key来比较)存储由键值key和值value组合而成的元素。
2. 在map中，键值key通常用于排序和惟一地标识元素，而值value中存储与此键值key关联的内容。键值
key和值value的类型可能不同，并且在map的内部，key与value通过成员类型value_type绑定在一起，
为其取别名称为pair:
typedef pair value_type;
3. 在内部，map中的元素总是按照键值key进行比较排序的。
4. map中通过键值访问单个元素的速度通常比unordered_map容器慢，但map允许根据顺序对元素进行
直接迭代(即对map中的元素进行迭代时，可以得到一个有序的序列)。
5. map支持下标访问符，即在[]中放入key，就可以找到与key对应的value。
6. map通常被实现为二叉搜索树(更准确的说：平衡二叉搜索树(红黑树))。
相信看完这个对map应该已经有了一定的理解，那么下面看看代码吧。
/map
/
#include<iostream>
#include<string>
#include<map>
using namespace std;
//void TestMap()
//{
// /key和value的类型都给成string
// map<string, string> m1;
// map<string, string> m2{ {"apple","苹果"},
// { "banan","香蕉"},
// {"orange","橘子"},
// {"pench","桃子"},
// {"waterme","水蜜桃"} };
// cout << m2["apple"] << endl;
// cout << m2["waterme"] << endl;
// cout << m2["app"] << endl;
//
// map<string, string>m3(m2);
//
//
//}
//void TestMap()
//{
// map<string, string>m;
// 构造一个空的map m；
// 插入key = apple value = 苹果
// /*
// operator[]的原理是：
// 用<key, T()>构造一个键值对，然后调用insert()函数将该键值对插入到map中
// 如果key已经存在，插入失败，insert函数返回该key所在位置的迭代器
// 如果key不存在，插入成功，insert函数返回新插入元素所在位置的迭代器
// operator[]函数最后将insert返回值键值对中的value返回
// */
// m["apple"] = "苹果";
// cout << m.size() << endl;
// cout << m["apple"] << endl;
// //banan不在m中会抛异常
// m.at("banan");
//}
//{
// map<string, string> m{ { "apple","苹果" },
// { "banan","香蕉" },
// { "orange","橘子" },
// { "pench","桃子" },
// { "waterme","水蜜桃" } };
// for (auto it = m.begin(); it != m.end(); ++it)
// {
// cout << (*it).first << "-->" << it->second << endl;
// cout << endl;
// }
//}
//void TestMap()
//{
// map<string, string>m;
///将键值<“peach”，“桃子”>插入map中，用pair直接来构造键值对
// m.insert(pair<string, string>("peach", "桃子"));
//将键值<"banan","香蕉">插入map中，用make_pair函数来构造键值对
// m.insert(make_pair("banan", "香蕉"));
//借助oerator[]向map中插入元素
// m["apple"] = "苹果";
// //当你要查找的key不存在时会抛异常
// //m.insert(make_pair("waterme", "水蜜桃"));
// m.insert(m.find("banan"), make_pair("waterme", "水蜜桃"));
// cout << m.size() << endl;
//
//
// for (auto &e : m)
// {
// cout << e.first << "-->" << e.second << endl;
// }
// cout << endl;
// auto ret = m.insert(make_pair("peach", "桃色"));
// if (ret.second)
// cout << "<peach, 桃色>不在map中，已经插入" << endl;
// else
// cout << "键值peach的元素已经存在：" << ret.first->first<< "-->" << ret.first->second << "插入失败" << endl;
//
//
// 删除key为"apple"的元素
// m.erase("apple");
// for (auto&e : m)
// {
// cout << e.first << "-->" << e.second << endl;
//
// }
// if (1 == m.count("apple"))
// cout << "apple还在" << endl;
// else
// cout << "apple被吃了" << endl;
//}
//int main()
//{
// TestMap();
// return 0;
//}当然关于map 还要多说两句：
map中的元素是键值对，map中的key是唯一的不能修改，map中的元素如果用迭代器遍历会得到一个有序的序列，支持【】操作符，operator【】中实际进行插入查找
multimap：
multimap和map差不多不过：map中的key是唯一的，而multimap中key是可以重复的
multimap中没有重载operator【】操作
//
/multimap///
//void TestMultiMap()
//{
// multimap<string, string> m;
// m.insert(make_pair("李逵", "黑旋风"));
// m.insert(make_pair("林冲", "豹子头"));
// m.insert(make_pair("史进", "九纹龙"));
// m.insert(make_pair("鲁达", "花和尚"));
// m.insert(make_pair("李逵", "铁牛"));
// cout << m.size() << endl;
// for (auto&e : m)
// {
// cout << "<"<<e.first << "," << e.second << ">" << endl;
//
// }
// cout << m.count("李逵") << endl;
//}
//void TestMultiMap1()
//{
// multimap<int, int> m;
// for (int i= 0; i < 10; ++i)
// {
// m.insert(pair<int, int>(i, i));
// }
// for (auto&e : m)
// cout << e.first << "-->" << e.second << endl;
// cout << endl;
// /返回m中大于等于5的第一个元素
// auto it = m.lower_bound(5);
// cout << it->first << "-->" << it->second << endl;
// 返回m中大于5的元素
// it = m.upper_bound(5);
// cout << it->first << "-->" << it->second << endl;
//
//}
//int main()
//{
// TestMultiMap1();
// return 0;
//}set：
下面我们来看看set：
1. 与map/multimap不同，map/multimap中存储的是真正的键值对<key, value>，set中只放value，但
在底层实际存放的是由<value, value>构成的键值对。
2. set中插入元素时，只需要插入value即可，不需要构造键值对。
3. set中的元素不可以重复(因此可以使用set进行去重)。
4. 使用set的迭代器遍历set中的元素，可以得到有序序列
5. set中的元素默认按照小于来比较
6. set中查找某个元素，时间复杂度为：
7. set中的元素不允许修改(为什么?)
8. set中的底层使用二叉搜索树(红黑树)来实现。
当然set也支持迭代器啦 什么的 我们还是来看代码吧
///set/
#include<set>
//void TestSet()
//{
// int array[] = { 1,2,3,4,5,6,7,8,9,10,55,1 ,3333333,3,3,3,3};
//
// set<int>s(array, array + sizeof(array) / sizeof(int));
// cout << s.size() << endl;
// for (auto&e : s)
// {
// cout << e << " ";
// }
// cout << endl;
// for (auto it = s.rbegin(); it != s.rend(); ++it)
// cout << *it << " ";
// cout << endl;
// cout << s.count(3) << endl;
//}
int main()
{
TestSet();
return 0;
}multiset：
下面就该multiset了，介绍就不说了 和set差不多 我们还是直接看看值得注意的地方吧
1. multiset中再底层中存储的是<value, value>的键值对
2. mtltiset的插入接口中只需要插入即可
3. 与set的区别是，multiset中的元素可以重复，set是中value是唯一的
4. 使用迭代器对multiset中的元素进行遍历，可以得到有序的序列
5. multiset中的元素不能修改
6. 在multiset中找某个元素，时间复杂度为O(log2 N)
7. multiset的作用：可以对元素进行排序
它的接口和set相同 可以互相参考
我们来看下代码吧
//
//multiset///
void TestSet()
{
int marry[] = { 1,1,2,3,4,5,6,7,8,9,7,8,9,4,85,6, 8};
multiset<int>s(marry, marry + sizeof(marry) / sizeof(int));
for (auto&e : s)
cout << e << " ";
cout << endl;
s.insert(5);
cout << s.count(5) << endl;
for (auto&e : s)
cout << e << " ";
cout << endl;
s.erase(5);
for (auto&e : s)
cout << e << " ";
cout << endl;
}
int main()
{
TestSet();
return 0;
}
关联式容器的简单介绍就先到这。
扫一扫
167
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
