map和set

关联式容器

我们之前学习的部分容器，如：vector,list,deque
这些容器统称序列式容器，其底层为线性序列的数据结构，里面存储的是元素本身

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

键值对

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

树形结构的关联式容器

STL中总共就实现了两种不同结构的管理式容器：树形结构和哈希结构。

树形结构的关联式容器主要有四种：map,set,multimap,multiset
这四种容器的共同点：使用平衡搜索树（红黑树）作为底层结构，容器中的元素是一个有序的序列

set

先看看cplusplus对其的解释

翻译过来就是

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

在使用set有以下几点需要注意：

1.与map/multimap不同，map/multimap中存储的是真的键值对<key,value> 。set中脂肪value,但在底层实际存放的是由<value,value>构成的键值对
2.set中插入元素时，只需要插入value即可，不需要构成键值对
3.set中的元素不可以重复（因此可以使用set进行去重）
4.使用set的迭代器遍历set中的元素，会得到有序序列
5.set中的元素默认按照小于来比较
6.查找某个元素的时间复杂度是log(2n)
需要加头文件#include< set >

set的具体功能

set的构造

函数声明	功能介绍
set(const Compaer& comp=Compare(),const Allocator& =Alloctor()	构建空的set
set(InputIterator first, InputIterator last, const Compare& comp = Compare(), const Allocator& =Allocator());	用[first,last）区间中中的元素构造set
set(const set<Key,Compare,Allocator>& x);	set的拷贝构造

set的迭代器

函数声明	功能介绍
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

可以看到end代表的是最后一个元素下一个位置
rend就是rbegin

set的容量

|函数声明| 功能介绍 |
|–|–|3
|bool empty() const | 检测set是否为空，空返回true,否则返回true |
|size_type size() const|返回set中有效元素的个数|

set的修改操作

函数声明	功能介绍
pair<iterator,bool> insert(const value_type& x)	在set中插入元素x,实际插入的是<x,y>构成的键值对，如果插入成功，返回<该元素在set中的位置，true>，如果插入失败，说明x在set中已经存在，返回<x在set中的位置,false>
void erase(iteraor 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的元素的个数

来看下使用举例

map

来看下档案介绍

翻译后：

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

Alloc：通过空间配置器来申请底层空间，不需要用户传递，除非用户不想使用标准库提供的空间配置器

map的构造

函数声明	功能介绍
map()	构造一个空的map

map的迭代器

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

map的容量与元素访问

函数声明	功能简介
bool empty() const	检测map中的元素是否为空，空则返回true,否则返回false
size_t size() const	返回map中有效元素的个数
mapped_type& operator[] (const key_type& k)	返回key对应的value

有种特殊情况：
当key不在map中时，operator[]用默认value与key构造键值对然后插入，返回该默认value.

有一个类似的at()函数。都是通过key找到与key对应的value然后返回其引用。不同的是at()函数直接抛异常。

operator[] 还可以用来统计次数
看下举例操作:

1.常规计数

string arr[]={"苹果","西瓜","苹果"};

map<string,int> countmap;
for(auto& str:arr)
{
	map<string,int>::iterator it=countmap.find(str);
	if(it!=countmap.end())
	{
		it->second++;
	}
	else//不存在就自动记成1
	{
		countmap.insert(make_pair(str,1));
	}
}

2.使用operator[]

string arr[]={"苹果","西瓜","苹果"};

map<string,int> countmap;
for(auto& str:arr)
{
	//1.str不在countmap中，插入pair<string,int>(str,int()),然后返回次数++
	//2.str在countmap中，返回value（次数）的引用，次数++;
	countmap[str]++;
}

具体原理可以看下面使用实例中的解释

map中元素的修改

函数声明	功能简介
pair<iterator,bool> insert(const value_type& x )	在map中插入键值对x,注意x是一个键值对，返回值也是键值对。iterator代表新插入元素的位置，bool代表释放插入成功
void erase(iterator position)	删除position位置上的元素
size_t 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(const key_type& x)	在map中插入key为x的元素，找到返回该元素的位置的const迭代器，否则返回
iterator find(const key_type& x) const	在map中插入key为x的元素，找到返回该元素的位置的const迭代器，否则返回cend
size_t count(const key_type& x) const	返回key为x的键值在map中的个数，注意map中key是唯一的，所以返回值只能是0或1，也可以用来检测一个key是否在map中

来看下使用实例

#include<iostream>
#include<string>
#include<map>

using namespace std;

void TestMap()
{
	map<string, string> m;

	// 向map中插入元素的方式：
	// 将键值对<"peach","桃子">插入map中，用pair直接来构造键值对

	m.insert(pair<string, string>("peach", "桃子"));
	m.insert(make_pair("banan", "香蕉"));
	// 借用operator[]向map中插入元素
	/*
	operator[]的原理是：
	用<key, T()>构造一个键值对，然后调用insert()函数将该键值对插入到map中
	如果key已经存在，插入失败，insert函数返回该key所在位置的迭代器
	如果key不存在，插入成功，insert函数返回新插入元素所在位置的迭代器
	operator[]函数最后将insert返回值键值对中的value返回
	*/
	// 将<"apple", "">插入map中，插入成功，返回value的引用，将“苹果”赋值给该引用结果，

	m["apple"] = "苹果";
	// key不存在时抛异常

	//m.at("waterme") = "水蜜桃";
	cout << m.size() << endl;

	// 用迭代器去遍历map中的元素，可以得到一个按照key排序的序列
	for (auto& e : m)
		cout << e.first << "--->" << e.second << endl;
	cout << endl;

	// map中的键值对key一定是唯一的，如果key存在将插入失败
	auto ret = m.insert(make_pair("peach", "桃色"));
	if (ret.second)
		cout << "<peach, 桃色>不在map中, 已经插入" << endl;
	else
		cout << "键值为peach的元素已经存在：" << ret.first->first << "--->"
		<< ret.first->second << " 插入失败" << endl;

	// 删除key为"apple"的元素
	m.erase("apple");
	if (1 == m.count("apple"))
		cout << "apple还在" << endl;
	else
		cout << "apple被吃了" << endl;
}


int main()
{
	TestMap();
	return 0;
}

可以注意operator[]的使用原理

multiset

multiset功能使用与set大致相同，唯一不同的就是multiset中的元素是可重复的

可以用来排序有重复元素的序列

multimap

跟map也是大致相同的，唯一不同的就是multimap中key是可以重复的

但是multimap没有重载operator[]操作
因为operator[]实现原理是实现了 <key，value>键值对，一对一关系，不能有重复的

来做两个OJ题来使用下map和set

两个数的交集

OJ链接

大致思路：
使用set排序去重后
两个迭代器指向去重后的序列，进行解引用比较，当*it1<*it2时，it1++,当 *it1>*it2时，it2++,相等的时候将这个数push_back进vector即可

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        set<int> s1(nums1.begin(),nums1.end());
        set<int> s2(nums2.begin(),nums2.end());

        auto it1=s1.begin();
        auto it2=s2.begin();

        vector<int> v;

        while(it1!=s1.end()&&it2!=s2.end())
        {
            if(*it1<*it2)
                it1++;
            else if(*it1>*it2)
                it2++;
            else
                {
                    v.push_back(*it1);
                    it1++;
                    it2++;
                }

        }
        return v;
        
    }
};

底层结构

上面所述的map/multimap/set/multiset的共同点是：底层结构都是二叉搜索树。但是往二叉搜索树插入有序元素或这接近有序的元素，就会退化成单支树，效率会很低

AVL树

AVL树实际上一个引入了平衡因子的二叉搜索树，该平衡因子保证了每个节点的左右子树高度之差的绝对值不超过1，这样就可以降低树的高度，减少平均搜索长度。

一棵AVL树或者是空树，或者是具有以下性质的二叉搜索树：
1.它的左右子树都是AVL树
2.左右子树高度之差（平衡因子）的绝对值不超过1（-1/0/1)

如果一棵二叉搜索树是高度平衡的，他就是AVL树，如果它有n个结点，那么它的高度就是log2n,搜索时间复杂度O(log2n).

AVL树的插入

1.按照二叉搜索树的方式插入新节点
2.调整节点的平衡因子

pCur插入后，pParent的平衡因子需要调整，插入之前，pParent的平衡因子分为三种情况-1 0 1
1.如果pCur插入到pParent的左侧，只需要给pParent的平衡因子-1
2.如果pCur插入到pParent的右侧，只需要给pParent的平衡因子+1

插入后的平衡因子会有下面三种情况 0 正负1 正负2
1.如果平衡因子为0，说明插入前平衡因子为正负1，插入后满足性质
2.如果平衡因子为正负，说明插入前平衡因子为0，插入后以pParent为根的高度增加，需要继续向上更新
3.如果平衡因子为正负2，违反了AVL树的性质，需要进行旋转处理

AVL树的旋转

当插入节点后造成了不平衡也就是平衡因子为正负2，此时就需要进行旋转。
旋转分为4种情况：

1.新节点插入较高左子树的左侧 --左左：右单旋

2.新节点插入较高右子树的右侧 --右右：左单旋

3.新节点插入较高左子树的右侧 --左右：先左单旋再右单旋

4.新节点插入较高右子树的左侧 --右左：先右单旋再左单旋

AVL树的验证

1.验证为二叉搜索树
看中序遍历可以得到一个有序的序列，就说明为二叉搜索树
2.验证为平衡树
（1）每个节点子树高度差的绝对值不超过1（这是没有引入平衡因子）
（2）节点的平衡因子是否正确

红黑树

红黑树是一种二叉搜索树，但在每个节点上增加一个存储位标识节点的颜色，RED或BLACK。通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出两倍，因而接近平衡。（可以看出红黑树的控制平衡的条件没有AVL树那么严格）

红黑树的性质

1.每个结点不是黑色就是红色
2.根节点是黑色的
3.如果一个结点是红色的，则它的两个孩子结点是黑色的
4.对于每个结点，从该结点到其所有后代叶结点的简单路径上，均包含相同数目的黑色结点
5.每个叶子节点都是黑色的（这里的叶子结点指的是空结点）

代码部分后期补上