STL库：map和set

STL库：map和set

---

1.STL库中set的官方介绍

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

---

2.set的常用接口

2.1 set的迭代器

1. begin()：返回指向set中第一个元素的迭代器
2. end()：返回指向set中最后一个元素后面的迭代器

2.2 set的修改操作

1. insert()：Insert element（插入元素）
2. erase()：Erase elements（删除元素）

2.3 set的查询操作

1. 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的元素
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

---

3.set的总结

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

核心关键：set排序+去重，只放value，底层是红黑树(平衡二叉搜索树)

---

4.STL库中multiset的官方介绍

1. multiset 的使用和 set 几乎一样，它们之间的区别就是：set 是不允许数据冗余的，而 multiset 允许数据冗余，可以有多个相同值的元素
2. 注意：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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

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

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

---

5.STL库中map的官方介绍

1. key：键值对中 key 的类型
2. T： 键值对中 value 的类型
3. Compare：比较器的类型，map中的元素是按照 key 来比较的，缺省情况下按照小于 ( < 升序) 来比较，一般情况下(内置类型元素)该参数不需要传递，如果无法比较时(比如自定义类型)，需要用户自己显式传递比较规则(一般情况下按照函数指针或者仿函数来传递)
   • 小于（< 升序），less
   • 大于（> 降序），定义map时模板参数中要写上 greater
4. Alloc：通过空间配置器来申请底层空间，不需要用户传递，除非用户不想使用标准库提供的空间配置器
5. 在使用map时，需要包含头文件 #include
6. 核心：map的所有操作都是通过查找匹配元素的键 key 来完成的，和其对应映射值 value 无关。因为 map 不允许数据冗余，所以每个元素的 key 值是唯一的

---

6.map中的键值对pair

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) {} // 拷贝构造函数
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14

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

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

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

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

---

7.map的常用接口

7.1 map的访问操作

1. operator[]：Access element（访问元素）
2. at(C++11)： Access element（访问元素）
3. map::at在元素存在时和map::operator[]具有相同的行为，区别在于，当元素不存在时，map::at会抛出异常

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，我们可以对其修改
4. operator[]非常强大，既有查找功能，也有插入功能，还可以修改

map<string, string> dict;

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

// 等价于：
dict["tree"];        // 插入pair("string", "")
dict["tree"] = "树"; // "tree"已存在，修改了"tree"对应的value值为"树"
1
2
3
4
5
6
7
8
9

---

7.2 map的修改操作

1. insert()：Insert element（插入元素）
2. erase()： Erase elements（删除元素）

pair<iterator,bool> insert (const value_type& val);//函数原型
1

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

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

使用举例：

//实现一个字典 – 可通过单词查找到对应的中文含义
//定义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++;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

---

7.3 map的查找操作

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

使用举例：

//统计单词出现的次数
//定义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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

上述解法，先查找当前单词是否在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;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

第三种解法：使用 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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

---

8.map的总结

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;
   1

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

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

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

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

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

---

9.STL库中multimap的官方介绍

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

• map 是不允许数据冗余的，而 multimap 允许数据冗余，可以有多个相同 key 值的元素
• multimap中没有重载 operator[] 操作符（有歧义，有多个相同 key，到底返回哪个 key 的映射值 value 不清楚）