map和set
1. 关联式容器
1.1 介绍
我们已经接触过STL中的部分容器，比如：vector、list、deque、forward_list(C++11)等，这些容器统称为序列式容器，因为其底层为线性序列的数据结构，里面存储的是元素本身。
那什么是关联式容器？它与序列式容器有什么区别？
关联式容器也是用来存储数据的，与序列式容器不同的是，其里面存储的是<key, value>结构的键值对，在数据检索时比序列式容器效率更高。
1.2 键值对
用来表示具有一一对应关系的一种结构，该结构中一般只包含两个成员变量key和value，key代表键值value表示与key对应的信息。比如：现在要建立一个英汉互译的字典，那该字典中必然有英文单词与其对应的中文含义，而且，英文单词与其中文含义是一一对应的关系，即通过该应该单词，在词典中就可以找到与其对应的中文含义。
1.3 树形结构的关联式容器
根据应用场景的不同，STL总共实现了两种不同结构的管理式容器：树型结构与哈希结构。树型结构的关联式容器主要有四种：map、set、multimap、multiset。这四种容器的共同点是：使用平衡搜索树(即红黑树)作为其底层结果 ，容器中的元素是一个有序的序列。下面一依次介绍每一个容器。
2. set
2.1 set的介绍
set - C++ Reference (cplusplus.com)
- set是按照一定次序存储元素的容器
- 在set中，元素的value也标识它(value就是key，类型为T)，并且每个value必须是唯一的。set中的元素不能在容器中修改(元素总是const)，但是可以从容器中插入或删除它们。
- 在内部，set中的元素总是按照其内部比较对象(类型比较)所指示的特定严格弱排序准则进行排序。
- set容器通过key访问单个元素的速度通常比unordered_set容器慢，但它们允许根据顺序对子集进行直接迭代。
- set在底层是用二叉搜索树(红黑树)实现的。
注意
- 与map/multimap不同，map/multimap中存储的是真正的键值对<key, value>，set中只放value，但在底层实际存放的是由<value, value>构成的键值对。
- set中插入元素时，只需要插入value即可，不需要构造键值对。
- set中的元素不可以重复(因此可以使用set进行去重)。
- 使用set的迭代器遍历set中的元素，可以得到有序序列
- set中的元素默认按照小于来比较
- set中查找某个元素，时间复杂度为： l o g 2 n log_2 n log2n
- set的作用：排序 + 去重
2.2 set的使用
2.2.1 set的模板参数列表
T: set中存放元素的类型，实际在底层存储<value, value>的键值对。
Compare：set中元素默认按照小于来比较
Alloc：set中元素空间的管理方式，使用STL提供的空间配置器管理
2.2.2 set的构造
| 函数声明 | 功能介绍 |
|---|---|
| set (const Compare& comp = Compare(), const Allocator&= Allocator() ); | 构造空的set |
| set (InputIterator first, InputIterator last, const Compare& comp = Compare(), const Allocator& =Allocator() ); | 用[first, last)区间中的元素构造 |
| set ( const set<Key,Compare,Allocator>& x); | set的拷贝构造 |
2.2.3 set的迭代器和容量
迭代器部分与vector，list相似，容量比较简单，直接参考文档即可
2.2.4 set修改操作
| 函数声明 | 功能介绍 |
|---|---|
| pair<iterator,bool> insert (const value_type& x ) | 在set中插入元素x，实际插入的是<x, x>构成的键值对，如果插入成功，返回<该元素在set中的位置，true>,如果插入失败，说明x在set中已经存在，返回<x在set中的位置，false> |
| void erase ( iterator position ) | 删除set中position位置上的元素 |
| size_type erase ( const key_type& x ) | 删除set中值为x的元素，返回删除的元素的个数 |
| void erase ( iterator first, iterator last ) | 删除set中[first, last)区间中的元素 |
| void swap (set<Key,Compare,Allocator>&st ); | 交换set中的元素 |
| void clear ( ) | 将set中的元素清空 |
| iterator find ( const key_type& x ) const | 返回set中值为x的元素的位置 |
| size_type count ( const key_type& x ) const | 返回set中值为x的元素的个数 |
2.2.5 set使用举例
set作用: 排序 + 去重
void test1()
{
set<int> s1;
s1.insert(3);
s1.insert(1);
s1.insert(4);
s1.insert(2);
s1.insert(1); //不允许插入重复元素, 插入失败
s1.insert(2);
set<int>::iterator it1 = s1.begin();
while (it1 != s1.end())
{
//搜索二叉树不允许修改key, 破坏了树的规则
//*it = 1;
cout << *it1 << " ";
++it1;
}
cout << endl;
//范围for
for (auto e : s1)
{
cout << e << " ";
}
}
int main()
{
test1();
return 0;
}
运行结果:
演示count
因为set中的每个元素是唯一的，所以count函数看起来没什么用，实际上它可以用来判断元素在不在set中的问题
void test2()
{
//排序 + 去重
set<int> s1;
s1.insert(3);
s1.insert(1);
s1.insert(4);
s1.insert(2);
s1.insert(1);
s1.insert(2);
// set中值为3的元素出现了几次
cout << s1.count(3) << endl;
int x;
while (cin >> x)
{
auto ret = s1.find(x);
if (ret!=s1.end())
{
cout << "在" << endl;
}
else
{
cout << "不在" << endl;
}
//与上面的写法功能相似
if (s1.count(x))
{
cout << "在" << endl;
}
else
{
cout << "不在" << endl;
}
}
}
运行结果:
3. multiset
3.1 multiset的介绍
基本与set 特点相似, 接口相似
-
与set的区别是，multiset中的元素可以重复，set中value是唯一的
-
使用迭代器对multiset中的元素进行遍历，可以得到有序的序列
-
multiset的作用：可以对元素进行排序
3.2 multiset使用举例
multiset作用: 排序
当有多个key时, find的是中序第一个key
void test4()
{
//排序
multiset<int> s1;
s1.insert(3);
s1.insert(1);
s1.insert(4);
s1.insert(2);
s1.insert(1);
s1.insert(2);
// set中值为2的元素出现了几次
cout << s1.count(2) << endl;
multiset<int>::iterator it1 = s1.begin();
while (it1 != s1.end())
{
cout << *it1 << " ";
++it1;
}
cout << endl;
//多个key, find的是中序第一个key
auto ret = s1.find(1);
while (ret != s1.end() && *ret==1)
{
cout << *ret << " ";
++ret;
}
cout << endl;
cout << s1.count(1) << endl;
}
运行结果:
4. map
4.1 map的介绍
map - C++ Reference (cplusplus.com)
- map是关联容器，它按照特定的次序(按照key来比较)存储由键值key和值value组合而成的元素。
- 在map中，键值key通常用于排序和惟一地标识元素，而值value中存储与此键值key关联的内容。键值key和值value的类型可能不同，并且在map的内部，key与value通过成员类型value_type绑定在一起，为其取别名称为pair: typedef pair<const key, T> value_type;
- 在内部，map中的元素总是按照键值key进行比较排序的。
- map中通过键值访问单个元素的速度通常比unordered_map容器慢，但map允许根据顺序对元素进行直接迭代(即对map中的元素进行迭代时，可以得到一个有序的序列)。
- map支持下标访问符，即在[]中放入key，就可以找到与key对应的value。
- map通常被实现为二叉搜索树(更准确的说：平衡二叉搜索树(红黑树))。
4.2 map的使用
4.2.1 map的模板参数说明
key: 键值对中key的类型
T： 键值对中value的类型
Compare: 比较器的类型，map中的元素是按照key来比较的，缺省情况下按照小于来比较，一般情况下(内置类型元素)该参数不需要传递，如果无法比较时(自定义类型)，需要用户自己显式传递比较规则(一般情况下按照函数指针或者仿函数来传递)
Alloc：通过空间配置器来申请底层空间，不需要用户传递，除非用户不想使用标准库提供的空间配置器
4.2.2 pair的介绍
pair是一个key/value结构的struct模板类。这个类将一对键值耦合在一起，所以，map的存储方式是通过存储键值对pair，而搜索二叉树的k/v模型是在节点中存储key和value两个变量类型，并不相同。pair的结构:
template <class T1, class T2>
struct pair
{
typedef T1 first_type;
typedef T2 second_type;
T1 first;
T2 second;
pair(): first(T1()), second(T2())
{}
pair(const T1& a, const T2& b): first(a), second(b)
{}
};
那为什么需要pair这个东西将两个值放在一起呢？实际上是为了map能够更方便的操作，举个例子，对于map,如果是迭代器访问，返回的时候不可能返回两个参数，这时候以pair为参数的函数就派上用场了，直接返回pair类型就好了。
pair在使用时需要指定类型
void map_test1()
{
map<string,string> dict;
dict.insert(pair<string,string>("sortq", "排序q")); //这种写法是去调用匿名构造
}
所以我们一般可以使用make_pair，make_pair是一个函数模板:
template <class T1,class T2>
pair<T1,T2> make_pair (T1 x, T2 y)
{
return ( pair<T1,T2>(x,y) );
}
使用时不用指定类型
oid map_test1()
{
map<string,string> dict;
dict.insert(make_pair("sort", "排序")); //make_pair是函数模板
dict.insert(make_pair("string", "字符串"));
}
但make_pair类型也不支持流插入，所以就需要一个一个的访问
void map_test1()
{
//排序
map<string,string> dict;
dict.insert(make_pair("sort", "排序")); //make_pair是函数模板
dict.insert(make_pair("string", "字符串"));
dict.insert(make_pair("count", "计数"));
auto dit = dict.begin();
while (dit != dict.end())
{
cout << (*dit).first << ":" << (*dit).second << endl; //这种写法也可以
cout << dit->first << ":" << dit->second << endl;
++dit;
}
}
运行结果:
4.2.3 map的[]重载
例如需要实现统计水果出现的次数
void map_test3()
{
string arr[] = { "西瓜", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜", "苹果", "香蕉", "苹果", "香蕉", "梨" };
map<string, int> countMap;
for (auto& e : arr)
{
auto ret = countMap.find(e);
if (ret == countMap.end())
{
countMap.insert(make_pair(e, 1)); //第一次插入
}
else
{
ret->second++;
}
}
for (auto& kv : countMap)
{
cout << kv.first << ":" << kv.second << endl;
}
}
运行结果:
上面的代码是可以的，但是还是要区分是第一次插入还是非第一次插入写法略微麻烦，那么可不可以写到一起呢？我们可以使用[]来完成
map的返回值即所标注的部分
结合insert函数
在map中插入键值对x，注意x是一个键值对，返回值也是键值对：iterator代表新插入元素的位置，bool代表是否插入成功
因此，我们可以将最上面的map重载的返回值进行解释了，可以转化成这样:
V& operator[](const K& key)
{
//在结构体pair中找到first(一个map的迭代器)，->解引用找到该迭代器的pair，再找该pair的second(即value)
pair<iterator, bool> ret = insert(make_pair(key, V()));
return ret.first->second;
}
总结[]的4种功能
1. 插入
2. 插入 + 修改
3. 修改
4. 查找
示例代码
void map_test2()
{
//排序
map<string, string> dict;
dict.insert(make_pair("sort", "排序"));
dict.insert(make_pair("string", "字符串"));
dict.insert(make_pair("count", "计数"));
dict.insert(make_pair("string", "(字符串)")); //插入失败
dict["left"]; //插入
dict["right"]="右边"; //插入 + 修改
dict["string"] = "(字符串)"; //修改
auto dit = dict.begin();
while (dit != dict.end())
{
cout << (*dit).first << ":" << (*dit).second << endl;
++dit;
}
cout << dict["string"] << endl; //查找
}
运行结果:
那么回到最开始的统计水果次数的问题，就可以这样简洁写
void map_test3()
{
string arr[] = { "西瓜", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜", "苹果", "香蕉", "苹果", "香蕉", "梨" };
map<string, int> countMap;
for (auto& e : arr)
{
countMap[e]++;
}
for (auto& kv : countMap)
{
cout << kv.first << ":" << kv.second << endl;
}
}
5. multimap
multimap和map的唯一不同就是：map中的key是唯一的，而multimap中key是可以重复的。
multimap没有重载[]
同样的，使用find将返回中序遍历找到的第一个key值所处节点的迭代器
可以实现一词多义
void map_test4()
{
//排序
multimap<string, string> dict;
dict.insert(make_pair("sort", "排序"));
dict.insert(make_pair("string", "字符串"));
dict.insert(make_pair("count", "计数"));
dict.insert(make_pair("string", "(字符串)"));
auto dit = dict.begin();
while (dit != dict.end())
{
cout << (*dit).first << ":" << (*dit).second << endl;
++dit;
}
}
运行结果:
6. map和set在OJ中的使用
前K个高频单词
思路
主要是两种思路:
思路1: 先将单词保存到map中同时统计单词出现次数，后对这组单词按照题目要求对value值排序(出现次数)同时保证相关字典排序要求，最后将前K个对应K值放入另一个数组中返回，这里的排序要保证是稳定排序，可以使用stable_sort排序也可以用sort排序再写一些按字典排序的限制
注意: map的迭代器是双向迭代器, sort时需要的迭代器是随机迭代器，不能直接排序要先保存到数组中
思路2: 与思路1类似，只是把数组元素放入set中排序处理
示例代码1
class Solution {
public:
vector<string> topKFrequent(vector<string>& words, int k) {
struct Compare
{ //写成内部类的形式
bool operator()(const pair<string,int>&kv1,const pair<string,int>&kv2)
{
return kv1.second>kv2.second;
}
};
//1. 统计次数
map<string,int> countMap;
for(auto&str:words)
{
countMap[str]++;
}
//2. 将countMap中元素保存到数组中
//map的迭代器是双向迭代器, sort时需要的迭代器是随机迭代器
//不能直接排序要先保存到数组中
//数组的迭代器区间初始化
vector<pair<string,int>> v(countMap.begin(),countMap.end()); //数组中存放的是键值对
//3. 对value值(即出现频率)排序 --- 要保证是稳定排序
stable_sort(v.begin(), v.end(), Compare());
//4. 对应的key值放入另一个数组中返回
vector<string> ret;
for(int i=0;i<k;++i)
{
ret.push_back(v[i].first);
}
return ret;
}
};
示例代码2
class Solution {
public:
vector<string> topKFrequent(vector<string>& words, int k) {
struct Compare
{ //写成内部类的形式
bool operator()(const pair<string,int>&kv1,const pair<string,int>&kv2)
{ //次数相等, 字典序小的在前面
return kv1.second>kv2.second || (kv1.second==kv2.second && kv1.first<kv2.first);
}
};
//1. 统计次数
map<string,int> countMap;
for(auto&str:words)
{
countMap[str]++;
}
//2. 将countMap中元素保存到数组中
//map的迭代器是双向迭代器, sort时需要的迭代器是随机迭代器
//不能直接排序要先保存到数组中
//数组的迭代器区间初始化
vector<pair<string,int>> v(countMap.begin(),countMap.end()); //数组中存放的是键值对
//3. 对value值(即出现频率)排序 --- 要保证是稳定排序
// stable_sort(v.begin(), v.end(), Compare());
sort(v.begin(), v.end(), Compare()); //仿函数生成匿名对象返回,参数传对象
//4. 对应的key值放入另一个数组中返回
vector<string> ret;
for(int i=0;i<k;++i)
{
ret.push_back(v[i].first);
}
return ret;
}
};
示例代码3
class Solution {
public:
vector<string> topKFrequent(vector<string>& words, int k) {
struct Compare
{ //写成内部类的形式
bool operator()(const pair<string,int>&kv1,const pair<string,int>&kv2)const
{ //次数相等, 字典序小的在前面
return kv1.second>kv2.second || (kv1.second==kv2.second && kv1.first<kv2.first);
}
};
//1. 统计次数
map<string,int> countMap;
for(auto&str:words)
{
countMap[str]++;
}
//2. 将countMap中元素保存multiset或set中进行排序 仿函数这里参数是传类型
set<pair<string, int>,Compare> sortSet(countMap.begin(),countMap.end());
//3. 对应的key值放入另一个数组中返回
vector<string> ret;
auto it=sortSet.begin();
while(k--)
{
ret.push_back(it->first);
++it;
}
return ret;
}
};
两个数组的交集
思路
找两个数组的交集，对数组 排序+去重 处理后再找交集，所以只需将数组的元素保留到set中
找交集的过程:
- 不相等，较小的值++
- 相等就是交集保存到一个数组中后，两个同时++
当有一个集合走完了，就结束了
示例代码
class Solution {
public:
vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
//1. 排序 + 去重 ---> set
set<int> s1(nums1.begin(), nums1.end());
set<int> s2(nums2.begin(), nums2.end());
//2. 开始比对
auto it1 = s1.begin();
auto it2 = s2.begin();
vector<int> v;
while (it1 != s1.end() && it2 != s2.end()) //有一个结束就结束了
{
if (*it1 == *it2) //相等, 一起++
{
v.push_back(*it1);
++it1;
++it2;
}
else if (*it1 < *it2) //不相等, 小的++
{
++it1;
}
else
{
++it2;
}
}
return v;
}
};
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
