C++ STL map和set的使用

介绍set和map之前，应该对二叉搜索树有一定的了解。
关于二叉搜索树的介绍：
二叉搜索树(BST)
set就是二叉搜索树应用场景的K模型，map就是二叉搜索树应用场景的KV模型

关联式容器

STL容器中的vector、list、deque等容器称为序列式容器，因为其底层为线性序列的数据结构，里面 存储的是元素本身。
关联式容器也是用来存储数据的，与序列式容器不同的是，其里面存储的是结构的 键值对，在数据检索时比序列式容器效率更高
C++ 容器包括序列式容器和关联式容器

• 序列式容器：序列式容器里面存储的是元素本身。比如ector、list、deque等容器。
• 关联式容器：关联式容器里面存储的是结构的键值对。在数据检索时比序列式容器效率更高。下面介绍的set和map都是关联式容器。

键值对pair

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

比如：现在要建立一个英汉互译的字典，那该字典中必然 有英文单词与其对应的中文含义，而且，英文单词与其中文含义是一一对应的关系，即通过该应 该单词，在词典中就可以找到与其对应的中文含义。

STL中对于键值对的定义

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

set

set的介绍

set文档

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

set的特性是所有的元素都会根据元素的键值(Key)自动被排序(默认是升序)，set对应的是K模型，只有一个键值，不像map拥有键值对key和value。set元素的键值就是实值，实值就是键值。set不允许有重复的键值。

也不能通过set的迭代器改变set元素的值，因为set的元素值就是其键值。如果修改set元素的值，会破坏set的排序规则。在STL源码中，将set的迭代器设置为const_iterator。就可以做到拒绝修改set元素。

set的使用

set的模板参数列表

• 第一个模板参数：T set存放的元素类型。实际在底层存储的键值对。
• 第二个模板参数：Compare 仿函数，默认以小于来比较
• 第三个模板参数：Alloc set中元素空间的管理方式，使用STL提供的空间配置器管理

set的构造函数

1. 构造一个空的set容器

set<int> set1;//构造空的set容器

2. 拷贝构造一个set容器

set<int> set1;//构造空的set容器
set<int> set2(set1);//使用set1构造set2

3. 使用迭代器进行构造

vector<int> v = { 1,2,3,4,5 };
set<int> set3(v.begin(),v.end());

4. 构造一个空的set容器，指定比较方式为大于(默认为小于)

set<int, greater<int>> set4

set的第迭代器

和其他容器一样，set也支持迭代器进行访问，但是set不允许通过迭代器进行修改。分别有正向迭代器和反向迭代器和const版本正反向迭代器。

示例：正向迭代器的使用

vector<int> v = { 1,2,3,4,5 };
set<int,greater<int>> set3(v.begin(),v.end());//以大于进行比较
//通过迭代器进行遍历访问
set<int, greater<int>>::iterator it = set3.begin();
while (it != set3.end())
{
        //*it += 1;//error 不允许修改
        cout << *it << endl;
        it++;
}

运行结果：

示例：反向迭代器的使用

vector<int> v = { 1,2,3,4,5 };
	set<int,greater<int>> set3(v.begin(),v.end());

	set<int, greater<int>>::reverse_iterator it = set3.rbegin();
	while (it != set3.rend())
	{
		
		cout << *it << endl;
		it++;
	}

运行结果为1 2 3 4 5

set容量相关函数

• empty
  • 判断容器是否为空。空返回true，非空返回false
• size
  • 返回容器中有效元素的个数

set常用容器修改操作

• insert : 在set中插入元素x，实际插入的是构成的 键值对，如果插入成功，返回<该元素在set中的 位置，true>,如果插入失败，说明x在set中已经 存在，返回
• erase:erase有几个常用的重载

• swap:交换两个set容器元素
• clear：情况set容器

set其他常用函数

• find：在set容器中查找指定元素的迭代器位置

• count：返回set中值为x的元素的个数

set使用举例

void print(set<int> tmp)
{
	for (auto& e : tmp)
	{
		cout << e << ' ';
	}
	cout << endl;
}
int main()
{
	vector<int> v = { 1,3,5,7,9,2,4,6,8,10,1,3,5,7,9,2,4,6,8,10 };
	set<int> set1(v.begin(), v.end());
	print(set1);

	cout << set1.size() << endl;

	set1.insert(666);
	print(set1);

	auto it = set1.find(666);
	set1.erase(it);
	print(set1);
	//统计1出现的次数
	cout << set1.count(3) << endl;

	return 0;
}

运行结果：

map

map文档

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

map的特性是：所有元素都会根据元素的键值自动排序。map的所有元素都是pair类型，同时拥有键值(key) 和 实值(value)。pair第一个元素被视为键值，pair第二个元素被视为实值。map不允许两个元素拥有相同的键值。

map不能通过迭代器修改键值，map元素的键值关系到map元素的排序规则。任意改变map的键值会破坏map的结构。
但是map的实值可以修改,map元素的实值修改不会影响map元素的排序规则。

map的使用

map的模板参数

• 第一个模板参数：键值对中的键值Key
• 第二个模板参数：键值对中的实值Value
• 第三个模板参数：仿函数，默认以小于进行元素比较
• 第四个模板参数：Alloc：通过空间配置器来申请底层空间，不需要用户传递，除非用户不想使用标准库提供的 空间配置器

map的迭代器

map迭代器和其他容器的迭代器使用方式一样。和set一样不能通过迭代器修改键值。

map的构造

map的构造和set一样
1.构造一个空map容器

map<string, int> map1;//构造一个key为string，value为int的map容器

2. 拷贝构造一个map容器

map<string, int> map2(map1);

3. 使用迭代器进行构造

map<string, int> map2(map1);
map<string, int> map3(map2.begin(),map2.end());

4. 构造一个以大于进行元素键值比较的空容器

map<string, int, greater<string>> map4;

map中常用的元素修改

insert

insert重载了三个版本

1. 插入键值对
   函数原型

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

在map中插入键值对x，注意x是一个键值 对，返回值也是键值对：iterator代表新插入 元素的位置，bool代表是否插入成功
value_type原型：

向map中插入元素时要先创建pair对象，再将pair对象插入到map中

map<string, string> map1;
map1.insert(pair<string, string>("set","K模型"));//创建pair匿名对象作为map元素进行插入
map1.insert(pair<string, string>("map","KV模型"));
map1.insert(pair<string, string>("insert","插入"));

这样就会很麻烦，STL库中提供了一个make_pair模板函数使创建pair对象更简单

template<class T1,class T2>
pair<T1,T2> make_pair(T1 x, T2 y)
{
    return (pair<T1, T2>(x, y));
}

使用make_pair创建pair对象进行插入

map1.insert(make_pair("set", "K模型"));
map1.insert(make_pair("map", "KV模型"));
map1.insert(make_pair("insert", "插入"));

2. 在指定位置插入键值对
   函数原型

iterator insert(iterator position, const value_type & val);

通过迭代器确定插入元素的位置。
比如：

map<string, string> map1;
auto it = map1.begin();
map1.insert(it, make_pair("pair", "键值对"));

3. 插入一段迭代器区间
   函数原型

template <class InputIterator>
void insert (InputIterator first, InputIterator last);

比如：

map<string, string> map1;
map<string, string> map2;
map2.insert(map1.begin(), map2.end());

erase

eraer也重载了三个版本

1. 通过迭代器确定位置进行删除
   比如

map<string, string> map1;
map1.insert(make_pair("set", "K模型"));
map1.insert(make_pair("map", "KV模型"));
map1.insert(make_pair("insert", "插入"));
auto it = map1.begin();//删除map中第一个元素
map1.erase(it);

2. 通过键值删除元素

map<string, string> map1;
map1.insert(make_pair("set", "K模型"));
map1.insert(make_pair("map", "KV模型"));
map1.insert(make_pair("insert", "插入"));
map1.erase("set");//通过键值删除，

3. 删除一段迭代器区间

map<string, string> map1;
map1.insert(make_pair("set", "K模型"));
map1.insert(make_pair("map", "KV模型"));
map1.insert(make_pair("insert", "插入"));

map1.erase(++map1.begin(),--map1.end());//删除第一个元素

swap

交换两个map容器

map<string, string> map1;
map1.insert(make_pair("set", "K模型"));
map1.insert(make_pair("map", "KV模型"));
map1.insert(make_pair("insert", "插入"));

map<string, string> map2;
map1.swap(map2);//交换完之后，map1为空。

for (auto& e : map2)
{
        cout << e.first << " " << e.second << endl;
}

clear

清空map容器中的所有元素

map<string, string> map1;
map1.insert(make_pair("set", "K模型"));
map1.insert(make_pair("map", "KV模型"));
map1.insert(make_pair("insert", "插入"));
map1.clear();

find

函数原型：

iterator find (const key_type& k);

map根据键值进行查找，找到了返回元素的迭代器位置，没找到返回end

map<string, string> map1;
map1.insert(make_pair("set", "K模型"));
map1.insert(make_pair("map", "KV模型"));
map1.insert(make_pair("insert", "插入"));

auto it = map1.find("set");通过键值查找set元素
cout << it->first << ":" << it->second << endl;;

[]操作符

map重载了[]运算符，
函数原型：

mapped_type& operator[] (const key_type& k);

[]的参数就是一个键值。
[]的返回值是maaped_type的引用。
mapped_type就是第二个模板参数，也就是实值。

官方文档对返回值的介绍：

很难理解，对其进行拆分 如下

mapped_type& operator[] (const key_type& k)
{
    //1、调用insert函数插入键值对 ret键值对接收insert返回值
    pair<iterator, bool> ret = insert(make_pair(k, mapped_type()));
    //2、拿到insert元素的迭代器
    iterator it = ret.first;
    //3、返回迭代器位置的实值value
    return it->second;
}

operator[]的原理是： 用构造一个键值对，然后调用insert()函数将该键值对插入到map中 如果key已经存在，插入失败，insert函数返回该key所在位置的迭代器 如果key不存在，插入成功，insert函数返回新插入元素所在位置的迭代器 operator[]函数最后将insert返回值键值对中的value返回

这样 []进行插入，也能进行修改，还能进行查找。
比如：

map<string, string> map1;
//第一次插入键值
map1["map"] = "KV模型";
//第二次插入键值就会修改键值对应的实值
map1["map"] = "XXXX";
//查找键值对应的实值
cout << map1["map"] << endl;//结果为XXX

conut

函数原型：

size_type count (const key_type& k) const;

返回键值为k在map中的个数，注意 map中key是唯一的，因此该函数的返回值 要么为0，要么为1，因此也可以用该函数来 检测一个key是否在map中

map<string, string> map1;
map1["map"] = "KV模型";
map1["insert"] = "插入";
map1["set"] = "K模型";
map1["pair"] = "键值对";
cout << map1.count("set") << endl;//1 存在
cout << map1.count("xxx") << endl;//0 不存在

multiset

multiset参考文档：multiset文档

• multiset和set的区别是：multiset中的元素可以重复，set是中value是唯一的
• multiset中的元素也不能进行修改
• multiset的作用：可以对元素进行排序
• 在multiset中找某个元素，时间复杂度为$O(log_2 N)

multiset的使用

multiset和set的使用基本一样，最大的区别就是multiset中的元素可以重复。
比如：

#include 
#include 
#include 
using namespace std;
int main()
{
	vector<int> v = { 1,3,5,7,8,2,4,6,8,2,4,6,8 };
	multiset<int> mset1;
	for (auto& e : v)
	{
		mset1.insert(e);//将vector中的元素插入到multiset中
	}

	for (auto& e : mset1)
	{
		cout << e << ' ';
	}
	return 0;
}

运行结果：

其他区别就是count函数统计次数不同。set中的count只有0/1。而multiset中允许重复键值。就可以统计元素的个数

multimap

multiset参考文档：
multimap文档

multimap和map的唯一不同就是：map中的key是唯一的，而multimap中key是可以重复的。

multimap的使用

multimap的使用和map的使用都是类似的。
注意： multimap中没有重载operator[]操作。因为multimap中允许键值冗余，调用[]返回哪一个Key的value存在歧义。所以没有重载[]。

multimap<string, string> mmap1;
	mmap1.insert(make_pair("pair", "键值对1"));
	mmap1.insert(make_pair("pair", "键值对2"));
	mmap1.insert(make_pair("pair", "键值对3"));
	mmap1.insert(make_pair("pair", "键值对4"));
	mmap1.insert(make_pair("pair", "键值对5"));
	for (auto& e : mmap1)
	{
		cout << e.first << ":" << e.second << endl;
	}

	cout << mmap1.count("pair"); //5

运行结果：