【C++】set、multiset与map、multimap的使用

一、关联式容器

谈到关联式容器，先来说说序列式容器，以前学习的vector、list、deque等就是序列式容器，它们的特点是底层为线性序列的数据结构，存储的是元素本身。关联式容器也是存储数据的，不同的是，里面存储的是<key, value>结构的键值对，在数据检索时比序列式容器效率更高。

二、键值对

键值对是用来表示一一对应关系的结构，该结构中一般只包含两个成员变量key和value，key代表键值，value表示与key对应的信息，比如汉英互译字典，查中文就可以找到对应的英文，是有对应关系的。

键值对的定义：

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)
{}
};

三、树形结构的关联式容器

STL总共有两种结构的关联式容器，分别是哈希结构和树形结构。树形结构主要有4种：set、multiset、map、multimap，它们的共同点是底层是平衡搜索树即红黑树实现的，且容器中的元素是一个有序的序列。

3.1 set

特点：

1. 遍历set中的元素，可以得到一个有序序列，因为它的底层实现是红黑树，再底层是二叉搜索树，遍历方式是中序遍历。
2. set中的元素不可以重复，因此可以用set去重。
3. 与map/multimap不同，map/multimap中存储的是真正的键值对<key, value>，set中只放value，但在底层实际存放的是由<value, value>构成的键值对。
4. set中插入元素时，只需要插入value即可，不需要构造键值对。
5. set中的元素默认按照小于来比较。
6. set中查找某个元素，时间复杂度为：logN，即最多高度次。
7. 在内部，set中的元素总是按照其内部比较对象(类型比较)所指示的特定严格弱排序准则进行排序。
8. set容器通过key访问单个元素的速度通常比unordered_set容器慢，但它们允许根据顺序对子集进行直接迭代。
9. set中的元素不允许修改，因为修改了其中的一个元素会改变内部的结构，从而影响有序性。
10. set在底层是用二叉搜索树(红黑树)实现的。

3.1.1 模板参数列表

• T: set中存放元素的类型，实际在底层存储<value, value>的键值对。
• Compare：set中元素默认按照小于来比较。
• Alloc：set中元素空间的管理方式，使用STL提供的空间配置器管理。

3.1.2 构造

1️⃣构造空的set：

set<int> s;

2️⃣用迭代器区间构造：

set<int> s1(s.begin(), s.end());

3️⃣拷贝构造：

set<int> s2(s);

3.1.3 迭代器

1️⃣begin+end
正向遍历

	set<int> s;s.insert(1);s.insert(3);s.insert(3);s.insert(3);s.insert(5);s.insert(2);set<int>::iterator it = s.begin();while (it != s.end()){cout << *it << " ";++it;}cout << endl;

这里顺便检验下是否去重且有序：

2️⃣rbegin+rend
与上面类似，只不过是反向遍历

	set<int>::reverse_iterator rit = s.rbegin();while (rit != s.rend()){cout << *rit << " ";++rit;}cout << endl;

3.1.4 容量

1️⃣empty
判断set是否为空，空返回true，否则返回true

	set<int> s;cout << s.empty() << endl;//1

2️⃣size
返回set中有效元素的个数

set<int> s;
s.insert(1);
s.insert(3);
s.insert(3);
s.insert(3);
s.insert(5);
s.insert(2);
cout << s.size() << endl;//4

3.1.5 修改操作

1️⃣insert

pair<iterator,bool> insert ( const value_type& x )

在set中插入元素x，实际插入的是<x, x>构成的键值对，如果插入成功，返回<该元素在set中的位置，true>,如果插入失败，说明x在set中已经存在，返回<x在set中的位置，false>。

set<int> s;
s.insert(1);
s.insert(3);
s.insert(3);
s.insert(3);
s.insert(5);
s.insert(2);
for (auto& e : s)
{cout << e << " ";
}
cout << endl;

2️⃣erase
删除有三种方式：

删除set中position位置上的元素

void erase ( iterator position )

set<int> s;
s.insert(1);
s.insert(3);
s.insert(5);
s.insert(2);
for (auto& e : s)
{cout << e << " ";
}
cout << endl;
set<int>::iterator pos = s.begin();
s.erase(pos);
for (auto& e : s)
{cout << e << " ";
}

删除set中值为x的元素，返回删除的元素的个数

size_type erase ( const key_type& x )

set<int> s;
s.insert(1);
s.insert(3);
s.insert(5);
s.insert(2);
for (auto& e : s)
{cout << e << " ";
}
cout << endl;
s.erase(3);
for (auto& e : s)
{cout << e << " ";
}

删除set中[first, last)区间中的元素

void erase ( iterator first, iterator last )

set<int> s;
s.insert(1);
s.insert(3);
s.insert(5);
s.insert(2);
for (auto& e : s)
{cout << e << " ";
}
cout << endl;
s.erase(s.begin(), s.end());
for (auto& e : s)
{cout << e << " ";
}

3️⃣swap
交换set中的元素

void swap ( set<Key,Compare,Allocator>& st );

	set<int> s1;s1.insert(1);s1.insert(3);s1.insert(5);for (auto& e : s1){cout << e << " ";//1 3 5}cout << endl;set<int> s2;s2.insert(7);s2.insert(8);s2.insert(6);for (auto& e : s2){cout << e << " "; //6 7 8}cout << endl;s2.swap(s1);for (auto& e : s1){cout << e << " ";//6 7 8}cout << endl;for (auto& e : s2){cout << e << " ";//1 3 5}

4️⃣clear
将set中的元素清空

void clear ( )

set<int> s1;
s1.insert(1);
s1.insert(3);
s1.insert(5);
s1.clear();
for (auto& e : s1)
{cout << e << " ";// 空
}

5️⃣find
找到了，返回set中值为x的元素的位置，如果每找到，返回最后一个元素的下一个位置

iterator find ( const key_type& x ) const

set<int> s1;
s1.insert(1);
s1.insert(3);
s1.insert(5);
//s1.clear();
set<int>::iterator pos = s1.find(3);
if (pos != s1.end())cout << "找到了" << endl;//找到了
elsecout << "没找到" << endl;

6️⃣count
返回set中值为x的元素的个数，因为set是去重的，所以存在返回1，不存在返回0

size_type count ( const key_type& x ) const

set<int> s1;
s1.insert(1);
s1.insert(3);
s1.insert(5);
cout << s1.count(3) << endl;//1
cout << s1.count(33) << endl;//0

3.2 multiset

multiset与set的区别是存储的元素可以重复

void test_set8()
{multiset<int> s;s.insert(1);s.insert(3);s.insert(3);s.insert(5);s.insert(5);s.insert(5);s.insert(2);for (auto& e : s){cout << e << " ";//1 2 3 3 5 5 5}
}

还有接口与set的不同，分别是find和count

set的find与multiset的find
set不能有重复元素，所以找到了返回该元素的位置；multiset有重复元素，找到了返回该元素的第一个的位置。找不到都是返回end()

multiset<int> s;
s.insert(1);
s.insert(3);
s.insert(3);
multiset<int>::iterator pos = s.find(3);//返回第一个3的位置
while (pos != s.end())
{cout << *pos << " ";// 3 3++pos;
}
cout << endl;
}

set的count与multiset的count
set没有重复元素，所以存在的元素返回1，不存在返回0；multiset有重复元素，所以存在返回该元素的个数，不存在返回0

multiset<int> s;
s.insert(1);
s.insert(3);
s.insert(3);
s.insert(3);
s.insert(3);
cout << s.count(3) << endl;//4

3.3 map

与sert一样，map可以使容器的元素有序且去重
特点：

1. map中的元素是键值对，由key和value组成
2. 在map中，键值key通常用于排序和惟一地标识元素，而值value中存储与此键值key关联的内容。键值key和值value的类型可能不同，并且在map的内部，key与value通过成员类型value_type绑定在一起，为其取别名称为pair—— typedef pair<const key, T> value_type;
3. 在内部，map中的元素总是按照键值key进行比较排序的
4. map中的key是唯一的，并且不能修改
5. map中通过键值访问单个元素的速度通常比unordered_map容器慢，但map允许根据顺序对元素进行直接迭代(即对map中的元素进行迭代时，可以得到一个有序的序列)。
6. map支持下标访问符，可以进行插入、查找和修改
7. map的底层为平衡搜索树(红黑树)

3.3.1 模板参数列表

• key: 键值对中key的类型
• T： 键值对中value的类型
• Compare: 比较器的类型，map中的元素是按照key来比较的，缺省情况下按照小于来比较，一般情况下(内置类型元素)该参数不需要传递，如果无法比较时(自定义类型)，需要用户自己显式传递比较规则(一般情况下按照函数指针或者仿函数来传递)
• Alloc：通过空间配置器来申请底层空间，不需要用户传递，除非用户不想使用标准库提供的空间配置器

3.3.2 构造

1️⃣构造空的map

map<string, string> m;

2️⃣用迭代器区间进行构造

map<string, string> m1(m.begin(), m.end());

3️⃣拷贝构造

map<string, string> m2(m);

3.3.3 迭代器

1️⃣begin和end
正向遍历

map<string, string> m;
m.insert(pair<string, string>("sort", "排序"));
m.insert(pair<string, string>("apple", "苹果"));
m.insert(pair<string, string>("left", "左边"));
map<string, string>::iterator it = m.begin();
while (it != m.end())
{cout << *it << " ";//错误写法，编译报错++it;
}

因为map的每个元素是键值对，由key和value组成，即pair，而且它们的类型不一定相同，所以要用 . 或者 -> 指向对应的成员

map<string, string> m;
m.insert(pair<string, string>("sort", "排序"));
m.insert(pair<string, string>("sort", "排序"));
m.insert(pair<string, string>("sort", "排序"));
m.insert(pair<string, string>("apple", "苹果"));
m.insert(pair<string, string>("left", "左边"));
map<string, string>::iterator it = m.begin();
while (it != m.end())
{//cout << (*it).first << "：" << (*it).second << endl;cout << it->first << "：" << it->second << endl;++it;
}

2️⃣rbegin和rend
反向遍历

map<string, string>::reverse_iterator rit = m.rbegin();
while (rit != m.rend())
{//cout << (*rit).first << "：" << (*rit).second << endl;cout << rit->first << "：" << rit->second << endl;++rit;
}

3.3.4 容量

1️⃣empty
检测map中的元素是否为空，是返回true，否则返回false

map<string, string> m;
cout << m.empty() << endl;//1

2️⃣size
返回map中有效元素的个数

m.insert(pair<string, string>("left", "左边"));
cout << m.size() << endl;//1

3.3.5 修改操作

1️⃣insert

pair<iterator,bool> insert ( const value_type& x )

在map中插入的是键值对，返回值也是键值对，如果插入成功，则返回当前元素(键值对)的位置和true，插入失败，则返回原来已有的元素的位置和false

插入的方式有三种写法：

map<string, string> m;
m.insert(pair<string, string>("sort", "排序"));//C++98
m.insert(make_pair("apple", "苹果"));//C++98
m.insert({ "left", "左边" }); //C++11 多参数隐式类型转换

2️⃣erase
删除有3种方式，与set相同：

删除position位置上的元素

void erase ( iterator position )

map<string, string> m;
m.insert(make_pair("sort", "排序"));
m.insert(make_pair("apple", "苹果"));
m.insert(make_pair("left", "左边"));
for (auto& e : m)
{cout << e.first << "：" << e.second << " ";
}
cout << endl;
map<string, string>::iterator pos = m.begin();
m.erase(pos);
for (auto& e : m)
{cout << e.first << "：" << e.second << " ";
}

删除键值为x的元素

size_type erase ( const key_type& x )

m.erase("sort");

删除[first, last)区间中的元素

void erase ( iterator first, iterator last )

m.erase(m.begin(), m.end());

3️⃣swap
交换两个map中的元素

void swap ( map<Key,T,Compare,Allocator>& mp )

map<string, string> m1;
m1.insert(make_pair("sort", "排序"));
m1.insert(make_pair("apple", "苹果"));
for (auto& e : m1)
{cout << e.first << "：" << e.second << " ";
}
map<string, string> m2;
m2.insert(make_pair("left", "左边"));
m2.insert(make_pair("right", "右边"));
for (auto& e : m2)
{cout << e.first << "：" << e.second << " ";
}
m2.swap(m1);
for (auto& e : m1)
{cout << e.first << "：" << e.second << " ";
}
for (auto& e : m2)
{cout << e.first << "：" << e.second << " ";
}

4️⃣clear
将map中的元素清空

void clear ( )

map<string, string> m;
m.insert(make_pair("sort", "排序"));
m.clear();
cout << m.empty() << endl;//1

5️⃣find
查找key为x的元素，找到了返回该元素的迭代器，找不到返回end

iterator find ( const key_type& x )

map<string, string> m;
m.insert(make_pair("sort", "排序"));
map<string, string>::iterator pos = m.find("sort");
if (pos != m.end())cout << "找到了" << endl;//找到了
elsecout << "没找到" << endl;

6️⃣count
返回key为x在map中的个数，由于map会去重，所以存在返回1，不存在返回0

size_type count ( const key_type& x ) const

map<string, string> m;
m.insert(make_pair("sort", "排序"));
m.insert(make_pair("sort", "排序"));
cout << m.count("sort") << endl;//1
cout << m.count("apple") << endl;//0

3.3.6 operator[]

mapped_type& operator[] (const key_type& k);

该函数的参数是key，返回值是value。可以用来插入、查找、修改和计数。先来看看使用：

1️⃣插入：如果key没有重复，插入成功

map<string, string> m;
m.insert(make_pair("sort", "排序"));
m["left"];//插入
for (auto& e : m)
{cout << e.first << "：" << e.second << endl;
}

2️⃣查找：插入的key已经存在，查找到该key对应的value

map<string, string> m;
m.insert(make_pair("sort", "排序"));
m.insert(make_pair("apple", "苹果"));
cout << m["apple"] << endl;//苹果

3️⃣修改：插入的key已经存在，同时右边如下代码所示，将该key对应的value修改

map<string, string> m;
m.insert(make_pair("sort", "排序"));
m.insert(make_pair("apple", "苹果"));
m["sort"] = "排序的英文";
for (auto& e : m)
{cout << e.first << "：" << e.second << endl;
}

4️⃣插入+修改：插入key没有重复，且右边如下代码所示，修改对应的value(其实是补上)

map<string, string> m;
m.insert(make_pair("sort", "排序"));
m.insert(make_pair("apple", "苹果"));
m["left"] = "左边";
for (auto& e : m)
{cout << e.first << "：" << e.second << endl;
}

5️⃣统计次数

map<string, int> m;
string arr[] = { "sort","sort" ,"apple" ,"apple", "banana","one" };
for (auto& e : arr)
{m[e]++;
}
for (auto& e : m)
{cout << e.first << "：" << e.second << " ";cout << endl;
}

接下来看看operator[]是如何实现以上操作的：

operator[]内部其实调用了insert函数

我们再来看看insert函数：

回顾下，insert函数的要插入的数据类型是键值对

它的返回类型也是键值对，operator[]调用insert函数得到的返回值是迭代器，对迭代器解引用然后点访问迭代器的第二个成员，最后返回该成员。

梳理下：
首先看operator[]调用insert函数，而insert里面的make_pair是(k, mapped_type())，也就是说key值是要输入的，而value我们不写编译器帮我们默认构造出来，int类型是0。接着insert函数就要返回了，返回的是键值对，插入成功，返回该位置的迭代器和true；插入失败，返回该位置的迭代器和false。.first，得到返回值的第一个成员，即迭代器。迭代器的本质是指针，指针指向的是该位置的key和对应的value，解引用指针，然后最后的 .second 得到是该迭代器的value，即插入的key对应的value

3.4 multimap

multimap与map的区别和multiset与set的区别相同，都能形成有序，但是multimap可以允许元素重复

multimap<string, string> m;
m.insert(make_pair("sort", "排序"));
m.insert(make_pair("sort", "排序"));
m.insert(make_pair("left", "左边"));
m.insert(make_pair("sort", "排序"));
m.insert(make_pair("apple", "苹果"));
m.insert(make_pair("apple", "苹果"));
for (auto& e : m)
{cout << e.first << "：" << e.second << " ";cout << endl;
}

还有find和count:

map的find与multimap的find
map返回该元素的迭代器，multimap返回该元素的第一个的迭代器

multimap<string, string> m;
m.insert(make_pair("sort", "排序"));
m.insert(make_pair("sort", "排序"));
m.insert(make_pair("apple", "苹果"));
multimap<string, string>::iterator pos = m.find("sort");
while (pos != m.end())
{cout << pos->first << "：" << pos->second << endl;++pos;
}

map的count与multimap的count
map没有重复元素，所以该元素存在返回1，不存在返回0；multimap可以有重复元素，存在返回该元素的个数，不存在返回0

multimap<string, string> m;
m.insert(make_pair("sort", "排序"));
m.insert(make_pair("sort", "排序"));
m.insert(make_pair("apple", "苹果"));
cout << m.count("sort") << endl;//2
cout << m.count("apple") << endl;//1
cout << m.count("left") << endl;//0