漫步STL-map AND set

1. 关联式容器

容器可以分为：关联式容器和序列式容器

类型	容器名（常用）			常用功能
序列式容器	vector	list	deque（用的也不是很多）	存储数据
关联式容器	map	set	unordered_map	存储数据+数据检索
容器适配器	stack	queue

序列式是互相挨着放的，而且实际上可以随便改变顺序

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

map和set的话底层是平衡二叉树和红黑树，而unordered_map是哈希表

2. 键值对

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

容器	功能
set	1. key在不在set
map	1. key在不在map	2. 通过key查找对应的value
unordered_map	to be continued…	to be continued…

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

3. 树形结构的关联式容器

根据应用场景的不桶，STL总共实现了两种不同结构的管理式容器：树型结构与哈希结构。树型结构的关联式容器主要有四种：map、set、multimap、multiset。这四种容器的共同点是：使用平衡搜索树(即红黑树)作为其底层结果，容器中的元素是一个有序的序列。

4. set

4.1 set快速入门

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

4.2 构造

4.3 增删查改Modifiers

函数声明	功能介绍
pair<iterator,bool> insert (const value_type& x )	在set中插入元素x，实际插入的是<x, x>构成的键值对，如果插入成功，返回<该元素在set中的位置，true>,如果插入失败，说明x在set中已经存在，返回<x在set中的位置，false>
void erase ( iterator position )	删除set中position位置上的元素
size_type erase ( const key_type& x )	删除set中值为x的元素，返回删除的元素的个数
void erase ( iterator first,iterator last )	删除set中[first, last)区间中的元素
void swap (set<Key,Compare,Allocator>& st )	交换set中的元素
void clear ( )	将set中的元素清空
iterator find ( const key_type& x ) const	返回set中值为x的元素的位置
size_type count ( const key_type& x ) const	返回set中值为x的元素的个数

🌿 insert

对于insert接口来说，无关乎我是前插还是后插，以为我插入之后一般都是会经过一定的插入方式来操作结构的，就像搜索树一样

	set<string> strSet;
	strSet.insert("Pikachu");
	strSet.insert("Politoed");
	strSet.insert("Yanma");
	strSet.insert("Wooper");

🌿 find

支持查找

	for (const auto& e : strSet)
	{
		cout << e << " ";
	}
	cout << endl;

	set<string>::iterator ret = strSet.find("Pikachu");
	if (ret != strSet.end())
	{
		cout << "找到了" << endl;
	}
	else
	{
		cout << "没有找到" << endl;
	}
	ret = strSet.find("皮卡丘");
	if (ret != strSet.end())
	{
		cout << "找到了" << endl;
	}
	else
	{
		cout << "没有找到" << endl;
	}

🌿 降序

使用反向迭代器

set<int>::reverse_iterator rit = s.rbegin();
	while (rit != s.rend())
	{
		cout << *rit << " ";
		++rit;
	}
	cout << endl;

🌿 erase

set<int> s;
s.insert(3);
s.insert(1);
s.insert(2);
s.insert(14);
s.insert(36);
s.insert(4);
s.insert(3);
s.insert(3);

// 1.先查找，找到了再删。没找到，也去删，会报错
pos = s.find(40);
s.erase(pos);//越界
//改成
auto pos = s.find(40);
if (pos != s.end())
{
    s.erase(pos);
}
//2.在就删除，不在就不处理也不报错
s.erase(30);

🌿 swap

下面这两者是有区别的（C++98）

在C++98中前者直接交换，后者需要深拷贝，所以前者效率较高，然后C++11中则会做一些优化

s1.swap(s2);
swap(s1,s2);

4.4 访问elements

函数声明	功能介绍
iterator begin()	返回set中起始位置元素的迭代器
iterator end()	返回set中最后一个元素后面的迭代器
const_iterator cbegin() const	返回set中起始位置元素的const迭代器
const_iterator cend() const	返回set中最后一个元素后面的const迭代器
reverse_iterator rbegin()	返回set第一个元素的反向迭代器，即end
reverse_iterator rend()	返回set最后一个元素下一个位置的反向迭代器，即rbegin
const_reverse_iterator crbegin() const	返回set第一个元素的反向const迭代器，即cend
const_reverse_iterator crend()const	返回set最后一个元素下一个位置的反向const迭代器，即crbegin

🌿 iterator

注意之前已经提到过set的元素不能在容器中修改，搜索树如果改了节点，就破坏了原来的结构

我们在访问的时候效果是排序+去重

// 遍历方式1：
set<int>::iterator it = s.begin();
while (it != s.end())
{
    // 不能修改已经插入的值
    //*it+1;//error
    cout << *it << " ";
    ++it;
}
cout << endl;

注意:如果直接一个数组的话要排序肯定是sort来的快

🌿 范围for

// 遍历方式2：
for (auto e : s)
{
    cout << e << " ";
}
cout << endl;
//用到自定义类型或者string最好这样写，避免拷贝构造
for (const auto& e : strSet)
{
    cout << e << " ";
}
cout << endl;

🌿 活学活用

利用之前的几个小接口，写一个类似单词检查拼写的小程序，
思路：词库中单词都放进set的对象中，把每个写出来的单词去set中查一下，在不在，在就是正确的，不在就是错误的拼写

4.5 容量

4.6 multiset

有些极端情况下有一种set实际上是可以插入相同数据的，此时必须规定好究竟在哪里插入相同数据，是在左子树还是右子树不一定

multiset就是一种只排序不去重的特殊set，其他功能和接口与set很类似

4.5.1 multiset 快速入门

🍁 multiset是按照特定顺序存储元素的容器，其中元素是可以重复的。
🍁 在multiset中，元素的value也会识别它(因为multiset中本身存储的就是<value, value>组成的键值对，
因此value本身就是key，key就是value，类型为T). multiset元素的值不能在容器中进行修改(因为元素
总是const的)，但可以从容器中插入或删除。
🍁 在内部，multiset中的元素总是按照其内部比较规则(类型比较)所指示的特定严格弱排序准则进行排
序。
🍁 multiset容器通过key访问单个元素的速度通常比unordered_multiset容器慢，但当使用迭代器遍历时
会得到一个有序序列。
🍁 multiset底层结构为二叉搜索树(红黑树)。

4.5.2 multiset注意事项

🌿 multiset中再底层中存储的是<value, value>的键值对
🌿 mtltiset的插入接口中只需要插入即可
🌿 与set的区别是，multiset中的元素可以重复，set是中value是唯一的
🌿 使用迭代器对multiset中的元素进行遍历，可以得到有序的序列
🌿 multiset中的元素不能修改
🌿 在multiset中找某个元素，时间复杂度为O(logN)
🌿 multiset的作用：可以对元素进行排序

4.5.3 multiset使用

// multiset允许键值冗余，使用方法基本跟set一致
// 就下面几个地方有一些差异
multiset<int> s;
s.insert(3);
s.insert(1);
s.insert(2);
s.insert(14);
s.insert(36);
s.insert(4);
s.insert(3);
s.insert(3);
s.insert(3);

// 排序
multiset<int>::iterator it = s.begin();
while (it != s.end())
{
    cout << *it << " ";
    ++it;
}
cout << endl;

// find查找的val有多个的时候，那么他找到的是中序的第一个
multiset<int>::iterator pos = s.find(3);
while (*pos == 3)
{
    cout << *pos << endl;
    ++pos;
}
cout << s.count(3) << endl;
cout << s.count(4) << endl;

//所有的3一起删除
s.erase(3);

5. map

5.1 map快速入门

🍁 map是关联容器，它按照特定的次序(按照key来比较)存储由键值key和值value组合而成的元素。
🍁 在map中，键值key通常用于排序和惟一地标识元素，而值value中存储与此键值key关联的内容。键值key和值value的类型可能不同，并且在map的内部，key与value通过成员类型value_type绑定在一起，为其取别名称为pair:

  typedef pair value_type;

🍁 在内部，map中的元素总是按照键值key进行比较排序的。
🍁 map中通过键值访问单个元素的速度通常比unordered_map容器慢，但map允许根据顺序对元素进行
直接迭代(即对map中的元素进行迭代时，可以得到一个有序的序列)。
🍁 map支持下标访问符，即在[]中放入key，就可以找到与key对应的value。
🍁 map通常被实现为二叉搜索树(更准确的说：平衡二叉搜索树(红黑树))。

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

5.2 增删查改Modifiers

函数声明	功能简介
pair<iterator,bool> insert (const value_type& x )	在map中插入键值对x，注意x是一个键值对，返回值也是键值对：iterator代表新插入元素的位置，bool代表释放插入成功
void erase ( iterator position )	删除position位置上的元素
size_type erase ( const key_type& x )	删除键值为x的元素
void erase ( iterator first, iterator last )	删除[first, last)区间中的元素
void swap ( map<Key,T,Compare,Allocator>& mp )	交换两个map中的元素
void clear ( )	将map中的元素清空iterator find
iterator find ( const key_type& x )	在map中插入key为x的元素，找到返回该元素的位置的迭代器，否则返回end
const_iterator find ( const key_type& x ) const	在map中插入key为x的元素，找到返回该元素的位置的const迭代器，否则返回cend
size_type count ( const key_type& x ) const	返回key为x的键值在map中的个数，注意map中key是唯一的，因此该函数的返回值要么为0，要么为1，因此也可以用该函数来检测一个key是否在map中

🌿 insert

不用担心make_pair的效率问题，这个函数已经搞成了内联函数

map<int, double> m;
// 调用pair的构造函数，构造一个匿名对象插入
m.insert(pair<int, double>(1, 1.1));
m.insert(pair<int, double>(5, 5.5));
m.insert(pair<int, double>(2, 2.2));
m.insert(pair<int, double>(2, 3.3)); // key相同就会插入失败

// 调用函数模板，构造对象，
// 好处:是不需要去声明pair的参数，让函数模板自己推演，用起来方便些
m.insert(make_pair(2, 2.2));

如果有时候我们发现这个pair写起来太麻烦了，那么我们实际上可以宏定义一下

	// 通过typedef 简化命名
	typedef std::map<std::string, std::string> POKEMON;
	typedef std::pair<std::string, std::string> POKEMON_KV;
	typedef std::map<std::string, std::string>::iterator POKEMON_ITER;

	POKEMON pokemon;
	pokemon.insert(pair<string,string>("卡比兽", "一般"));
	pokemon.insert(POKEMON_KV("喷火龙","火"));
	pokemon.insert(make_pair("皮卡丘", "电"));

	POKEMON_ITER pok = pokemon.begin();
	//auto pok = pokemon.begin();
	while (pok != pokemon.end())
	{
		cout << pok->first << ":" << pok->second << endl;
		++pok;
	}
	cout << endl;

如果我们想要修改插入，还可以用insert有一些修改操作，注意还是key不能修改只能改value

下面用一些代码实例value的值在周围包上一对【】，同时因为喷火龙是飞行和火属性所以我可以试着修改补充飞行属性

// 通过typedef 简化命名
	typedef std::map<std::string, std::string> POKEMON;
	typedef std::pair<std::string, std::string> POKEMON_KV;
	typedef std::map<std::string, std::string>::iterator POKEMON_ITER;

	POKEMON pokemon;
	pokemon.insert(pair<string,string>("卡比兽", "一般"));
	pokemon.insert(POKEMON_KV("喷火龙","火"));
	pokemon.insert(make_pair("皮卡丘", "电"));

	// 修改map的value数据
	auto ret = pokemon.find("喷火龙");
	if (ret != pokemon.end())
	{
		//ret->second.insert(ret->second.size(), "、飞行");
		// 可读性优化技巧
		string& str = ret->second;
		str += "、飞行";
	}

	//修改value显示的时候加一个括号
	POKEMON_ITER pok = pokemon.begin();
	while (pok != pokemon.end())
	{
		pok->second.insert(0, "【");
		pok->second += "】";
		cout << pok->first << ":" << pok->second << endl;
		++pok;
	}
	cout << endl;

有时候,我们的修改的时候为了提高可读性，可以不用一步出，而改成两步出

	//ret->second.insert(ret->second.size(), "、飞行");
		// 可读性优化技巧
		string& str = ret->second;
		str += "、飞行";

5.3 访问elements

函数声明	功能介绍
begin()和end()	begin:首元素的位置，end最后一个元素的下一个位置
cbegin()和cend()	与begin和end意义相同，但cbegin和cend所指向的元素不能修改
rbegin()和rend()	反向迭代器，rbegin在end位置，rend在begin位置，其++和–操作与begin和end操作移动相反
crbegin()和crend()	与rbegin和rend位置相同，操作相同，但crbegin和crend所指向的元素不能修改

🌿 迭代器

省略了一个箭头，这里的原因和list篇中的很像https://blog.youkuaiyun.com/Allen9012/article/details/123789420

	map<int, double>::iterator it = m.begin();
	while (it != m.end())
	{
		//cout << (*it).first <<":"<<(*it).second<<endl;
		cout << it->first << ":" << it->second << endl;
		++it;
	}
	cout << endl;

🌿 operator[]

	// 关于[]的一些扩展学习
	map<string, string> pokemon;
	pokemon.insert(make_pair("皮卡丘", "一般"));
	pokemon["皮卡丘"] = "电";  // 插入+修改
	pokemon["卡比兽"]; // 插入
	pokemon["卡比兽"] = "一般";     // 修改
	pokemon["喷火龙"] = "火、飞行";  // 修改
	pokemon.erase("喷火龙");

5.4 统计次数

下面可以写一个程序统计某一个元素出现的次数，正好利用map的平衡二叉树的特性，时间复杂度是O(log

N)

第一次出现，插入<str, 1>, 后续再出现就++次数ret->second

5.4.1 方法一

// 1、统计次数 
	string arr[] = { "皮卡丘", "喷火龙", "皮卡丘", "妙蛙种子", "水跃鱼", 
		"皮卡丘", "喷火龙", "喷火龙","喷火龙","喷火龙", "皮卡丘", "水跃鱼", "喷火龙" };

	// 统计次数的方式1：
	map<string, int> countMap;
	for (const auto& str : arr)
	{
		// 思路：第一次出现，插入<str, 1>, 后续再出现就++次数ret->second
		map<string, int>::iterator ret = countMap.find(str);
		if (ret != countMap.end())
		{
			ret->second++;
		}
		else
		{
			countMap.insert(make_pair(str, 1));
		}
	}
	for (const auto& e : countMap)
	{
		cout << e.first << ":" << e.second << endl;
	}

5.4.2 方法二

来看一下map的insert返回值

第二次插入相同的值的时候返回值会返回<指向新插入的节点的迭代器iterator,false>

	 //统计次数的方式2： 
	map<string, int> countMap;
	for (const auto& str : arr)
	{
		// 先插入，如果str已经在map中，insert会返回str所在节点的迭代器，我们++次数即可
		//pair<map<string, int>::iterator, bool>  ret = countMap.insert(make_pair(str, 1));
		auto ret = countMap.insert(make_pair(str, 1));//返回值ret是pair类型的
		if (ret.second == false)
		{//first是迭代器，迭代器指向的value++
			ret.first->second++;
		}
	}

5.4.3 方法三

实际当中map的统计方式一般用第三种

map<string, int> countMap;
for (const auto& str : arr)
{
    countMap[str]++;
}

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

使用operator[]访问

5.5 统计次数并排序

有时候我们不仅需要对数据统计次数，同时还需要取出排序后的前几项也就是TopK问题

5.5.1 sort

利用库函数排序，sort函数中要传入对象MapItCompare()

struct MapItCompare
{//降序
	bool operator()( map<string, int>::iterator x,  map<string, int>::iterator y) 
	{
		return x->second > y->second;
	}
};

void Statistic_sort()
{
    string arr[] = { "香蕉", "苹果", "香蕉", "榴莲", "草莓", "苹果", "香蕉", "苹果", "西瓜", "西瓜", "香蕉", "草莓", "西瓜" };
    map<string, int> countMap;
    //1. 统计次数
    for (const auto& str : arr)
    {
        countMap[str]++;
    }

    // 2. 对所有水果次数排序的思路
    //vector<pair<string, int>> v;//不要放数据进vector
    vector<map<string, int>::iterator> v;//放指针
    map<string, int>::iterator countMapIt = countMap.begin();
    while (countMapIt != countMap.end())
    {
        v.push_back(countMapIt);
        ++countMapIt;
    }
    //排序
    sort(v.begin(), v.end(), MapItCompare());
}

5.5.2 map排序

使用greater仿函数来获取一个map存放个数，并利用map排序，注意greater要包<functional>

注意这里的map比较的只能是key，所所以新构建的map这里我们是<int,string>

#include<functional>

string arr[] = { "香蕉", "苹果", "香蕉", "榴莲", "草莓", "苹果", "香蕉", "苹果", "西瓜", "西瓜", "香蕉", "草莓", "西瓜" };
map<string, int> countMap;
//1. 统计次数
for (const auto& str : arr)
{
    countMap[str]++;
}

// 2. 对所有水果次数排序的思路
// 利用map排序  -- 拷贝pair数据
//map<int, string> sortMap;//默认升序
map<int, string, greater<int>> sortMap;//降序
for (auto e : countMap)
{
    sortMap.insert(make_pair(e.second, e.first));
}

5.5.3 set排序

不过此时发现map还是做了对数据的拷贝，还是可以改成存迭代器，利用set即可，set模板中要传入一个类MapItCompare来比较大小

struct MapItCompare
{//降序
	bool operator()( map<string, int>::iterator x,  map<string, int>::iterator y) const
	{//VS2022比较严格也就是说const一定要加，不然会丢失const特性
		return x->second  y->second;
	}
};
void Statistic_sort()
{
	string arr[] = { "香蕉", "苹果", "香蕉", "榴莲", "草莓", "苹果", "香蕉", "苹果", "西瓜", "西瓜", "香蕉", "草莓", "西瓜" };
	map<string, int> countMap;
	//1. 统计次数
	for (const auto& str : arr)
	{
		countMap[str]++;
	}
	map<string, int>::iterator countMapIt = countMap.begin();
	// 2. 利用set排序  --不拷贝pair数据
	set<map<string, int>::iterator, MapItCompare> sortSet;
	countMapIt = countMap.begin();
	while (countMapIt != countMap.end())
	{
		sortSet.insert(countMapIt);
		++countMapIt;
	}
}

5.5.4 优先级队列

优先级队列并不是有序的，是一个小堆

struct MapItCompare
{//降序
	bool operator()( map<string, int>::iterator x,  map<string, int>::iterator y) const
	{//VS2022比较严格也就是说const一定要加，不然会丢失const特性
		return x->second < y->second;
	}
};
void Statistic_sort()
{
	string arr[] = { "香蕉", "苹果", "香蕉", "榴莲", "草莓", "苹果", "香蕉", "苹果", "西瓜", "西瓜", "香蕉", "草莓", "西瓜" };
	map<string, int> countMap;
	//1. 统计次数
	for (const auto& str : arr)
	{
		countMap[str]++;
	}
	map<string, int>::iterator countMapIt = countMap.begin();
	// 2. 利用set排序  --不拷贝pair数据
	typedef map<string, int>::iterator M_IT;
	priority_queue<M_IT, vector<M_IT>, MapItCompare> pq;
	countMapIt = countMap.begin();
	while (countMapIt != countMap.end())
	{
		pq.push(countMapIt);
		++countMapIt;
	}
}

5.6 multimap

5.6.1 multimap快速入门

🌿 Multimaps是关联式容器，它按照特定的顺序，存储由key和value映射成的键值对<key, value>，其中
多个键值对之间的key是可以重复的。
🌿 在multimap中，通常按照key排序和惟一地标识元素，而映射的value存储与key关联的内容。key和value的类型可能不同，通过multimap内部的成员类型value_type组合在一起，value_type是组合key和value的键值对:

	typedef pair<const Key, T> value_type;

🌿 在内部，multimap中的元素总是通过其内部比较对象，按照指定的特定严格弱排序标准对key进行排序
的。
🌿 multimap通过key访问单个元素的速度通常比unordered_multimap容器慢，但是使用迭代器直接遍历
multimap中的元素可以得到关于key有序的序列。
🌿 multimap在底层用二叉搜索树(红黑树)来实现。

5.6.2 multimap注意事项

🍁 multimap中的key是可以重复的。
🍁 multimap中的元素默认将key按照小于来比较
🍁 multimap中没有重载operator[]操作(同学们可思考下为什么?)。
🍁 使用时与map包含的头文件相同

5.6.3 multimap的使用

multimap和multiset的特性十分相像，可以类比来看

	map<string, string> pokemon;
	pokemon.insert(make_pair("喷火龙", "火"));
	pokemon.insert(make_pair("喷火龙", "飞行"));

	multimap<string, string> mpokemon;
	mpokemon.insert(make_pair("喷火龙", "火"));
	mpokemon.insert(make_pair("喷火龙", "飞行"));
	mpokemon.insert(make_pair("喷火龙", "火"));

5.7 map小结

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