C++：map和set

最新推荐文章于 2024-08-09 10:25:03 发布

Sherry_iyao

最新推荐文章于 2024-08-09 10:25:03 发布

阅读量1k

点赞数 49

文章标签： c++ rpc 开发语言

本文链接：https://blog.csdn.net/2301_80153885/article/details/140774177

版权

hello，各位小伙伴，本篇文章跟大家一起学习《C++：map和set》，感谢大家对我上一篇的支持，如有什么问题，还请多多指教！
如果本篇文章对你有帮助，还请各位点点赞！！！
在这里插入图片描述
话不多说，开始正题：

关联式容器

STL中的部分容器如：vector、list、deque、forward_list(C++11)等称为序列式容器，因为其底层为线性序列的数据结构，里面存储的是元素本身。

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

键值对

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

就比如英汉字典：英文单词为key，对应的中文就是value。

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

树形结构的关联式容器

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

🍃set

🔥set的介绍

set是按照一定次序存储元素的容器
在set中，元素的value也标识它(value就是key，类型为T)，并且每个value必须是唯一的。
set中的元素不能在容器中修改(元素总是const)，但是可以从容器中插入或删除它们。
在内部，set中的元素总是按照其内部比较对象(类型比较)所指示的特定严格弱排序准则进行排序。
set容器通过key访问单个元素的速度通常比unordered_set容器慢，但它们允许根据顺序对子集进行直接迭代。
set在底层是用二叉搜索树(红黑树)实现的。

注意：

与map/multimap不同，map/multimap中存储的是真正的键值对<key, value>，set中只放value，但在底层实际存放的是由<value, value>构成的键值对。
set中插入元素时，只需要插入value即可，不需要构造键值对。
set中的元素不可以重复(因此可以使用set进行去重)。
使用set的迭代器遍历set中的元素，可以得到有序序列
set中的元素默认按照小于来比较
set中查找某个元素，时间复杂度为： $log_2 n$
set中的元素不允许修改(为什么?)
set中的底层使用二叉搜索树(红黑树)来实现。

关于7问题：在红黑树中结点的值是不允许修改的，一旦修改了，就不符合搜索二叉树的规则，也就不再是搜索二叉树。

🔥set的使用

在这里插入图片描述

可以看到class T实际上就是set::key_type/value_type构成键值对。
Compare：set中元素默认按照小于来比较。
Alloc：set中元素空间的管理方式，使用STL提供的空间配置器管理。

关于set的成员函数可查看官网cplusplus—set

🔥set的使用

#include <set>
void TestSet()
{
	 // 用数组array中的元素构造set
	 int array[] = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 0, 1, 3, 5, 7, 9, 2, 4, 6, 8, 0 };
	 set<int> s(array, array+sizeof(array)/sizeof(array));
	 cout << s.size() << endl;
	 
	 // 正向打印set中的元素，从打印结果中可以看出：set可去重
	 for (auto& e : s)
	 cout << e << " ";
	 cout << endl;
	 
	 // 使用迭代器逆向打印set中的元素
	 for (auto it = s.rbegin(); it != s.rend(); ++it)
	 cout << *it << " ";
	 cout << endl;
	 
	 // set中值为3的元素出现了几次
	 cout << s.count(3) << endl;
}

🍃map

map的介绍

map是关联容器，它按照特定的次序(按照key来比较)存储由键值key和值value组合而成的元素。
在map中，键值key通常用于排序和惟一地标识元素，而值value中存储与此键值key关联的内容。键值key和值value的类型可能不同，并且在map的内部，key与value通过成员类型value_type绑定在一起，为其取别名称为pair:
typedef pair<const key, T> value_type;
在内部，map中的元素总是按照键值key进行比较排序的。
map中通过键值访问单个元素的速度通常比unordered_map容器慢，但map允许根据顺序对元素进行直接迭代(即对map中的元素进行迭代时，可以得到一个有序的序列)。
map支持下标访问符，即在[]中放入key，就可以找到与key对应的value。
map通常被实现为二叉搜索树(更准确的说：平衡二叉搜索树(红黑树))。

🔥map的使用

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

关于map的成员函数可查看官网cplusplus—map

🔥operator[]
在这里插入图片描述

(*((this->insert(make_pair(k,mapped_type()))).first)).second

对于这代码的解释：
在元素访问时，有一个与operator[]类似的操作at()(该函数不常用)函数，都是通过key找到与key对应的value然后返回其引用，不同的是：当key不存在时，operator[]用默认value与key构造键值对然后插入，返回该默认value，at()函数直接抛异常。

详细解释：

这段表达式 (((this->insert(make_pair(k,mapped_type()))).first)).second 是比较复杂的 C++ 表达式，涉及到了 std::set 的 insert 操作和对返回值的解析。
让我们逐步解释这个表达式：
1.make_pair(k, mapped_type()):
2.make_pair 是一个 C++ 标准库函数模板，用于创建一个 std::pair 对象。在这里，它用来创建一个键值对，其中键是 k，值是 mapped_type() 的默认构造值。mapped_type() 是 std::set 中存储的值类型的默认构造值。
3.this->insert(make_pair(k, mapped_type())):
4.this 是指向当前对象的指针或引用。insert 是 std::set 的成员函数，用于将一个键值对插入到集合中。insert 返回一个 std::pair 对象，其中 .first 是一个迭代器，指向插入的元素或已存在的相同键的元素，.second 是一个布尔值，表示插入是否成功。
5.this->insert(make_pair(k, mapped_type())).first:
6.这部分代码提取了 insert 返回的 std::pair 对象的 .first 成员，即一个迭代器。这个迭代器指向 std::set 中插入的元素或已经存在的元素。
7.(((this->insert(make_pair(k, mapped_type()))).first)):
8.通过 () 运算符对 .first 返回的迭代器进行解引用操作，得到 std::set 中的元素。因为 std::set 是有序的，插入后元素会按照键的顺序排列。
9.(((this->insert(make_pair(k, mapped_type()))).first)).second:
10.最后，再次使用 ().second 来访问 std::pair 中的 .second 成员。在 std::set 的情况下，.second 成员是集合中元素的值部分，即 mapped_type 类型的对象。
综上所述，(((this->insert(make_pair(k, mapped_type()))).first)).second 的含义是：
11.将键值对 (k, mapped_type()) 插入到当前 std::set 对象中。
12.获取这个插入操作返回的迭代器，解引用该迭代器，得到 std::set 中的元素。
13.访问这个元素的值部分，即 mapped_type 类型的对象。
这段代码的目的通常是在 std::set 中插入一个新的键值对，并立即访问或修改插入的元素的值。

🔥map中元素的修改

map<string, string> dict;
dict.insert({ "sort", "排序" });
dict.insert({ "left", "左边" });
dict.insert({ "right", "右边" });

dict["left"] = "左边，剩余";
dict["insert"] = "插入";
dict["string"];

当["key"]不存在时，会直接插入["key"]元素，若存在，则返回value，可以对其修改，如：

dict["insert"] = "插入";
dict.insert({ "left", "左边" });
dict["left"] = "左边，剩余";

["insert"]不存在，直接插入
将left的valuve修改为左边，剩余

map中的的元素是键值对
map中的key是唯一的，并且不能修改
默认按照小于的方式对key进行比较
map中的元素如果用迭代器去遍历，可以得到一个有序的序列
map的底层为平衡搜索树(红黑树)，查找效率比较高 $O(log_2 N)$
支持[]操作符，operator[]中实际进行插入查找。

例题

来自力扣前K个高频单词

class Solution {
public:
    vector<string> topKFrequent(vector<string>& words, int k) {

    }
};

答案：

class Solution {
public:
    struct comp
    {
        bool operator()(pair<string,int> m1,pair<string,int> m2)
        {
            return (m1.second > m2.second || (m1.second == m2.second && m2.first > m1.first));
        }
    };

    vector<string> topKFrequent(vector<string>& words, int k) {
        map<string,int> m;
        for(auto& e : words)
        {
            m[e]++;
        }

        vector<pair<string,int>> v(m.begin(),m.end());
        sort(v.begin(),v.end(),comp());
        vector<string> res;
        for(int i = 0; i < k;++i)
        {
            res.push_back(v[i].first);
        }

        return res;
    }
};

来自力扣两个数组的交集

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
    
    }
};

答案：

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        set<int> s1;
        set<int> s2;
        vector<int> v1;
        vector<int> res;
        for(auto& e : nums1)// 去重操作
        {
            if(s1.insert(e).second)
            {
                v1.push_back(e);
            }
        }
        for(auto& e : nums2)// 去重操作
        {
            s2.insert(e);
        }
        for(auto& e : v1)
        {
            if(!s2.insert(e).second)
            res.push_back(e);
        }

        return res;

    }
};