【STL】set和map

STL Y Y D S ！

集合 set

把相同类型的元素堆在一起（想堆多少就堆多少），这一堆东西就是一个“集合”
我们这样构造一个集合：set<T> s; 这样我们定义了一个名为 $s$ 的、储存 $T$

我们用 insert 函数向集合中插入一个新的元素，如果集合中已经存在了某个元素，再次插入不会产生任何效果，集合中不会出现重复元素；所以 set 也可以帮助我们完成去重操作。
insert 函数的时间复杂度为 $O(log \ n)$

#include <set>
#include <string>
using namespace std;
int main() {
    set<string> country;
    // {} 集为空
    country.insert("China");
    // {"China"} 插入一个"China"的元素
    country.insert("America");
    // {"China", "America"} 插入一个"America"的元素
    country.insert("France");
    // {"China", "America", "France"} 插入一个"France"的元素
    country.insert("China");
    // {"China", "America", "France"} 再次插入"China"不会添加到集合中
    return 0;
}

我们通过 erase 函数删除集合中的一个元素，如果集合中不存在这个元素，也不会进行任何操作。
erase 函数的时间复杂度为 $O(log \ n)$

#include <set>
#include <string>
using namespace std;
int main() {
    set<string> country; 
    // {} 集为空
    country.insert("China");
    // {"China"} 删除一个"China"的元素
    country.insert("America");
    // {"China", "America"} 删除一个"America"的元素
    country.insert("France");
    // {"China", "America", "France"} 删除一个"France"的元素
    country.erase("America");
    // {"China", "France"} 删除一个"America"的元素,由于（操作后的）集合内没有此元素，所以没有任何作用。
    country.erase("England"); 
    // {"China", "France"} 与上面同理
    return 0;
}

如果我们想知道元素个数，需要使用 size 函数，相信这个函数大家都很熟悉。没错！这个函数与看字符串长度，看 vector 中的元素数量是一模一样的。
size 函数的时间复杂度为 $O(1)$

我们用 clear 函数就可以清空 set，同时会清空 set 占用的内存。
clear 函数的时间复杂度为 $O(n)$

多重集合 multiset

刚才我们说过，在一个集合中，相同的元素只能出现一次，因此只能显示出有或无的属性。而在多重集合之中，同一个元素可以出现多次。比如 $\{1,1,1,2,2,3\}$

在C++中，多重集合为 multiset ，同样是在头文件 <set> 中定义，其实它就是一个可以装重复元素的 set ，所以基本的函数都是一样的，我们不再重复叙述。

下面来看一个具体的例子：

multiset<int> ms;
//初始时集合为空{}
ms.insert(5);
//插入元素5 {5}
ms.insert(4);
//插入元素4 {4, 5}
ms.insert(5);
//插入元素5 {4, 5, 5}
ms.insert(7);
//插入元素7 {4, 5, 5, 7}
ms.erase(3);
//删除元素3 {4, 5, 5, 7}
ms.erase(4);
//删除元素4 {5, 5, 7}
ms.erase(5);
//删除元素5 {7}

我们定义了一个存放 int 类型元素的多重集合 ms ，刚开始的时候为空。然后插入了 $4$ 个元素，当前多重集合为 $\{4, 5, 5, 7\}$

后面有三个删除操作，第一个删除的元素是 $3$ ，它在 ms 中并不存在，因此不会有任何变化（也不会出错）。第二个要删除的数是 $4$ ，删完后 ms 中只剩下 $\{5, 5, 7\}$ 。第三个要删除的数是 $5$ ，它在 ms 中出现两次， erase 函数会把这两个 $5$ 都从集合中删去，因此最后集合变为 $\{7\}$ ；注意这里， multiset 直接 erase 一个元素是把集合中这个元素全部都删掉。

那么问题来了，在有多个重复的数情况下，我们如何只从 multiset 里删除其中的一个数呢？这里要先介绍一个之前没有说的成员函数 find 。

find(x) 返回指向第一个值为 $x$ 的元素的迭代器，若 $x$

multiset<int> ms;
//初始时集合为空 {}
ms.insert(5);
//插入元素5 {5}
ms.insert(4);
//插入元素4 {4, 5}
ms.insert(5);
//插入元素5 {4, 5, 5}
ms.insert(7);
//插入元素7 {4, 5, 5, 7}
multiset<int>::iterator it;
it = ms.find(5);
//it指向第一个5的位置
cout << *it << endl;
//输出5
it = ms.find(6);
//此时 it 为尾后迭代器 ms.end()

因为有不存在的情况，所以使用 find 函数的时候，我们经常需要特判。

if (ms.find(x) != ms.end()) {//找得到的情况

} else {//找不到的情况

}

之前用的 erase 函数，它的参数是和容器内元素类型一样的，其实他还有别的版本：参数可以是一个迭代器。就是我们瞄准一个位置进行删除。
我们可以利用 find 函数来得到指向相应位置的迭代器，这样我们就可以只删除一个元素了。

multiset<int> ms;
//初始时集合为空 {}
ms.insert(5);
//插入元素5 {5}
ms.insert(4); 
//插入元素4 {4, 5}
ms.insert(5);
//插入元素5 {4, 5, 5}
ms.insert(7);
//插入元素7 {4, 5, 5, 7}
ms.erase(ms.find(5)); 
//删除第一个元素5 {4, 5, 7}

不可以删除尾后迭代器，否则程序会出错。

所以在进行删除的时候，如果不确定这个元素是否存在，一定加上判断。

映射表 map

map 可以当作特殊的数组来使用，在数组开不下，或者数组下标不是整数的时候使用 map 就很方便，比如统计字符串的出现个数，统计 int 范围内的数的出现次数等等。
映射是指两个集合之间的元素的相互对应关系。就是一个元素对应另外一个元素。
打个比方说有一个姓名的集合$\{"Tom", "Jone", "Mary"\}$，班级集合$\{1,2\}$。姓名与班级之间可以有如下的映射关系：$class("Tom")=1$，$class("Jone")=2$，$class("Mary") =1$

我们称其中的姓名集合为关键字集合（key），班级集合为值集合（value）。

构造一个 map ：map<T1, T2> m ;
定义了一个名为的从T1类型到T2类型的映射。
访问 map 的某一个位置和改变 map 某一个位置的数据的操作与数组一样，直接用 [] 就能访问或更改值了。
所以咱们也可以把 map 看成是一种特殊数组，下标可以不为整数的数组。

#include <iostream>
#include <map>
#include <string>
using namespace std;
int main() {
    map<string, int> dict;  
    //dict是一个string到int的映射，存放每个名字对应的班级号，初始时为空
    dict["Tom"] = 1;   
    // {"Tom"->1}
    dict["Jone"] = 2;  
    // {"Tom"->1, "Jone"->2}
    dict["Mary"] = 1;  
    // {"Tom"->1, "Jone"->2, "Mary"->1}
    cout << "Mary is in class " << dict["Mary"] << endl;
    cout << "Tom is in class " << dict["Tom"] << endl;
    return 0;
}

直接访问 map 中的一个位置，时间复杂度为 $O(log⁡\ n)$。

不过我们如果用刚才的方法访问 map 会有一个很神奇的事情。（啊先卖个关子…）
如果我们在访问 dict[Tom] 的时候，map 内部还没有 "Tom" 这个下标的话，系统会自动给 "Tom" 生成一个映射，其 value 为对应类型的默认值也就是它自动会完成(这里以string类型举例)dict[Tom] = ""; 这句话。
但是我们一般都不需要系统这么做，我们想知道 "Tom" 这个 key 是否在 map 里存在；这时就可以借助 count 函数进行判断。
如果这个 key 存在会返回 $1$ ；否则会返回 $0$

#include <iostream>
#include <map>
#include <string>
using namespace std;
int main() {
    map<string, int> dict;  // {}
    dict["Tom"] = 1;        // {"Tom"->1}
    dict["Jone"] = 2;       // {"Tom"->1, "Jone"->2}
    dict["Mary"] = 1;       // {"Tom"->1, "Jone"->2, "Mary"->1}
    if (dict.count("Mary")) {
        cout << "Mary is in class " << dict["Mary"] << endl;
    } else {
        cout << "Mary has no class" << endl;
    }
    return 0;
}

map 的迭代器的定义和 set 差不多：map<T1, T2>::iterator it 这样就定义了一个迭代器，其中 T1 , T2 分别是 key 和 value 的类型。

C++通过迭代器可以访问集合中的每个元素。这里迭代器指向的元素是一个 pair ； pair 可以看作是一个有两个成员变量 first 和 second 的结构体，排序方法默认为先比较 first，first小的算小，first 一样就比较 second，second 小的算小。在 map 里每一个 pair 的 first 和 second 分别代表一个映射的 key 和 value 。

我们用->（捡大鱼 指向的）运算符来获取值，it->first 和 (*it).first 的效果一样，就是获取迭代器 it 指向的 pair 里 first 成员的值。

#include <iostream>
#include <map>
#include <string>
using namespace std;
int main() {
    map<string, int> dict;
    // {}
    dict["Tom"] = 1;
    // {"Tom"->1}
    dict["Jone"] = 2;
    // {"Tom"->1, "Jone"->2}
    dict["Mary"] = 1;
    // {"Tom"->1, "Jone"->2, "Mary"->1}
    for (map<string, int>::iterator it = dict.begin(); it != dict.end(); it++) {
        cout << it->first << " -> " << it->second << endl;
        // first 是关键字， second 是对应的值
    }
    return 0;
}