C++set、map、multiset、multimap的使用
文章目录
-
- 1.关联式容器
- 2.树形结构和哈希结构
- 3.set
-
- 3.1set的介绍
- 3.2set的构造
- 3.3set的迭代器
- 3.4set的常用成员函数
- 4.multiset
- 5.map
-
- 5.1map的介绍
- 5.2pair和make_pair
- 5.3map的构造
- 5.4map的插入
- 5.5map的遍历
- 5.6map的修改
- 5.7map的删除
- 5.8operator[]与map经典场景
-
- 5.8.1统计次数的方式一
- 5.8.2统计次数的方式二
- 5.8.3统计次数的方式三(operator[])
-
- 5.8.3.1operator[]的底层原理
- 5.8.3.2operator[]的一些扩展场景
- 5.8.4Topk
- 5.8.5 [692.前K个高频单词](https://leetcode-cn.com/problems/top-k-frequent-words/)
- 6.multimap
1.关联式容器
C++STL包含了序列式容器和关联式容器：
-
序列式容器里面存储的是元素本身，其底层为线性序列的数据结构。比如：vector，list，deque，forward_list(C++11)等。
-
关联式容器里面存储的是
序列式容器，数据是挨着挨着放的。在哪里插入都可以。单纯目标就是内存中存储数据。
关联式容器也是用来存储数据的，与序列式容器不同的是，其里面存储的是结构的键值对，在数据检索时比序列式容器效率更高。目标是搜索内存中存储数据。
跟之前学习的二叉搜索树一样，搜索树有key和key-value的两个模型。
key：查找key在不在set
key/value:查找key在不在;通过key查找对应的value map
2.树形结构和哈希结构
根据应用场景的不同，STL总共实现了两种不同结构的管理式容器：树型结构与哈希结构。
树型结构的关联式容器主要有四种：map、set、multimap、multiset。这四种容器的共同点是：使用平衡搜索树(即红黑树) 作为其底层结果，容器中的元素是一个有序的序列。
| 关联式容器 | 容器结构 | 底层实现 |
|---|---|---|
| set,map,multiset,multimap | 树形结构 | 平衡搜索树(红黑树) |
| unordered_set,unordered_map,unordered_multiset,unordered_multimap | 哈希结构 | 哈希表 |
3.set
3.1set的介绍
- set是按照一定次序存储元素的容器
- 在set中，元素的value也标识它(value就是key，类型为T)，并且每个value必须是唯一的。set中的元素不能在容器中修改(元素总是const)，但是可以从容器中插入或删除它们。
- 在内部，set中的元素总是按照其内部比较对象(类型比较)所指示的特定严格弱排序准则进行排序。
- set容器通过key访问单个元素的速度通常比unordered_set容器慢，但它们允许根据顺序对子集进行直接迭代。
- set在底层是用二叉搜索树(红黑树)实现的。
Tips:
- 与map/multimap不同，map/multimap中存储的是真正的键值对，set中只放value，但在底层实际存放的是由
- set中插入元素时，只需要插入value即可，不需要构造键值对。
- set中的元素不可以重复(因此可以使用set进行去重)。
- 使用set的迭代器遍历set中的元素，可以得到有序序列
- set中的元素默认按照小于来比较
- set中查找某个元素，时间复杂度为： l o g 2 n log_2{n} log2n
- set中的元素不允许修改，修改了就破坏了二叉搜索树的结构了。
- set中的底层使用二叉搜索树(红黑树)来实现。
3.2set的构造
| 函数声明 | 功能介绍 |
|---|---|
| set (const Compare& comp = Compare(), const Allocator& = Allocator() ); | 构造空的set |
| set (InputIterator first, InputIterator last, const Compare& comp = Compare(), const Allocator& = Allocator() ); | 用[first, last)区间中的元素构造set |
| set ( const set& x); | set的拷贝构造 |
- 构造某个类型的空容器
默认比较方式为升序
set<double> s;
比较方式为降序
set<double,greater<double> > s;
- 拷贝构造
set<double> s1;
set<double> s2(s1);
- 使用迭代器拷贝构造一段区间
string str = "123456";
set<char> s(str.begin(),str.end());
3.3set的迭代器
| 函数声明成员函数 | 功能 |
|---|---|
| iterator begin() | 返回set中起始位置元素的迭代器 |
| iterator end() | 返回set中最后一个元素后面的迭代器 |
| reverse_iterator rbegin() | 返回set第一个元素的反向迭代器，即end |
| reverse_iterator rend() | 返回set最后一个元素下一个位置的反向迭代器，即 rbegin |
3.4set的常用成员函数
| 函数声明 | 功能介绍 |
|---|---|
| pair insert ( const value_type& x) | 在set中插入元素x，实际插入的是构成的键值对， 如果插入成功，返回<该元素在set中的位置，true>,如果插入失败，说明x在set中已经存在，返回 |
| 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& st ); | 交换set中的元素（这种方式少一次拷贝）；直接swap(x,y)会有一次拷贝 |
| void clear ( ) | 将set中的元素清空 |
| iterator find ( const key_type& x ) const | 返回set中值为x的元素的位置 |
| size_type count ( const key_type& x ) const | 返回set中值为x的元素的个数 |
插入和遍历
int main()
{
set<int> s;
s.insert(5);
s.insert(1);
s.insert(3);
s.insert(4);
s.insert(5);
s.insert(6);
s.insert(3);
s.insert(3);
// 排序+去重
// 遍历方式1：正向迭代器
set<int>::iterator it = s.begin();
while (it != s.end())//注意set不能修改值
{
cout << *it << " ";
++it;
}
cout << endl;
// 遍历方式2:反向迭代器
set<int>::reverse_iterator rit = s.rbegin();
while (rit != s.rend())
{
cout << *rit << " ";
++rit;
}
cout << endl;
// 遍历方式3:auto
for (auto e : s)
{
cout << e << " ";
}
cout << endl;
}
查找和删除
int main()
{
set<int> s;
s.insert(5);
s.insert(1);
s.insert(3);
s.insert(4);
s.insert(5);
s.insert(6);
s.insert(3);
s.insert(3);
// 先查找，找到了再删。没找到，也去删会报错
auto pos = s.find(4);
if (pos != s.end())
{
s.erase(pos);
}
pos = s.find(40);
//s.erase(pos);
if (pos != s.end())
{
s.erase(pos);
}
// 在就删除，不在就不处理也报错
s.erase(3);
s.erase(30);
}
4.multiset
multiset和set的接口基本一致，有个别不同。
由于multiset可以存在多个相同的key，因此multiset查找的时候找的是中序的第一个。而且set的count只有1，multiset的count可以返回具体的元素个数。
删除的时候如果删除的是迭代器那么就是删除一个元素，如果指定key就是删除该key的所有元素。
底层上multiset对同key的处理统一规定挂在第一个同key的左边或者右边。
int main()
{
multiset<int> s;
s.insert(3);
s.insert(1);
s.insert(2);
s.insert(1);
s.insert(6);
s.insert(4);
s.insert(3);
s.insert(3);
s.insert(3);
// 排序
multiset<int>::iterator it = s.begin();
while (it != s.end())
{
cout << *it << " ";
++it;
}
cout << endl;
// find查找的val有多个的时候，那么他找到的是中序的第一个
multiset<int>::iterator pos = s.find(3);
while (*pos == 3)
{
cout << *pos << endl;
++pos;
}
cout << s.count(3) << endl;
cout << s.count(4) << endl;
s.erase(3);//删除所有的3
it = s.begin();
while (it != s.end())
{
cout << *it << " ";
++it;
}
cout << endl;
}
5.map
5.1map的介绍
- map是关联容器，它按照特定的次序(按照key来比较)存储由键值key和值value组合而成的元素。
- 在map中，键值key通常用于排序和惟一地标识元素，而值value中存储与此键值key关联的内容。键值key和值value的类型可能不同，并且在map的内部，key与value通过成员类型value_type绑定在一起，为其取别名称为pair:
typedef pair value_type; - 在内部，map中的元素总是按照键值key进行比较排序的。
- map中通过键值访问单个元素的速度通常比unordered_map容器慢，但map允许根据顺序对元素进行直接迭代(即对map中的元素进行迭代时，可以得到一个有序的序列)。
- map支持下标访问符，即在[]中放入key，就可以找到与key对应的value。
- map通常被实现为平衡二叉搜索树(红黑树)。
5.2pair和make_pair
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)
{}
};
make_pair：
template <class T1, class T2>
pair<T1, T2> make_pair(T1 x, T2 y)
{
return (pair<T1, T2>(x, y));
}
5.3map的构造
- 指定key和value的类型构造空容器。
map<int,int> map1;
- key的比较方式指定为大于
map<int,bool , greater<int> > map4;
- 拷贝构造同类型容器
map<int,int> map1;
map<int,int> map2 (map1);
- 使用迭代器拷贝构造一段内容
map<int,int> map1;
map<int,int> map3(map1.begin(),map1.end());
5.4map的插入
map::insert：
pair<iterator,bool> insert (const value_type&val);
insert函数的参数显示是value_type类型的，实际上value_type就是pair类型的别名：
typedef pair<const Key, T> value_type;
- 方式一:匿名对象插入map
int main()
{
map<int, double> m;
// 调用pair的构造函数，构造一个匿名对象插入
m.insert(pair<int, double>(1, 1.1));
m.insert(pair<int, double>(3, 3.3));
m.insert(pair<int, double>(2, 2.2));
m.insert(pair<int, double>(2, 3.3)); // key相同就会插入失败
}
但是这种做法每次要声明函数模板参数，比较麻烦。
- 方式二:使用make_pair
不需要去声明pair的参数，让函数模板自己推演，用起来方便些
int main()
{
map<int, double> m;
m.insert(make_pair(2, 2.2));
}
5.5map的遍历
关于这里的迭代器->访问，需要回顾STLlist存一个结构体的迭代器。
it -> first ,调用it.operator->(),返回pair* (回想链表，迭代器要承担的是一个相当于封装成的指针类)
需要对(pair*)->first,second，因此应该为it->->first。编译器把两个->->处理成一个。
int main()
{
map<int, double> m;
m.insert(pair<int, double>(1, 1.1));
m.insert(pair<int, double>(3, 3.3));
m.insert(pair<int, double>(2, 2.2));
m.insert(pair<int, double>(2, 3.3));
map<int, double>::iterator it = m.begin();
while (it != m.end())
{
//cout << (*it).first <<":"<<(*it).second<
cout << it->first << ":" << it->second << endl;
++it;
}
cout << endl;
}
但是这样如果要声明多个同类型迭代器就比较麻烦，而且实际项目中并不是using namespace std。
通过typedef简化命名
int main()
{
typedef std::map<std::string, std::string > DICT;
typedef std::pair<std::string, std::string > DICT_KV;
typedef std::map<std::string, std::string >:: iterator Dict_ITER;
DICT dict;
dict. insert(DICT_KV("insert","插入"));
dict. insert(std::make_pair("left","左边"));
dict. insert(std::make_pair("right","右边"));
DICT_ITER dit = dict.begin();
while (dit != dict.end())
{
//cout << (*it).first <<":"<<(*it).second<
cout << dit->first << ":" << dit->second << endl;
++dit;
}
cout << endl;
}
5.6map的修改
int main()
{
typedef std::map<std::string, std::string > DICT;
typedef std::pair<std::string, std::string > DICT_KV;
typedef std::map<std::string, std::string >:: iterator Dict_ITER;
DICT dict;
dict. insert(DICT_KV("insert","插入"));
dict. insert(std::make_pair("left","左边"));
dict. insert(std::make_pair("right","右边"));
DICT_ITER dit = dict.begin();
while (dit != dict.end())
{
dit -> second.insert(0,'{');
dit -> second += '}';
++dit;
}
cout << endl;
//修改map的特定value数据
auto ret = dict.find("left");
if(ret != dict.end() )
{
//ret -> second.insert(ret -> second.size() -1 , "、剩余" );
//可读性优化小技巧
string& str = ret->second;
str.insert( str.size() - 1 ,"、剩余");
}
dit = dict.begin();
while (dit != dict.end())
{
//cout << (*it).first <<":"<<(*it).second<
cout << dit->first << ":" << dit->second << endl;
++dit;
}
cout << endl;
}
5.7map的删除
通过key进行删除。
int main()
{
map<string,string> dict;
dict.insert(make_pair("sort","排序"));//插入
dict["left"] = "左边"; //先string默认构造函数生成空字符串,然后再修改。（插入+修改）
dict["insert"];//gdb到这里此时value是空字符串(插入)
dict["insert"]= "插入";//(修改)
dict.erase("left");
}
5.8operator[]与map经典场景
- 统计次数
- 找出TopK
5.8.1统计次数的方式一
思路:第一次出现,插入
int main()
{
//统计次数
string str[] = { "apple", "apple" , "apple" , "banana", "banana","banana","watermelon","peach","peach","pear","pear","pear","pear"};
map<string , int > countMap;
//思路:第一次出现,插入,后续再出现就++
for(const auto & i :str)
{
map<string,int>::iterator result = countMap.find(str);
if( result != countMap.end() )
{
result -> second ++;
}
else{
countMap.insert( make_pair(i,1) );
}
}
for( const auto& e: countMap)
{
cout<< e->first <<" " << e->second << endl;
}
}
5.8.2统计次数的方式二
insert的返回值:
pair<iterator,bool> insert (const value_type&val);
int main()
{
//统计次数
string str[] = { "apple", "apple" , "apple" , "banana", "banana","banana","watermelon","peach","peach","pear","pear","pear","pear"};
map<string , int > countMap;
//先插入，如果str已经在map中，insert会返回str所在节点的迭代器,我们++次数即可。
for(const auto & i :str)
{
//pair :: iterator,bool > ret = countMap.insert(make_pair(i,1));
auto ret = countMap.insert(make_pair(i,1));
if( ret. second == false)
{
ret.first->second ++;
}
}
for( const auto& e: countMap)
{
cout<< e->first <<" " << e->second << endl;
}
}
5.8.3统计次数的方式三(operator[])
5.8.3.1operator[]的底层原理
使用operator[]
V& opeartor[] (const key_type& k);
实际上该整个函数：
| member type | definition | |
|---|---|---|
key_type |
The first template parameter (Key) |
|
mapped_type |
The second template parameter (T) |
V& opeartor[] (const key_type& k)
{
return (*((this->insert(make_pair(k,mapped_type()))).first)).second
}
//mapped_type()为传入value的匿名对象，对于内置类型来说cpp提供了兼容，比如int(10),默认的话就是0.因为若第一次插入value 为int,新插入节点的value =0 并返回。
- 如果k不在map中,先插入
- 如果k已经在map中,返回所在节点中对应V对象的引用。
我们可以简化
value_type& opeartor[] (const key_type& k)
{
pair<iterator , bool> ret=insert(make_pair ( k, mapped_typed()));
return ret.first -> second;
}
countMap[str]++;
countMap.operator[](str)++,对返回值++
int main()
{
//统计次数
string str[] = { "apple", "apple" , "apple" , "banana", "banana","banana","watermelon","peach","peach","pear","pear","pear","pear"};
map<string , int > countMap;
//先插入，如果str已经在map中，insert会返回str所在节点的迭代器,我们++次数即可。
for(const auto & i :str)
{
map[i]++;
}
for( const auto& e: countMap)
{
cout<< e->first <<" " << e->second << endl;
}
}
5.8.3.2operator[]的一些扩展场景
int main()
{
map<string,string> dict;
dict.insert(make_pair("sort","排序"));//插入
dict["left"] = "左边"; //先string默认构造函数生成空字符串,然后再修改。（插入+修改）
dict["insert"];//gdb到这里此时value是空字符串(插入)
dict["insert"]= "插入";//(修改)
}
5.8.4Topk
针对次数（value）排序。
- 使用
vector存元素
int main()
{
string str[] = { "apple", "apple" , "apple" , "banana", "banana","banana","watermelon","peach","peach","pear","pear","pear","pear"};
map<string,int> countMap;
for(const auto& i: str)
{
countMap[i]++;
}
vector<pair<string,int> >v;
}
然后重载pair<>使得按照second来排序。但是很明显，这样做要多一次拷贝，效率并不高。
- 使用
vector存储迭代器
迭代器在使用上就可以考虑成是一个原生指针。
struct MapItCompare{
bool operator()(map<string,int>::iterator A,map<string,int>:: iterator B)
{
return A->second > B->second;
}
}
int main()
{
string str[] = { "apple", "apple" , "apple" , "banana", "banana","banana","watermelon","peach","peach","pear","pear","pear","pear"};
map<string,int> countMap;
for(const auto& i : str){
countMap[i]++;
}
vector< map<string,int>::iterator > v;
map<string,int> :: iterator countMapIt = countMap.begin();
while( countMapIt != countMap.end() )
{
v.push_back(countMapIt);
countMapIt++;
}
sort( v.begin() , v.end() , MapItCompare() );
//set::iterator,MapItCompare > sortSet;
}
- 再创建一个
multimap
int main()
{
string str[] = { "apple", "apple" , "apple" , "banana", "banana","banana","watermelon","peach","peach","pear","pear","pear","pear"};
map<string,int> countMap;
for(const auto& i : str){
countMap[i]++;
}
multimap<int,string , greater<int> > sortMap;
for(const auto& e: countMap)
{
sortMap.insert(make_pair(e.second,e.first));
}
}
- 创建set存迭代器
// 利用set排序 --不拷贝pair数据
set<map<string, int>::iterator, MapItCompare> sortSet;
countMapIt = countMap.begin();
while (countMapIt != countMap.end())
{
sortSet.insert(countMapIt);
++countMapIt;
}
- 创建堆来存数据
typedef map<string, int>::iterator MI;
priority_queue<MI, vector<MI>, MapItCompare> pq;
countMapIt = countMap.begin();
while (countMapIt != countMap.end())
{
pq.push(countMapIt);
++countMapIt;
}
5.8.5 692.前K个高频单词
方法一：使用map和multimap的二叉搜索树自动排序
这道题唯一的一个点就是sort底层是快排，所以就算写了仿函数也是做不到稳定的。而题目要求的是稳定的。
而使用multimap/map的二叉搜索树的排序是稳定的，就算旋转了相对关系也是不变的。
class Solution {
public:
vector<string> topKFrequent(vector<string>& words, int k) {
map<string,int> map1;
for(auto & i: words) map1[i]++;
vector< map<string,int>::iterator > v;
map<string,int>::iterator it = map1.begin();
while ( it != map1.end() )
{
v.push_back(it);
it ++ ;
}
multimap< int ,string ,greater<int> > mult;
for(const auto& i : map1)
{
mult.insert(make_pair(i.second , i.first ));
}
vector<string> ans;
multimap< int,string ,greater<int> > ::iterator muit = mult.begin();
while(k--)
{
ans.push_back( muit->second);
muit ++ ;
}
return ans;
}
};
方法二：本质是TopK问题，利用哈希表先处理次数，然后pair
TopK问题也是面试中的一个常见问题，其特点主要是考察空间复杂度。
6.multimap
multimap和map的接口大致相同。其关系类似multiset和set。多个查找中序的第一个。
- 允许键值冗余与否
multimap不提供[]
int main()
{
map<string,string> dict;
dict.insert(make_pair("left","左边"));
dict.insert(make_pair("left","剩余"));
multimap<string,string> mdict;
mdict.insert(make_pair("left","左边"));
mdict.insert(make_pair("left","剩余"));
}