【C++ - STL】set、map、multiset、multimap 容器（介绍、使用、应用场景）

前言

序列式容器，比如：vector、list、deque、forward_list(C++11)等，其底层为线性序列的数据结构，里面存储的是元素本身。那什么是关联式容器？它与序列式容器有什么区别？

关联式容器也是用来存储数据的，与序列式容器不同的是，其里面存储的是 结构的键值对，在数据检索时比序列式容器效率更高。

• 根据应用场景的不同，STL总共实现了两种不同结构的关联式容器：「树型结构」与「哈希结构」。

• 树型结构的关联式容器主要有四种：map、set、multimap、multiset。这四种容器的共同点是：使用平衡二叉搜索树(即红黑树)作为其底层结构，容器中的元素是一个有序的序列。

---

一、set（集合）

1.1 set容器介绍

官方文档：set - C++ Reference (cplusplus.com)

set的模板参数列表：

参数解释：

• T：set中存放元素的类型，实际在底层存储的是 键值对。
• Compare：比较器的类型，set中元素默认按照小于（< 升序）来比较。一般情况下(内置类型元素)该参数不需要传递，如果无法比较时(比如自定义类型)，需要用户自己显式传递比较规则(一般情况下按照函数指针或者仿函数来传递)
  • 小于（< 升序），less
  • 大于（> 降序），定义set时模板参数中要写上 greater
• Alloc：set中元素空间的管理方式，使用STL提供的空间配置器管理。
• 使用set时，需要包含头文件 #include。

---

1.2 set的使用

① set的常用接口

set的迭代器：

Iterators:
begin	返回指向set中第一个元素的迭代器
end	返回指向set中最后一个元素后面的迭代器

set的修改：

Modifiers:
insert	Insert element（插入元素）
erase	Erase elements（删除元素）

set的操作：

Operations:
find	如果找到，则返回该元素的迭代器，否则返回set::end的迭代器。

---

② 使用举例

void test_set1()
{
	// 用数组array中的元素构造set
	int array[] = { 1, 3, 5, 4, 2 };
	set<int> s(array, array + sizeof(array) / sizeof(array[0]));

	s.insert(4); // 4已经在set中了，不会插入

	cout << s.size() << endl; // 获取set元素个数

	// 迭代器遍历set
	set<int>::iterator it = s.begin();
	while (it != s.end())
	{
		cout << *it << " ";
		it++;
	}
	cout << endl;

	// 两种查找元素方式：
    // 1、algorithm文件中的find函数，底层是暴力查找，全部节点遍历一遍，效率低，O(N)
    // auto ret = find(s.begin(), s.end(), 4); 
    
    // 2、set的成员函数，代价为：O(logN)
	auto ret = s.find(4); 
    
	// 这里需要判断一下，若找到，返回该元素的迭代器，若没有找到，返回s中最后一个元素后面的迭代器
	if (ret != s.end())
	{
		s.erase(ret); // 删除元素方式1，删除迭代器ret指向的元素
	}
	s.erase(5); // 删除元素方式2：删除值为5的元素
}

排序+去重

set 是不允许数据冗余的，使用 set 迭代器遍历 set 中的元素，可以得到一个有序序列，这样就达到了对一对数据排序+去重的效果。

---

1.3 总结

1. 与 map/multimap 不同，map/multimap 中存储的是真正的键值对，而 set 中只放 value，但在底层实际存放的是由 构成的键值对。
2. set 中插入元素时，只需要插入 value 即可，不需要构造键值对。
3. set 中的元素不可以重复（因此可以使用 set 进行去重）
4. 使用 set 的迭代器遍历 set 中的元素，可以得到有序序列。
5. set 中的元素默认按照小于来比较。
6. set 中查找某个元素，时间复杂度为：O(log₂N)，set 中增删查改都是O(log₂N)
7. set 中的元素不允许修改。因为set要保证其有序，因此set中元素不能被直接修改，若要修改可以先删除，在插入
8. set 中的底层是使用平衡二叉搜索树(红黑树)来实现。

---

二、multiset

multiset 的使用和 set 几乎一样，它们之间的区别就是：

set 是不允许数据冗余的，而 multiset 允许数据冗余，可以有多个相同值的元素。

注意：multiset 中 find() 查找一个值，比如查找4，找到第一个4以后，不能停止，要继续查找到中序的第一个4，即找到第一个4以后，要继续看它的左孩子是不是4，如果不是，就返回当前这个4；如果是，则走到左孩子这个4，继续往下遍历和判断。

使用举例：

multiset<int> s;
s.insert(4);
s.insert(3);
s.insert(5);
s.insert(4);
s.insert(6);
s.insert(4);
s.insert(2);

// 遍历multiset
for (auto e : s)
{
    cout << e << " ";
}
cout << endl;

// 运行结果：2 3 4 4 4 5 6

如果想要查看容器中，某个值为key的元素有多少个，可以用 count() 接口：

cout << s.count(4) << endl; // 运行结果：3
cout << s.count(3) << endl; // 运行结果：1

---

三、map（映射）

3.1 map容器介绍

官方文档：map - C++ Reference (cplusplus.com)

map的模板参数列表：

参数解释：

• key：键值对中 key 的类型
• T： 键值对中 value 的类型
• Compare：比较器的类型，map中的元素是按照 key 来比较的，缺省情况下按照小于 ( < 升序) 来比较，一般情况下(内置类型元素)该参数不需要传递，如果无法比较时(比如自定义类型)，需要用户自己显式传递比较规则(一般情况下按照函数指针或者仿函数来传递)
  • 小于（< 升序），less
  • 大于（> 降序），定义map时模板参数中要写上 greater
• Alloc：通过空间配置器来申请底层空间，不需要用户传递，除非用户不想使用标准库提供的空间配置器
• 在使用map时，需要包含头文件 #include。

---

3.2 键值对 - pair（⭐核心 - 非常重要）

用来表示具有一一对应关系的一种结构，该结构中一般只包含两个成员变量 key 和 value，key 代表键值，value 表示与 key 对应的信息。

SGI-STL中关于 键值对 的定义：map中存放的元素是一个个的键值对（即 pair 对象）。

// map中存的是一个pair结构体，key和value被封装在里面
template <class T1, class T2>
struct pair
{
    typedef T1 first_type;  // 键值对中key的类型
    typedef T2 second_type; // 键值对中value的类型
    
    T1 first;  // first相当于key
    T2 second; // second相当于value

    pair(): first(T1()), second(T2()) {} // 构造函数
    
    pair(const T1& a, const T2& b): first(a), second(b) {} // 拷贝构造函数
};

构造一个pair对象(键值对)：

std::pair<int, int> p(10, 20);

利用 make_pair 函数模板构造一个pair对象(键值对)，通过传递给make_pair的参数隐式推导出来。

std::pair<int,int> p = std::make_pair(10,20); // 常用这种构造方式

---

3.3 map的使用

核心：map的所有操作都是通过查找匹配元素的键 key 来完成的，和其对应映射值 value 无关。因为 map 不允许数据冗余，所以每个元素的 key 值是唯一的。

① map的常用接口

map的迭代器，和 set 类似，只不过map迭代器指向的元素是一个pair对象

map的访问：

Element access:
operator[ ]	Access element（访问元素）
at (C++11)	Access element（访问元素）

---

1、operator[] 函数介绍（⭐）

前面学习的 vector 容器里面的 vector::operator[] 是传入元素下标，返回对该元素的引用。

而 map 中的 operator[] 访问元素函数，和其它容器有挺大区别的，已经不是传统的数组下标访问了：

operator[] 底层实际上调用的 insert() 函数。

map容器中的 map::operator[] 是传入键值 key，通过该元素的 key 查找并判断是否在 map 中：

1. 如果在 map 中，说明 insert 插入失败，insert函数返回的 pair 对象会带出指向该元素的迭代器，通过这个迭代器，我们可以拿到该元素 key 对应的映射值 value，然后函数返回其对应映射值 value 的引用。

2. 如果不在 map 中，说明 insert 插入成功，插入了这个新元素 < key, value() >，然后函数返回其对应映射值 value 的引用。

3. 注意：这里插入新元素时，该 value() 是一个缺省值，是调用 value 类型的默认构造函数构造的一个匿名对象。（比如是 string 类型就调用 string 的默认构造）

【operator[ ] 总结】

使用 map::operator[] 函数，传入元素的键值 key：

1. 如果 key 在map中，返回 key 对应映射值 value 的引用。
2. 如果 key 不在map中，插入该元素 < key, value() >，返回 key 对应映射值 value 的引用。
3. 拿到函数返回的映射值 value，我们可以对其修改。

这个函数非常的强大，即有查找功能，也有插入功能，还可以修改。

举例说明：

map<string, string> dict;

// 这里的意思是，先插入pair("tree", "")，再修改"tree"对应的value值为"树"
dict["tree"] = "树";

// 等价于：
dict["tree"];        // 插入pair("string", "")
dict["tree"] = "树"; // "tree"已存在，修改了"tree"对应的value值为"树"

---

【补充】

类似的成员函数 map::at 在元素存在时和 map::operator[] 具有相同的行为，区别在于，当元素不存在时 map::at 会抛出异常。

---

map的修改：

Modifiers:
insert	Insert element（插入元素）
erase	Erase elements（删除元素）

2、insert 函数介绍（⭐）

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

功能：向 map 中插入元素(pair对象)时，先通过该元素的 key 查找并判断是否在 map 中：

• 如果在，返回一个 pair 对象：<指向该元素的迭代器, false>
• 如果不在，插入该元素，返回一个 pair 对象：<指向该元素的迭代器, true>

---

map的操作：

Operations:
find	如果找到具有指定键(key)的元素，则返回该元素的迭代器，否则返回map::end的迭代器。

---

② 使用举例

1、实现一个字典 – 可通过单词查找到对应的中文含义

定义map，向map中插入元素(键值对)，map有两种插入元素方式：一般用第二种

// 定义map
map<string, string> dict;

// 向map中插入元素，2种方式：
// 1、将键值对<"sort", "排序">插入map中，直接构造pair匿名对象(键值对)
dict.insert(pair<string, string>("sort", "排序"));

// 2、将键值对<"sort", "排序">插入map中，用make_pair函数来构造pair对象(键值对)
dict.insert(make_pair("left", "左边"));
dict.insert(make_pair("tree", "树"));

用迭代器遍历map元素：

需要注意的是，遍历map中元素的方式和其它迭代器有些不同，下面这种是错误示范：

// error：这里的it是指向当前元素的迭代器，解引用*it是一个pair对象(键值对)，而map中没有流插入运算符的重载，所以不能这样输出
map<string, string>::iterator it = dict.begin();
while (it != dict.end())
{
	/* 这里调用的是 it.operator*() 解引用运算符重载函数，
	* 所以 *it 只是得到了当前节点中存储 pair 结构体
	* key和value是一起封装在pair结构体中的，不能直接把key和value输出出来
	* 除非重载了专门针对输出 pair 结构体中数据的流插入运算符，比如：
	* ostream& operator<<(ostream& out, const pair& kv);
	*/
    // cout << *it << endl; // error!!!
    it++;
}

迭代器遍历map元素的两种方式：

// 迭代器遍历map
map<string, string>::iterator it = dict.begin();
while (it != dict.end())
{
    /* 两种遍历map中元素的方式：*/
    
    /* 1、
    * 迭代器是像指针一样的类型
    * 对当前元素的迭代器it解引用(*it)可以得到当前节点中存储的数据：即pair对象(键值对)，
    * 然后用'.'再去访问pair对象中的kv值
    * 这里调用的是it.operator*() 解引用运算符重载函数，返回值为：pair对象的引用
    */
    cout << (*it).first << ", " << (*it).second << endl;

    /* 2、
    * 迭代器箭头->，返回当前迭代器指向j的地址(指针)：pair*
    * 实际上是调用的operator->()函数
    * 该指针再使用'->'就可以取到(pair对象)里面的kv值，即first和second
	* 代码为：it->->first，但可读性太差，编译器进行了特殊处理，省略掉了一个箭头
	* 保持了程序的可读性
    */
    // 一般结构体的指针才会使用'->'来访问成员
    // 所以当迭代器管理的节点中的数据是结构体的时候，就可以用'->'
    cout << it->first << ", " << it->second << endl; // 常用这种写法

    it++;
}

遍历结果：

---

2、统计单词出现的次数

定义map，遍历str，向map中插入元素(键值对)：

string str[] = { "sort","sort", "tree","sort", "node", "tree","sort", "sort", };

// 定义map
map<string, int> Map;

// 遍历str
for (auto& e : str)  // 传引用，避免string深拷贝
{
    // 先查找判断当前单词是否已经在Map中了
    auto ret = Map.find(e);
    if (ret == Map.end()) // 如果不在Map中，返回Map中最后一个元素后面的迭代器
    {
        Map.insert(make_pair(e, 1)); // 插入pair对象(键值对)，即<单词，单词出现次数>
    }
    else // 如果在Map中，返回该元素的迭代器
    {
        ret->second++; // 单词出现的次数+1
    }
}

// 遍历map，这里的e是map的元素(即pair对象)，打印<单词，单词出现次数>
for (auto& e : Map)
{
    cout << e.first << ", " << e.second << endl;
}

上述解法，先查找当前单词是否在map中，如果不在，则插入，但是在插入函数内又会查找一次，找到插入的位置，有点冗余。

另外一种解法，插入元素时，insert本来就有查找功能：

void test_map()
{
	string str[] = { "sort","sort", "tree","sort", "node", "tree","sort", "sort", };
	
	// 定义map
	map<string, int> count_map;

	// 遍历str
	for (auto& e : str)
	{
		// 插入元素
		auto ret = count_map.insert(make_pair(e, 1));
		// insert返回值类型是：pair::iterator, bool>

		// 插入失败，说明该元素已存在于map中，函数返回一个pair对象
        // 即：pair<指向该元素的迭代器, false>
		if (ret.second == false)
		{
			(ret.first)->second++; // 对当前元素的value值加1
		}
	}

	// 遍历map，这里的e是map的元素(即pair对象)
	for (auto& e : count_map)
	{
		cout << e.first << ", " << e.second << endl;
	}
}

第三种解法：

使用 map::operator[] 函数根据当前元素的键值 key 查找，判断该元素是否在 map 中，如果在，返回其映射值 value 的引用，如果不在，当成新元素插入，并返回其映射值 value 的引用。

string str[] = { "sort","sort", "tree","sort", "node", "tree","sort", "sort", };

// 定义map
map<string, int> Map;

// 使用operator[]函数
// 若元素e存在，返回其对应映射值value，并加1
// 若元素e不存在，则插入，返回其对应映射值value，并加1
for (auto& e : str)
{
    Map[e]++;
}

// 遍历map，打印< 单词，单词出现次数 >
for (auto& e : Map)
{
    cout << e.first << ", " << e.second << endl;
}

运行结果：

---

3、对一堆数据去重

map不允许数据冗余，所以插入元素时，如果已存在相同key值的元素，则无法插入。可对一堆数据去重。

---

3.4 总结

1. map中的的元素是键值对(pair结构体)

2. map中的key是唯一的，并且不能修改，只能修改key对应的映射值value

3. 在map中，键值 key 通常用于排序和惟一地标识元素，键值 key 和值 value 的类型可能不同，在 map 的内部，key 与 value 通过成员类型 value_type 绑定在一起，为其取别名为 pair：

   typedef pair<const Key, T> value_type;
   

4. 默认按照小于的方式对 key 进行比较

5. map 中通过键值访问单个元素的速度通常比 unordered_map 容器慢，但 map 允许根据顺序对元素进行直接迭代（即==对map中的元素进行迭代时，可以得到一个有序的序列==）。

6. map支持 [] 操作符，operator[] 中实际是进行查找插入，即在 [] 中放入 key，就可以找到与 key 对应的 value。

7. map的底层为平衡二叉搜索树(红黑树)，查找效率比较高

---

四、multimap

multimap 的使用和 map 几乎一样，它们之间的区别就是：

• map 是不允许数据冗余的，而 multimap 允许数据冗余，可以有多个相同 key 值的元素。

• multimap中没有重载 operator[] 操作符（有歧义，有多个相同 key，到底返回哪个 key 的映射值 value 呢？）

---