【STL】set和map

logn_sort

已于 2023-07-01 11:03:30 修改

阅读量142

点赞数 1

文章标签： c++

于 2023-05-28 17:12:30 首次发布

本文链接：https://blog.csdn.net/weixin_54994444/article/details/130914184

版权

本文介绍了C++中集合set的基本操作，如插入、删除元素，以及去重功能。接着讲解了多重集合multiset，允许元素重复，并展示了如何使用find和erase函数进行特定操作。最后，文章讨论了映射表map，用于存储键值对，提供了访问和修改元素的方法，以及count函数的用途。所有这些容器的时间复杂度也进行了说明。

摘要由CSDN通过智能技术生成

STL Y Y D S ！

集合 set

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

我们用 insert 函数向集合中插入一个新的元素，如果集合中已经存在了某个元素，再次插入不会产生任何效果，集合中不会出现重复元素；所以 set 也可以帮助我们完成去重操作。
insert 函数的时间复杂度为 $\ 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 函数的时间复杂度为 $\ 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\}$ 。姓名与班级之间可以有如下的映射关系： $c l a ss (" T o m ") = 1$ ， $c l a ss (" J o n e ") = 2$ ， $c l a ss (" M a ry ") = 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;
}