今天我们来讲一下set和map 的使用以及其底层原理（包括AVL树，红黑树等），最后我们自己实现一个简单的set和map.

阅读指南：

入门 set/map 的同学，建议全篇阅读
熟练使用set/map 相关接口的同学可以直通【4. 底层结构】
熟悉set/map 的底层的同学，可以直通【5. set和map 的模拟实现】
欢迎指正与交流讨论！

1. 关联式容器

在初阶阶段，我们已经接触过STL中的部分容器，比如：vector、list、dequeforward_list(C++11)等，这些容器统称为序列式容器，因为其底层为线性序列的数据结构，里面存储的是元素本身。那什么是关联式容器？它与序列式容器有什么区别？

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

2. 键值对

2.1 键值对的概念

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

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

2.2 pair

在stl 中我们使用结构体pair来存储键值对，其中存储了first和second 两个值，分别代表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)
	{
    
    }
};

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

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

3.1 set

3.1.1 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中查找某个元素，时间复杂度为：log2 N
set中的元素不允许修改(为什么?)
set中的底层使用二叉搜索树(红黑树)来实现。

3.1.2 set 的使用

3.1.2.1 set的模板参数列表

在这里插入图片描述

T: set中存放元素的类型，实际上在底层存储<value,vaslue>的键值对。
Compare: set中元素默认按照小于来比较
Alloc:set中元素空间的管理方式，使用STL提供的空间配置管理

3.1.2.2 set的构造函数

函数声明	功能介绍
set(const Compare& comp=Compare(),const Allocator&=Allocator())	构造空的set
set(Inputlterator first,Inputlterator last,const Compare& comp=Compare(),const Allocator& = Allocator() ));	用[first, last)区间
set ( const set<Key,Compare,Allocator>& x);	set的拷贝构造

3.1.2.3 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

3.1.2.4 set 的容量

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

3.1.2.5 set修改操作

函数声明	功能介绍
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位置上的元素
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的元素的个数

3.1.2.6 使用举例

#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;
}

3.2 map

3.2.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通常被实现为二叉搜索树(更准确的说：平衡二叉搜索树(红黑树))。

3.2.2 map的使用

3.2.2.1 map的模板参数说明

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

3.2.2.2 map 的构造函数

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

3.2.2.3 map的迭代器

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

3.2.2.4 map 的容器与元素访问

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

3.2.2.5 map 中元素的修改

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

3.2.2.6 使用举例

#include <string>
#include <map>
void TestMap()
{
    
    
	map<string, string> m;
	// 向map中插入元素的方式：
	// 将键值对<"peach","桃子">插入map中，用pair直接来构造键值对
	m.insert(pair<string, string>("peach", "桃子"));
	// 将键值对<"peach","桃子">插入map中，用make_pair函数来构造键值对
	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;
}

3.2.2.7 map对[ ]的重载原理

在map 中重载了[]，但是其原理是比较复杂的。

在这之前，我们先来看一个小问题，统计单词出现次数

方法一

这道题有几种做法，我们最容易想到的方法就是使用查找方法，如果找到了，就对应单词数量加一，如果找不到，就插入新单词。

void test_map1()
{
    
    
	string str[] = {
    
     "sort","sort","tree","insert",
	"sort","tree","sort","test" };
	map<string, int> countMap;  //pair 结构体

	for (auto& e : str) {
    
    
    
		auto ret = countMap.find(e);
		if (ret != countMap.end()) {
    
    
			//找到了
			(*ret).second++;
			//(ret->second)++;
		}
		else {
    
    
		    //没找到
			countMap.insert(make_pair(e, 1));
			//countMap.insert(pair<string ,int>(e, 1));
		}
	}
	//打印测试
	map<string, int>::iterator it1 = countMap.begin();
	while (it1 != countMap.end()) {
    
    
		cout << it1->first << ":" << it1->second << endl;
		++it1;
	}
	cout << endl;
}

方法二

方法一的思路简单，但是其缺点在于我们插入新单词是要遍历两次map（查找+插入（也要查找空位））.

我们可以利用insert 的特性来直接实现。
在这里插入图片描述

我们发现，insert的返回值很有意思： pair<iterator,bool>

如果插入成功的话，我们会返回新插入元素的迭代器和true, 如果待插入值已存在(插入失败)，那么我们会返回与插入值相等的值得迭代器和 false。

void test_map2()
{
    
    
	string str[] = {
    
     "sort","sort","tree","insert",
	"sort","tree","sort","test" };
	map<string, int> countMap;  //pair 结构体

	for (auto& e : str) {
    
    
        //不会允许插入值的冗余  返回类型: pair<iterator , bool>
		pair<map<string, int>::iterator, bool> ret = countMap.insert(make_pair(e, 1)); 
		
	    //插入失败，表示e对应的字符串已经在map中了,++次数
		if (ret.second == false) {
    
    
			ret.first->second++;
		}
		
	}
	map<string, int>::iterator it1 = countMap.begin();
	while (it1 != countMap.end()) {
    
    
		cout << it1->first << ":" << it1->second << endl;
		++it1;
	}
	cout << endl;
}

方法三

其实上面两种方法都比较少用，我们可以直接使用 []来实现，相信很多同学多多少少是见过这种方法的，但是并不是很理解，这就是没有深入底层来探究的原因。
在这里插入图片描述

其中 key_value是 key的类型，mapped_type 是 value 的类型。

mapped_type& operator[] (const key_type& k){
    
    
   (*((this->insert(make_pair(k,mapped_type()))).first)).second;
}

可以发现，官方文档给出的说明 “非常离谱”，但是并不是看不懂：
我们将函数拆解一下：

mapped_type& operator[] (const key_type& k){
    
    
   pair<iterator,bool>ret = insert(make_pair(k,mapped_type());
   return ret.first->second;
}

k 在map 中，insert插入失败，因为k已经有了。insert返回的pair 会带出k在map中存储节点的迭代器，通过这个迭代器，我们可以拿到k对应的valueh值，进行返回。
k不在map中，insert插入成功，插入的值是make_pair<k, value（）> (value()是匿名构造对象)，insert返回值会带出刚插入的k所在节点的迭代器，通过这个迭代器，我们可以拿到k对应的value值，进行返回。

总结 map 的operator特征:

k不存在，插入默认构造函数生成缺省值的value的pair<K,V()>
k存在,返回k对应的value值
不严谨的说，operator可以包含了查找，修改，插入

void test_map3()
{
    
    
	string str[] = {
    
     "sort","sort","tree","insert",
	"sort","tree","sort","test" };
	map<string, int> countMap;  //pair 结构体

	for (auto& e : str) {
    
    

		countMap[e]++;//[]已经被重载了，内部实现较复杂 重点          
	}	
}

一些其他的测试：

void test_map4() {
    
    
	map<string, string>dict;
	dict.insert(make_pair("sort", "排序"));
	dict["string"] = "字符串";//先插入pair("string"," ")，再修改value

	dict["map"];  //插入
	dict["map"] = "地图,映射";//查找 + 修改

	cout << dict["yort1"] << endl;
}

3.3 multiset

3.3.1 multiset简介

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

注意：

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

3.3.2 multiset 的使用

multiset 的使用与set 相差不大，这里我们只提醒几点：

当使用 Find()查找的时候，在底层，找到该值之后，不能停止，而是要找中序的第一个该值。换句话说，找到该值之后，，要看该值的左孩子是不是该值，不是，则返回当前该值，如果是，则继续取左孩子的值，继续刚才的判断。
在这里插入图片描述
这么说有些同学可能还是将信将疑，我们来验证一下：

3.3.2 使用举例

此处只简单演示set与multiset的不同，其他接口接口与set相同。

#include <set>
void TestSet()
{
    
    
	int array[] = {
    
     2, 1, 3, 9, 6, 0, 5, 8, 4, 7 };
	// 注意：multiset在底层实际存储的是<int, int>的键值对
	multiset<int> s(array, array + sizeof(array)/sizeof(array[0]));
	for (auto& e : s)
	cout << e << " ";
	cout << endl;
	return 0;
}

3.4 multimap

3.4.1 简介

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在底层用二叉搜索树(红黑树)来实现。

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

3.4.2 multimap的使用

multimap中的接口可以参考map，功能都是类似的

注意：

multimap中的key是可以重复的。
multimap中的元素默认将key按照小于来比较
multimap中没有重载operator[]操作
使用时与map包含的头文件相同

4. 底层结构

前面对map/multimap/set/multiset进行了简单的介绍，在其文档介绍中发现，这几个容器有个共同点是：其底层都是按照二叉搜索树来实现的，但是二叉搜索树有其自身的缺陷，假如往树中插入的元素有序或者接近有序，二叉搜索树就会退化成单支树，时间复杂度会退化成O(N)，因此map、set等关联式容器的底层结构是对二叉树进行了平衡处理，即采用平衡树来实现

4.1 AVL树

4.1.1 AVL树的概念

两位俄罗斯的数学家G.M.Adelson-Velskii和E.M.Landis在1962年发明了一种解决上述问题的方法：当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度。

一棵AVL树或者是空树，或者是具有以下性质的二叉搜索树：

它的左右子树都是AVL树
左右子树高度之差(简称平衡因子)的绝对值不超过1

在这里插入图片描述

如果一棵二叉搜索树是高度平衡的，它就是AVL树。如果它有n个结点，其高度可保持在 log2 N，搜索时间复杂度O(log2 N )。

4.1.2 AVL树的节点的定义

为了控制树的平衡，我们需要添加一些参数：

_parent 指向父亲节点的指针
_bf 平衡因子（balance factor ）,其值等于右子树的高度 - 左子树的高度。

template<class K,class V>
struct AVLTreeNode
{
    
    
	AVLTreeNode<K, V>* _left;
	AVLTreeNode<K, V>* _right;
	AVLTreeNode<K, V>* _parent;   

	pair<K, V> _kv; //键值对
	int _bf;        //平衡因子

	AVLTreeNode(const pair<K,V>& kv)
		:_left(nullptr)
		,_right(nullptr)
		,_parent(nullptr)
		,_kv(kv)
		,_bf(0)
	{
    
    }
};

同时，我们也就可以写出AVLTree的基本结构：

template<class K,class V>
class AVLTree
{
    
    
	typedef AVLTreeNode<K, V>Node;
public:
	AVLTree()
		:_root(nullptr)
	{
    
    }
	
private:
	Node* _root;

};

4.1.3 AVL树的插入

4.1.3.1 插入的思路

插入分为两步：
第一步与二叉搜索树的插入完全相同，只需要将元素插入到合适的位置。
第二部调整树的结构，使其保持平衡，这一步骤叫做 AVL树的旋转。

//第一步 
if (_root == nullptr) {
    
    
			_root = new Node(kv);
		    return true;
		}
		Node* parent = nullptr;
		Node* cur = _root;
		while (cur) {
    
    
			if (cur->_kv.first < kv.first) {
    
    
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_kv.first > kv.first) {
    
    
				parent = cur;
				cur = cur->_left;
			}
			else {
    
    
				return false; 
			}
		}
		cur = new Node(kv);

		if (parent->_kv.first < cur->_kv.first) {
    
    
			parent->_right = cur;
			cur->_parent = parent;
		}
		else {
    
    
			parent->_left = cur;
			cur->_parent = parent;
		}

4.1.3.2 AVL树的旋转

平衡因子更新规则

我们根据平衡因子的值来判断AVL树的平衡是否被打破。一颗二叉树在插入之前（即平衡态），平衡因子的值一定是-1,0,1 中的一个。当我们插入之后，节点的平衡因子可能会改变。我们更具有平衡因子的值决定是否要旋转。

插入一个节点之后，对于这个新节点祖先都有可能会有影响，但是还需要更具体的分析：

插入更新的节点在父亲的左边，父亲平衡因子- -
插入更新的节点在父亲的右边，父亲平衡因子++
父亲的平衡因子更新之后，是1或者-1,说明父亲所在的子树高度变化了,需要继续往上更新
父亲的平衡因子更新之后，是0，说明父亲所在的子树高度不变,不需要继续往上更新
更新之后，更新到了根节点，就不需要再更新
更新之后,父亲的平衡因子是2或者-2，说明父亲所在的子树已经不平衡了，需要旋转，让他平衡

同学们可以根据文字，配合图片自己来体会一下：
在这里插入图片描述

我们先不管旋转的实现，先上面的不同情况写出代码：

         while (parent) {
    
    
			//更新平衡因子
			if (cur == parent->_left) {
    
    
				parent->_bf--;
			}
			else {
    
    
				parent->_bf++;
			}
			
			//检查父亲的平衡因子
			
			// 1. 父亲所在子树的高度不变，不影响先祖，更新结束
			if (parent->_bf == 0) {
    
    
				break;   
			} //2. 父亲所在子树的高度变了，影响先祖，继续往上更新
			else if (parent->_bf == 1 || parent->_bf == -1) {
    
    

				cur = parent;
				parent = parent->_parent;
			}//3. 父亲所在的子树出现不平衡，需要旋转处理
			else if (parent->_bf == 2 || parent->_bf == -2) {
    
    
				//旋转
			}//4. 出现异常错误
			else {
    
    
				assert(false);
			}
		}

AVL 树的旋转

旋转的本质是：在遵循搜索树的规则情况下，让左右均衡，并且降低整棵树的高度。
不平衡分为四种情况：

新节点插入较深左子树的左侧—左左：右单旋

一. 右旋的规则

在这里插入图片描述
此时，a这颗子树的高度变为h+1 ，就会引发右单旋。
根据上图，右单旋的具体操作：

b子树变成60的左子树
60成为30的右子树，30成这棵树的根

二. 右旋的条件

同学第一次看上面的 抽象图 可能会很懵，在下面我们会将上面的图具体化出几个例子：（这里我还要强调一点：上面的图并不是说 60 一定是一棵树的根，60可以是根也可以是一棵树的一颗子树）

当h=0的时候
当h=0的时候，只存在如下一种情况，我们更新平衡因子，发现60 的平衡因子为-2 ,需要旋转
当h=1的时候
当h=1 的时候，我们的插入拥有两种选择，我们既可以插入在20的左边，也可以插入20的右边，但是在我们不断调整平衡因子之后，最后60的平衡因子都变成了-2，需要旋转。
当h=2的时候
当h=2的时候，其实情况已经变得比较复杂了，原因在于，h=2的子树有三种，而每个子树存在三个可连接点（下图中A,B,C），那么也就是说，在插入节点之前，我们就有3^3=27 种可能形态。
由于情况太多，这里我们只例举一种情况：

h更大的情况我就不写了，相信同学们也找到了一些规律，对于单右旋的条件有了一些体会：

结论：
在这里插入图片描述

从图上直观来说：子树a 与 30,60 呈现一条直线，且右边高，我们应该右单旋，加大右边深度
从代码角度来说：30的平衡因子为-1, 60的平衡因子为-2，我们应该右单旋。

对于右旋，感性理解，就是右边太高了，我们得把右边压下来，从而使右边深度增加，与左边平衡

三. 右旋的代码

由此，可以写出右旋的代码：

在这里插入图片描述

//右单旋
void RotateR(Node* parent) {
    
    
		Node* subL = parent->_left;
		Node* subLR = subL->_right;

		parent->_left = subLR;
		if (subLR) {
    
    
			subLR->_parent = parent;
		}
		//提前记录parent 的父节点
		Node* ppNode = parent->_parent;
		
		subL->_right = parent;
		parent->_parent = subL;
        
        //旋转树 可能是一颗完整树 或者 一颗子树
		if (parent == _root) {
    
    
			_root = subL;
			subL->_parent = nullptr;
		}
		else {
    
    
			if (ppNode->_left == parent) {
    
    
				ppNode->_left = subL;
			}
			else {
    
    
				ppNode->_right = subL;
			}
			subL->_parent = ppNode;
		}
		//更新平衡因子
		parent->_bf = subL->_bf = 0;

	}

新节点插入较深右子树的右侧—右右：左单旋

一. 左旋的规则
左旋的基本规则图如下：
在这里插入图片描述
此时，c这颗子树的高度变为h+1 ，就会引发左单旋。
根据上图，左单旋的具体操作：

b子树变成30的右子树
30成为60的左子树，60成这棵树的根

二. 左旋的条件

与之前的右单旋相同，同学们也可以将h 取特殊值来验证上面的“抽象图”，这里限于篇幅，不再赘述了。

我们直接总结出结论：
在这里插入图片描述

从图上直观来说：子树c 与 30,60 呈现一条直线，且左边高，我们应该左单旋，加大左边深度
从代码角度来说：30的平衡因子为2, 60的平衡因子为1，我们应该左单旋。

对于右旋，感性理解，就是左边太高了，我们得把左边压下来，从而使左边深度增加，与右边平衡

三. 左旋的代码
在这里插入图片描述

void RotateL(Node* parent){
    
    
    
    Node*subR=parent->_right;
    Node*subRL=subR->_left;
    
    parent->_right=subRL;
    if(subRL)
       subRL->_parent=parent;
       
    Node* ppNode= parent->_parent;
    
    subR->left=parent;
    parent->_parent=subR;
    
    if(ppNode==_root){
    
    
       _root=subR;
       subR->_parent=nullptr;
    }
    else{
    
    
       if (ppNode->_left == parent) {
    
    
			ppNode->_left = subR;
	   }
	   else {
    
    
			ppNode->_right = subR;
	   }
	   subR->_parent = ppNode;
    }
    subR->_bf =parent->_bf =0;
}

除了单旋之外，在某些情况之下，一次旋转是不足够的，我们需要两次旋转。

新节点插入较深左子树的右侧—左右：先左单旋再右单旋

左右双旋的规则
在这里插入图片描述
基本步骤：
先对30进行左单旋，然后再对90进行右单旋，旋转完成后再考虑平衡因子的更新。

可以发现，经过第一次左旋，此时 30,60,90 在一条直线上，且90最高，这也就我们右单旋的条件。所以，我们之后右单旋就能获得平衡树。

左右双旋的条件

我们了解了双旋是如何旋转的同时，也要探究一下什么时候我们采用左右双旋。抽象图比较难懂，我们还是采用“抽象具体化”的方式，对h取几个特殊值，看图说话。

抽象图：
在这里插入图片描述

当h=0 的时候

根据抽象图，当我们取h=0 的时候，b,c的子树高度为-1，显然不可能，这里我们理解为60是新增节点。当我们更新平衡因子之后，得到_bf(30)=1,_bf(90)=-2,需要旋转。
在这里插入图片描述

当h=1 的时候

当h=1 的时候，只有一种原始状态，但是插入存在两种情况，60的左边或者右边均可。当然，无论如何插入，最终得到_bf(30)=1,_bf(90)=-2,需要旋转。
在这里插入图片描述

当 h=2的时候

同样，h=2 的时候，情况已经比较复杂，我们任意选取一种来画图：
在这里插入图片描述
由此我们可以得出结论：

从图上直观来说：60 与 30,90 呈现一条折现，且90左边较深
从代码角度来说：30的平衡因子为1, 90的平衡因子为-2

从感性角度认识，90的左子树太深（h+3）,我们先左旋降低左子树高度（h+2）.此时右子树太高，右旋降低右子树高度。

左右双旋的代码

左右双旋的条件是新节点插入较深左子树的右侧，在下图中也就是30的右侧，所以当h>=1的时候，我们插入可以在60的左边，也可以是右边。

我们如何区分这两种情况呢，很简单，使用平衡因子区分即可，两种插入会导致双旋之后 30和90 的平衡因子不同，而60的平衡因子一样，都是0.
在这里插入图片描述
很多同学到这里觉得的就完了，其实上面的图都是基于60存在的情况，如果60是新增节点呢（h=0）,这又是一种单独的情况。

void RotateLR(Node* parent) {
    
    

		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		int bf = subLR->_bf;

		RotateL(parent->_left);
		RotateR(parent);

		if (bf == -1) {
    
    
			subL->_bf = 0;
			parent->_bf = 1;
			subLR->_bf = 0;
		}
		else if (bf == 1) {
    
    
			parent->_bf = 0;
			subL->_bf = -1;
			subLR->_bf = 0;
		}
		else if (bf == 0) {
    
    
			parent->_bf = 0;
			subL->_bf = 0;
			subLR->_bf = 0;
		}
		else {
    
    
			assert(false);
		}

	}

新节点插入较深右子树的左侧—右左：先右单旋再左单旋

右左双旋的规则
在这里插入图片描述
基本步骤：
先对90进行右单旋，然后再对30进左单旋，旋转完成后再考虑平衡因子的更新。

右左双旋的条件

与之前的左右单旋相同，同学们也可以将h 取特殊值来验证上面的“抽象图”，这里限于篇幅，不再赘述了。
在这里插入图片描述

从图上直观来说：60 与 30,90 呈现一条折现，且90右边较深
从代码角度来说：30的平衡因子为2, 90的平衡因子为-1

从感性角度认识，90的右子树太深（h+3）,我们先右旋降低左子树高度（h+2）.此时左子树太高，右旋降低右子树高度。

右左双旋的代码

新节点插入较深右子树的左侧，我们就进行右左双旋。

所以当h>=1的时候，我们可以选择插入在60之下，左右都可以，但是我们要通过30和60的_bf 区分结果。
在这里插入图片描述
当h=0 的时候，只有30,90 两个节点，60作为新增节点出现


	void RotateRL(Node* parent) {
    
    

		Node* subR = parent->_right;
		Node* subRL = subR->_left;
		int bf = subRL->_bf;

		RotateR(parent->_right);
		RotateL(parent->_left);

		if (bf == 1) {
    
    

			subR->_bf = 0;
			parent->_bf = -1;
			subRL->_bf = 0;
		}
		else if (bf == -1) {
    
    

			parent->_bf = 0;
			subR->_bf = 1;
			subRL->_bf = 0;
		}
		else if (bf == 0) {
    
    
			parent->_bf = 0;
			subR->_bf = 0;
			subRL->_bf = 0;
		}
		else {
    
    
			assert(false);
		}

	}

4.1.3.2 AVL树的插入代码

完整代码：

bool Insert(const pair<K, V>& kv) {
    
    
		if (_root == nullptr) {
    
    
			_root = new Node(kv);
		    return true;
		}
		Node* parent = nullptr;
		Node* cur = _root;
		while (cur) {
    
    
			if (cur->_kv.first < kv.first) {
    
    
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_kv.first > kv.first) {
    
    
				parent = cur;
				cur = cur->_left;
			}
			else {
    
    
				return false; 
			}
		}
		cur = new Node(kv);

		if (parent->_kv.first < cur->_kv.first) {
    
    
			parent->_right = cur;
			cur->_parent = parent;
		}
		else {
    
    
			parent->_left = cur;
			cur->_parent = parent;
		}

		//控制树的平衡
		//插入一个节点之后，对于这个新节点祖先都有可能会有影响，但是还需要更具体的分析
		//1.插入更新的节点在父亲的左边，父亲平衡因子--
		//2.插入更新的节点在父亲的右边，父亲平衡因子++
		//3.父亲的平衡因子更新之后，是1或者-1,说明父亲所在的子树高度变化了,需要继续往上更新
		//4.父亲的平衡因子更新之后，是0，说明父亲所在的子树高度不变,不需要继续往上更新
		//5.更新之后，更新到了根节点，就不需要再更新
		//6.更新之后,父亲的平衡因子是2或者-2，说明父亲所在的子树已经不平衡了，需要旋转，让他平衡

		
		while (parent) {
    
    
			//更新平衡因子
			if (cur == parent->_left) {
    
    
				parent->_bf--;
			}
			else {
    
    
				parent->_bf++;
			}

			//检查父亲的平衡因子
			if (parent->_bf == 0) {
    
    
				break;
			}
			else if (parent->_bf == 1 || parent->_bf == -1) {
    
    

				cur = parent;
				parent = parent->_parent;
			}
			else if (parent->_bf == 2 || parent->_bf == -2) {
    
    
				//当出现不平衡，会有四种情况

				if (parent->_bf == -2 && cur->_bf == -1) {
    
    
					//右单旋
					RotateR(parent);
				}
				else if (parent->_bf == 2 && cur->_bf == 1) {
    
    
					//左单旋
					RotateL(parent);
				}

				//更新平衡因子的过程中，引发旋转的路径是直线 就是单旋
				//如果是折现,就是双旋

				else if (parent->_bf == -2 && cur->_bf == 1) {
    
    
					RotateLR(parent);

				}
				else if (parent->_bf == 2 && cur->_bf == -1) {
    
    
					RotateRL(parent);
				}
				else {
    
    
					assert(false);
				}
				break;

			}
			else {
    
    
				assert(false);
			}
		}
		return true;
	}

void RotateR(Node* parent) {
    
    
		Node* subL = parent->_left;
		Node* subLR = subL->_right;

		parent->_left = subLR;
		if (subLR) {
    
    
			subLR->_parent = parent;
		}
		Node* ppNode = parent->_parent;
		
		subL->_right = parent;
		parent->_parent = subL;

		if (parent == _root) {
    
    
			_root = subL;
			subL->_parent = nullptr;
		}
		else {
    
    
			if (ppNode->_left == parent) {
    
    
				ppNode->_left = subL;
			}
			else {
    
    
				ppNode->_right = subL;
			}
			subL->_parent = ppNode;
		}
		parent->_bf = subL->_bf = 0;
	}

	void RotateL(Node* parent) {
    
    
		Node* subR = parent->_right;
		Node* subRL = subR->_left;

		parent->_right = subRL;
		if (subRL) {
    
    
			subRL->_parent = parent;
		}
		Node* ppNode = parent->_parent;

		subR->_left = parent;
		parent->_parent = subR;

		if (parent == _root) {
    
    
			_root = subR;
			subR->_parent = nullptr;
		}
		else {
    
    
			if (ppNode->_left == parent) {
    
    
				ppNode->_left = subR;
			}
			else {
    
    
				ppNode->_right = subR;
			}
			subR->_parent = ppNode;
		}
		parent->_bf = subL->_bf = 0;
	}
	void RotateLR(Node* parent) {
    
    

		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		int bf = subLR->_bf;

		RotateL(parent->_left);
		RotateR(parent);

		if (bf == -1) {
    
    
			subL->_bf = 0;
			parent->_bf = 1;
			subLR->_bf = 0;
		}
		else if (bf == 1) {
    
    
			parent->_bf = 0;
			subL->_bf = -1;
			subLR->_bf = 0;
		}
		else if (bf == 0) {
    
    
			parent->_bf = 0;
			subL->_bf = 0;
			subLR->_bf = 0;
		}
		else {
    
    
			assert(false);
		}

	}

	void RotateRL(Node* parent) {
    
    

		Node* subR = parent->_right;
		Node* subRL = subR->_left;
		int bf = subRL->_bf;

		RotateR(parent->_right);
		RotateL(parent->_left);

		if (bf == 1) {
    
    

			subR->_bf = 0;
			parent->_bf = -1;
			subRL->_bf = 0;
		}
		else if (bf == -1) {
    
    

			parent->_bf = 0;
			subR->_bf = 1;
			subRL->_bf = 0;
		}
		else if (bf == 0) {
    
    
			parent->_bf = 0;
			subR->_bf = 0;
			subRL->_bf = 0;
		}
		else {
    
    
			assert(false);
		}

	}

4.1.4 AVL树的删除

因为AVL树也是二叉搜索树，可按照二叉搜索树的方式将节点删除，然后再更新平衡因子，只不错与删除不同的时，删除节点后的平衡因子更新，最差情况下一直要调整到根节点的位置。

删除较插入更加复杂，感兴趣的同学可以自行了解。之后我可能也会添加相关内容。

4.1.5 AVL树的验证

通过以下代码，我们可以验证我们写的AVL树是否平衡。

int Height(Node* root) {
    
    
		if (root == NULL) {
    
    
			return 0;
		}
		int left = Height(root->_left);
		int right = Height(root->_right);
		return max(left, right) + 1;

	}

	bool _IsBalance(Node* root) {
    
    
	
		if (root == nullptr) {
    
    
			return;
		}
		int leftHeight = Height(root->_left);
		int rightHeight = Height(root->_right);

		return abs(rightHeight - leftHeight) < 2
			&& _IsBalance(root->_left) && _IsBalance(root->_right);

	}

4.1.6 AVL树的性能

AVL树是一棵绝对平衡的二叉搜索树，其要求每个节点的左右子树高度差的绝对值都不超过1，这样可以保证查询时高效的时间复杂度，即。但是如果要对AVL树做一些结构修改的操作，性能非常低下，比如：
插入时要维护其绝对平衡，旋转的次数比较多，更差的是在删除时，有可能一直要让旋转持续到根的位置。因此：如果需要一种查询高效且有序的数据结构，而且数据的个数为静态的(即不会改变)，可以考虑AVL树，但一个结构经常修改，就不太适合

4.2 红黑树

4.2.1 红黑树的概念

由于AVLTree存在以上缺陷，于是，又有人发明出一种新的搜索二叉树，也就是广为人知的红黑树。

红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的。

4.2.2 红黑树的性质

红黑树具有五点重要的性质：

每个结点不是红色就是黑色
根节点是黑色的
如果一个节点是红色的，则它的两个孩子结点是黑色的
对于每个结点，从该结点到其所有后代叶结点的简单路径上，均包含相同数目的黑色结点
每个叶子结点都是黑色的(此处的叶子结点指的是空结点)

这五条性质就可以保证我们的红黑树的最长路径不超过最短路径的两倍。

4.2.3 红黑树节点的定义


enum Colour {
    
    
	BLACK,
	RED
};

template<class K, class V>
struct RBTreeNode {
    
    

	RBTreeNode<K, V>* _left;
	RBTreeNode<K, V>* _right;
	RBTreeNode<K, V>* _parent;

	Colour _col;
	pair<K, V> _kv;

	RBTreeNode(const pair<K, V>& kv)
		:_left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _col(RED)
		, _kv(kv)
	{
    
    }
};

4.2.4 红黑树的结构

在c++ stl 库中，为了后续实现关联式容器简单，红黑树的实现中增加一个头结点，因为跟节点必须为黑色，为了与根节点进行区分，将头结点给成黑色，并且让头结点的 pParent 域指向红黑树的根节点，pLeft域指向红黑树中最小的节点，_pRight域指向红黑树中最大的节点，如下：

在这里插入图片描述

4.2.5 红黑树的插入

与AVL树的插入类似，我们先按照搜索二叉树的规则进行插入，在插入之后，检查红黑树的平衡是否被被打破，如果打破，我们需要对红黑树进行节点的变色或者局部的旋转。

4.2.5.1 插入节点的颜色

在这之前，还有一个重要的问题，对于我们新插入的节点，我们应该设置为什么颜色？

如果我们插入黑色节点，那么该路径相较于其他路径必定多出一个黑色路径。此时违反了 规则四，即不同路径黑色数量相同。那么我们这时候想调整是是否困难。
如果我们插入红色节点。如果其父亲是黑色节点，那么红黑树未被破坏，不需要调整。如果其父节点是红色节点，此时违反了规则三，即红色节点的子节点要为黑色，需要我们调整，此时调整不影响其他路径，比较可行。

综上所述，插入节点统一设置为红色。

由此我们可以写出一部分代码，这部分与搜索二叉树基本相同：


bool Insert(const pair<K, V>& kv) {
    
    

		if (_root == nullptr) {
    
    
			_root = new Node(kv);
			_root->_col = BLACK;
			return true;
		}

		Node* parent = nullptr;
		Node* cur = _root;
		while (cur) {
    
    
			if (cur->_kv.first < kv.first) {
    
    
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_kv.first > kv.first) {
    
    
				parent = cur;
				cur = cur->_left;
			}
			else {
    
    
				return false;
			}
		}
		//新增节点，设置为红色，可能破坏规则三
		cur = new Node(kv);
		cur->_col = RED;

		if (parent->_kv.first < kv.first) {
    
    
			parent->_right = cur;
			cur->_parent = parent;
		}
		else {
    
    
			parent->_left = cur;
			cur->_parent = parent;
		}
		
}

4.2.5.2 调整红黑树平衡

接下来检测新节点插入后，红黑树性质是否遭到破坏。

我们约定:

cur为当前节点，parent(p)为父节点，grandpa(g)为祖父节点，uncle（u）为叔叔节点。
接下来的图，可能代表一颗完整的树，也可能是一颗子树

情况1： cur 为红，p为红，g为黑，存在且为红

此时一条路径上存在连续的红色节点，我们需要调整：
在这里插入图片描述

情况1.1： g是子树，存在父节点
将p和u 颜色改为黑色，g 改为红色，此时该局部是符合红黑树的性质的由于g是子树，如果g的父节点是红色，那么又违反了规则三，这就像一个套娃一样，我们可能需要一直调整到g为根节点。
在这里插入图片描述
我们也可以多画一步（如下图），看看是如何“套娃”？
可以看出，在这种情况下，我们的cur，parent,uncle，grandpa 是不断往上走动的，这也就导致了我们的cur 指向的不一定是我们真正的新增节点。换句话说，上面的“抽象图”所说的cur,不一定是真正的新增节点！
在这里插入图片描述

情况1.2： g是子树，存在父节点

与情况1.1相同，我只需要最后将 g 改为黑色即可，原因是我们要符合 性质二，根节点是黑色。

细心的同学可能已经意识到了，情况1.2就是情况1.1的“”终点”。
在这里插入图片描述

情况2: cur为红，p为红，g为黑，u不存在或者 u为黑（c,p,g 不在一条直线上）

抽象图：
在这里插入图片描述

情况2.1： u存在且为黑
在这里插入图片描述
这张抽象图十分奇怪，就算去掉"新增节点"cur,它依然不满足红黑树的性质，那么这张图错了吗，并不是，只是因为这张图是不完整的，cur也不是真正的新增节点。

那么完整的图应该是怎样的？如下图

我们将原始状态更新一次之后得到的图的橙色部分，就是我们之前的抽象图。同时，我们可以发现原始状态下绿色框内的节点分布与我们的情况1.1是一样的。

当然，所谓的完整的图也只是也只是我例举的一种比较简单情况，二叉树可能有很多层，但是，可以肯定的是，情况2.1 是由情况2.2 迭代而来的，且现在的cur 节点颜色原来一定是黑色，现在看到是红色是因为cur的子树在调整过程中将cur 节点的颜色由红色改为了黑色。
在这里插入图片描述

那么，情况2.1 又该如何调整？

p是g的左孩子，cur 为p的左孩子，则进行右单旋（如下图）
p为g的右孩子，cur为p的右孩子，则进行左单旋转 (没有画图)
p变黑，g变红

在这里插入图片描述

抽象图如下：
在这里插入图片描述

情况2.2： u不存在
在这里插入图片描述

与情况2.1 相比,如果u不存在，那么cur一定是新插入的节点，因为如果cur 不是新插入节点，那么cur与p一定一定有一个节点的颜色是黑色，这样就不满足性质4，即每条路径黑色节点个数相同。

那么情况2.1 又该如何调整？

p为g的左孩子，cur为p的左孩子，则进行右单旋转（如下图）；相反，p为g的右孩子，cur为p的右孩子，则进行左单旋转（没画图）
p变黑，g变红

情况3： cur为红，p为红，g为红，u不存在或者 u存在且为黑 （c,p,g 不在一条直线上）

抽象图：

在这里插入图片描述

情况 3.1 ： u存在且为黑
在这里插入图片描述

与情况2.1类似，我们看上图的时候发现去掉新增节点，原树并不符合红黑树性质，这也是因为抽象图并不完整，所以这里不再赘述，直接看图。

那么情况3.1 又该如何调整？

p为g的左孩子，cur为p的右孩子，则先对p左旋，此时变成情况2，再对g右旋（如下图）
p为g的右孩子，cur为p的左孩子，则先对p右旋，此时变成情况2，再对g左旋（没画图）

在这里插入图片描述

情况 3.2 ： u不存在

在这里插入图片描述
此时 cur 一定是新插入的节点。

同样，我们也是用双旋解决：

p为g的左孩子，cur为p的右孩子，则先对p左旋，此时变成情况2，再对g右旋（如下图）
p为g的右孩子，cur为p的左孩子，则先对p右旋，此时变成情况2，再对g左旋（没画图）

在这里插入图片描述

4.2.5.3 插入代码实现

bool Insert(const pair<K, V>& kv) {
    
    

		if (_root == nullptr) {
    
    
			_root = new Node(kv);
			_root->_col = BLACK;
			return true;
		}

		Node* parent = nullptr;
		Node* cur = _root;
		while (cur) {
    
    

			if (cur->_kv.first < kv.first) {
    
    
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_kv.first > kv.first) {
    
    
				parent = cur;
				cur = cur->_left;
			}
			else {
    
    
				return false;
			}
		}
		//新增节点，设置为红色，可能破坏规则三
		cur = new Node(kv);
		cur->_col = RED;

		if (parent->_kv.first < kv.first) {
    
    
			parent->_right = cur;
			cur->_parent = parent;
		}
		else {
    
    
			parent->_left = cur;
			cur->_parent = parent;
		}
		// 控制近似平衡

		while (parent && parent->_col == RED) {
    
    

			Node* grandfather = parent->_parent;

			if (parent == grandfather->_left) {
    
    
				Node* uncle = grandfather->_right;
				//情况一
				//uncle 存在且为红，进行变色处理
				if (uncle && uncle->_col == RED) {
    
    
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;

					cur = grandfather;
					parent = cur->_parent;

				}//情况二+三 ：uncle不存在，或者存在且为黑，需要旋转+变色处理
				else {
    
    
					//情况二： 单旋+变色
					if (cur = parent->_left) {
    
    
						RotateR(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;

					}//情况三： 双旋 + 变色
					else {
    
    
						RotateL(parent);
						RotateR(grandfather);
						cur->_col = BLACK;

						grandfather->_col = RED;
					}
					break;
				}
			}
			else {
    
    
				Node* uncle = grandfather->_left;
				if (uncle && uncle->_col == RED) {
    
    
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;

					cur = grandfather;
					parent = cur->_parent;
				}
				else {
    
    
					if (cur = parent->_right) {
    
    
						RotateL(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else {
    
    
						RotateR(parent);
						RotateL(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}
					break;
				}
			}

		}
		_root->_col = BLACK;
		return true;

	}
    void RotateR(Node* parent) {
    
    
		Node* subL = parent->_left;
		Node* subLR = subL->_right;

		parent->_left = subLR;
		if (subLR) {
    
    
			subLR->_parent = parent;
		}
		Node* ppNode = parent->_parent;

		subL->_right = parent;
		parent->_parent = subL;

		if (parent == _root) {
    
    
			_root = subL;
			subL->_parent = nullptr;
		}
		else {
    
    
			if (ppNode->_left == parent) {
    
    
				ppNode->_left = subL;
			}
			else {
    
    
				ppNode->_right = subL;
			}
			subL->_parent = ppNode;
		}

	}

	void RotateL(Node* parent) {
    
    
		Node* subR = parent->_right;
		Node* subRL = subR->_left;

		parent->_right = subRL;
		if (subRL) {
    
    
			subRL->_parent = parent;
		}
		Node* ppNode = parent->_parent;

		subR->_left = parent;
		parent->_parent = subR;

		if (parent == _root) {
    
    
			_root = subR;
			subR->_parent = nullptr;
		}
		else {
    
    
			if (ppNode->_left == parent) {
    
    
				ppNode->_left = subR;
			}
			else {
    
    
				ppNode->_right = subR;
			}
			subR->_parent = ppNode;
		}
	}

4.2.6 红黑树的删除

红黑树的删除本节不做讲解，有兴趣的同学可参考：《算法导论》或者《STL源码剖析》

4.2.7 红黑树的验证

我们可以写一个函数Is_Balance验证我们的红黑树是否正确：

void _InOrder(Node* root) {
    
    
		if (root == nullptr)return;
		_InOrder(root->_left);
		cout << root->_kv.first << " ";
		_InOrder(root->_right);
	}
	void InOrder() {
    
    

		_InOrder(_root);
	}

	bool Check(Node* cur) {
    
    
		if (cur == nullptr) {
    
    
			return true;
		}

		if (cur->_col == RED && cur->_parent->_col == RED) {
    
    
			cout << "违反规则三，存在连续的红色节点" << endl;
			return false;
		}

		return Check(cur->_left) && Check(cur->_right);
	}
	//检查每条路径的黑色节点个数
	bool CheckBlackNum(Node* cur, int blackNum, int benchmark) {
    
    
		if (cur == NULL) {
    
    
			if (blackNum != benchmark) {
    
    
				cout << "违反规则四，黑色节点的数量不相等" << endl;
				return false;
			}
			return true;
		}
		if (cur->_col == BLACK) {
    
    
			++blackNum;
		}
		return CheckBlackNum(cur->_left, blackNum, benchmark) &&
			CheckBlackNum(cur->_right, blackNum, benchmark);
	}

	bool IsBalance() {
    
    
		if (_root == nullptr) {
    
    
			return true;
		}
		if (_root->_col == RED) {
    
    
			cout << "根节点是红色，违反规则二" << endl;
			return false;
		}

		//算出最左路径的黑色节点数量作为基准值
		int benchmark = 0;
		Node* cur = _root;
		while (cur) {
    
    
			if (cur->_col == BLACK) {
    
    
				++benchmark;
			}
			cur = cur->_left;
		}

		int blackNum = 0;
		return Check(_root) && CheckBlackNum(_root, blackNum, benchmark);

	}

4.2.8 红黑树与AVL树的对比

红黑树和AVL树都是高效的平衡二叉树，增删改查的时间复杂度都是O( )，红黑树不追求绝对平衡，其只需保证最长路径不超过最短路径的2倍，相对而言，降低了插入和旋转的次数，所以在经常进行增删的结构中性能比AVL树更优，而且红黑树实现比较简单，所以实际运用中红黑树更多。

4.2.9 红黑树的应用

C++ STL库 – map/set、mutil_map/mutil_set
Java 库
linux内核
其他一些库

5. set与map 的模拟实现

我们用了三万多字（累），终于把set和map的使用与底层知识铺垫好了，接下来我们就可以开始写我们自己的set和map了！

5.1 红黑树的改造

我们之前在红黑树节点中存储的是pair结构，如果这样的话，map是没有问题的，set 就会出现问题，所以我们要改造我们的红黑树。

这里我不多废话，直接模仿原码的实现方式加以简化改造。

原码中使用一个 RBTree 同时实现了map和set，这是如何做到的呢？
我们为RBTree设置三个模板参数，K,T,KeyOfT.

template<class K, class T,class KeyOfT>

第一个模板参数K 代表key值。
第二个模板参数T 代表节点中存储的数据类型。对于map 是 pair<K,V>,set是K
第三个模板参数KeyOdT 表示一个仿函数，用法之后说。

看到这里同学们可能会有两个疑问：

第二个模板参数含K,那么第一个K 是不是冗余了？

并不会冗余，比如我们想实现Find 方法：
```
Node* Find(const K& key);
```
这个时候如果没有第一个模板参数，我们能用第二个参数实现吗？对于set来说，肯定是没有问题的，第二个参数就是K,对于map,第二个参数是pair<K,V>,我们可以从pair中取出 K的数值，却无法取出 K这个类型。所以，这时候我们只能专门传一个K 类型，也就是第一个模板参数。这个参数虽然对于冗余，但是对map 不可缺少。
反函数是如何帮助 RBTree 一树两用的？

由于在map 与set 给第二个模板传的参数不同，这也导致了节点中存储的东西是不同的，但是这对位于底层的红黑树来说是没有办法判定的，节点内容的类型对于底层就是一个“黑匣子”，无法判断，这也导致了一个问题，当我们在插入/删除等操作的时候，要比较节点Key 值得value ,这对于set来说没有障碍，但是如果是map,在我们没有重载大于、小于的情况下，pair之间无法直接比较key.

所以我们采用仿函数，就可以优雅地解决这个问题。
我们在set 写一个仿函数：
```
	struct SetKeyOfT {
      
      
		const K& operator()(const K& key) {
      
      
			return key;
		}
	};
```
在map中也写一个仿函数：
```
		struct MapKeyOfT {
      
      
			const K& operator()(const pair<const K, V>& kv) {
      
      
				return kv.first;
			}
		};
```
我们将这两个仿函数作为模板参数传给红黑树，那么如何使用？比如，我们要比较两个节点的key值：
```
	    KeyOfT kot;
		while (cur) {
      
      

			if (kot(cur->_data) < kot(data)) {
      
      
				parent = cur;
				cur = cur->_right;
			}
			else if (kot(cur->_data) > kot(data)) {
      
      
				parent = cur;
				cur = cur->_left;
			}
			else {
      
      
				return make_pair(iterator(cur), false);
			}
		}
```
此时我们的问题就完美解决了，仿函数会自动匹配类型，如果是set,调用SetKeyOfT，返回key值，如果是map,调用 SetOfMap, 返回pair 的第一个值，即key.

5.2 红黑树的迭代器

处理基本的增删查改之外，迭代器也是stl 的重要组件之一。

关于迭代器的基础设计问题，我在C++】手把手教你写出自己的list类中写的比较清楚了，不太清楚的同学可以看看。

对于红黑树来说，迭代器比较难的一点是如何实现 ++ / --,这个比较考验同学们的数据结构功底。

这里我们分析一下++，我们需要分情况讨论：

如果it 指向的节点的右子树不为空，下一个就++ 到右子树中序的第一个节点，也就是右子树的最左节点。（比如17 下一个访问 22）
如果it指向的节点的右子树为空，下一个++要访问的节点是沿着it指向节点根节点的路径中，孩子是父亲左的那个父亲节点。（比如11的下一个访问 13）


template<class T ,class Ref ,class Ptr>
struct RBTreeIterator
{
    
    
	typedef RBTreeNode<T> Node;
	typedef RBTreeIterator<T, Ref, Ptr> Self;
	Node* _node;

	RBTreeIterator(Node* node=nullptr)
		:_node(node)
	{
    
    }

	Ref operator*()
	{
    
    
		return _node->_data;
	}
	Ptr operator->()
	{
    
    
		return &_node->_data;
	}
	bool operator!=(const Self& s)const {
    
    
		return _node != s._node;
	}
	bool operator ==(const Self& s)const {
    
    
		return _node == s._node;
	}
	Self& operator++() {
    
    

		if (_node->_right) {
    
    
			//右子树中序的第一个节点，也就是右子树的最左节点
			Node* subLeft = _node->_right;
			while (subLeft->_left) {
    
    
				subLeft = subLeft->_left;
			}
			_node = subLeft;
		}
		else{
    
    
			// 当前子树已经访问完了，要去找祖先，沿着根节点的路径往上走，
			//找孩子是父亲左的那个父亲节点
			Node* cur = _node;
			Node* parent = cur->_parent;
			while (parent && parent->_right == cur) {
    
    
				cur = parent;
				parent = parent->_parent;
			}
			_node = parent;
		}
		return *this;
	}
	Self& operator--() {
    
    
		//和++基本是反过来的
		return *this;
	}
};

5.3 RBTree完整代码

#pragma once

enum Colour {
    
    

	BLACK,
	RED
};

template<class T>
struct RBTreeNode {
    
    

	RBTreeNode<T>* _left;
	RBTreeNode<T>* _right;
	RBTreeNode<T>* _parent;

	Colour _col;
	T _data;

	RBTreeNode(const T& data)
		:_left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _col(RED)
		, _data(data)
	{
    
    }
};

template<class T ,class Ref ,class Ptr>
struct RBTreeIterator
{
    
    
	typedef RBTreeNode<T> Node;
	typedef RBTreeIterator<T, Ref, Ptr> Self;
	Node* _node;

	RBTreeIterator(Node* node=nullptr)
		:_node(node)
	{
    
    }

	Ref operator*()
	{
    
    
		return _node->_data;
	}
	Ptr operator->()
	{
    
    
		return &_node->_data;
	}
	bool operator!=(const Self& s)const {
    
    
		return _node != s._node;
	}
	bool operator ==(const Self& s)const {
    
    
		return _node == s._node;
	}
	Self& operator++() {
    
    

		if (_node->_right) {
    
    
			//右子树中序的第一个节点，也就是右子树的最左节点
			Node* subLeft = _node->_right;
			while (subLeft->_left) {
    
    
				subLeft = subLeft->_left;
			}
			_node = subLeft;
		}
		else{
    
    
			// 当前子树已经访问完了，要去找祖先，沿着根节点的路径往上走，
			//找孩子是父亲左的那个父亲节点
			Node* cur = _node;
			Node* parent = cur->_parent;
			while (parent && parent->_right == cur) {
    
    
				cur = parent;
				parent = parent->_parent;
			}
			_node = parent;
		}
		return *this;
	}
	Self& operator--() {
    
    
		//和++基本是反过来的
		return *this;
	}
};

// T->K set
// T->pair<const K,V>map

template<class K, class T,class KeyOfT>
class RBTree
{
    
    
	typedef RBTreeNode<T> Node;
public:
	typedef RBTreeIterator<T, T&, T*>iterator;
	typedef RBTreeIterator<T, const T&, const T*> const_iterator;

	iterator begin() {
    
    
		
		Node* left = _root;
		while (left && left->_left) {
    
    
			left = left->_left;
		}
		//return left;
		return iterator(left);
	}
	iterator end() {
    
    
		return iterator(nullptr);
	}

	RBTree()
		:_root(nullptr)
	{
    
    }
	//拷贝构造
	//赋值重载
	//析构
	
	Node* Find(const K& key) {
    
    

	}

	pair<iterator,bool> Insert(const T& data) {
    
    

		if (_root == nullptr) {
    
    
			_root = new Node(data);
			_root->_col = BLACK;
			return make_pair(iterator(_root),true);
		}
		KeyOfT kot;
		Node* parent = nullptr;
		Node* cur = _root;
		while (cur) {
    
    

			if (kot(cur->_data) < kot(data)) {
    
    
				parent = cur;
				cur = cur->_right;
			}
			else if (kot(cur->_data) > kot(data)) {
    
    
				parent = cur;
				cur = cur->_left;
			}
			else {
    
    
				return make_pair(iterator(cur), false);
			}
		}
		//新增节点，设置为红色，可能破坏规则三
		cur = new Node(data);
		Node* newnode = cur;
		cur->_col = RED;

		if (kot(parent->_data) < kot(data)) {
    
    
			parent->_right = cur;
			cur->_parent = parent;
		}
		else {
    
    
			parent->_left = cur;
			cur->_parent = parent;
		}
		// 控制近似平衡

		while (parent && parent->_col == RED) {
    
    

			Node* grandfather = parent->_parent;

			if (parent == grandfather->_left) {
    
    
				Node* uncle = grandfather->_right;
				//情况一
				//uncle 存在且为红，进行变色处理
				if (uncle && uncle->_col == RED) {
    
    
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;

					cur = grandfather;
					parent = cur->_parent;

				}//情况二+三 ：uncle不存在，或者存在且为黑，需要旋转+变色处理
				else {
    
    
					//情况二： 单旋+变色
					if (cur = parent->_left) {
    
    
						RotateR(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;

					}//情况三： 双旋 + 变色
					else {
    
    
						RotateL(parent);
						RotateR(grandfather);
						cur->_col = BLACK;

						grandfather->_col = RED;
					}
					break;
				}
			}
			else {
    
    
				Node* uncle = grandfather->_left;
				if (uncle && uncle->_col == RED) {
    
    
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;

					cur = grandfather;
					parent = cur->_parent;
				}
				else {
    
    
					if (cur = parent->_right) {
    
    
						RotateL(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else {
    
    
						RotateR(parent);
						RotateL(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}
					break;
				}
			}

		}
		_root->_col = BLACK;
		return make_pair(iterator(newnode), true);

	}
	void RotateR(Node* parent) {
    
    
		Node* subL = parent->_left;
		Node* subLR = subL->_right;

		parent->_left = subLR;
		if (subLR) {
    
    
			subLR->_parent = parent;
		}
		Node* ppNode = parent->_parent;

		subL->_right = parent;
		parent->_parent = subL;

		if (parent == _root) {
    
    
			_root = subL;
			subL->_parent = nullptr;
		}
		else {
    
    
			if (ppNode->_left == parent) {
    
    
				ppNode->_left = subL;
			}
			else {
    
    
				ppNode->_right = subL;
			}
			subL->_parent = ppNode;
		}
		
	}

	void RotateL(Node* parent) {
    
    
		Node* subR = parent->_right;
		Node* subRL = subR->_left;

		parent->_right = subRL;
		if (subRL) {
    
    
			subRL->_parent = parent;
		}
		Node* ppNode = parent->_parent;

		subR->_left = parent;
		parent->_parent = subR;

		if (parent == _root) {
    
    
			_root = subR;
			subR->_parent = nullptr;
		}
		else {
    
    
			if (ppNode->_left == parent) {
    
    
				ppNode->_left = subR;
			}
			else {
    
    
				ppNode->_right = subR;
			}
			subR->_parent = ppNode;
		}
	}

	void _InOrder(Node* root) {
    
    
		if (root == nullptr)return;
		_InOrder(root->_left);
		cout << root->_kv.first << " ";
		_InOrder(root->_right);
	}
	void InOrder() {
    
    

		_InOrder(_root);
	}

	bool Check(Node* cur) {
    
    
		if (cur == nullptr) {
    
    
			return true;
		}

		if (cur->_col == RED && cur->_parent->_col == RED) {
    
    
			cout << "违反规则三，存在连续的红色节点" << endl;
			return false;
		}

		return Check(cur->_left) && Check(cur->_right);
	}
	//检查每条路径的黑色节点个数
	bool CheckBlackNum(Node* cur, int blackNum, int benchmark) {
    
    
		if (cur == NULL) {
    
    
			if (blackNum != benchmark) {
    
    
				cout << "违反规则四，黑色节点的数量不相等" << endl;
				return false;
			}
			return true;
		}
		if (cur->_col == BLACK) {
    
    
			++blackNum;
		}
		return CheckBlackNum(cur->_left, blackNum, benchmark) &&
			CheckBlackNum(cur->_right, blackNum, benchmark);
	}

	bool IsBalance() {
    
    
		if (_root == nullptr) {
    
    
			return true;
		}
		if (_root->_col == RED) {
    
    
			cout << "根节点是红色，违反规则二" << endl;
			return false;
		}

		//算出最左路径的黑色节点数量作为基准值
		int benchmark = 0;
		Node* cur = _root;
		while (cur) {
    
    
			if (cur->_col == BLACK) {
    
    
				++benchmark;
			}
			cur = cur->_left;
		}

		int blackNum = 0;
		return Check(_root) && CheckBlackNum(_root, blackNum, benchmark);

	}
private:
	Node* _root;
};

5.4 map 的模拟实现

#pragma once
#include"RBTree.h"
namespace yyk {
    
    
	template<class K,class V>
	class map 
	{
    
    
		struct MapKeyOfT {
    
    
			const K& operator()(const pair<const K, V>& kv) {
    
    
				return kv.first;
			}
		};
	public:
		typedef typename RBTree<K, pair<const K, V>, MapKeyOfT>::iterator iterator;
		iterator begin()
		{
    
    
			return _t.begin();
		}
		iterator end() {
    
    
			return _t.end();
		}
		pair<iterator,bool> insert(const pair<const K, V>& kv) {
    
    
			return _t.Insert(kv);
		}
		V& operator[](const K& key) {
    
    
			pair<iterator, bool>ret = _t.Insert(make_pair(key, V()));
			return ret.first->second;
		}

	private:
		RBTree<K, pair<const K, V>, MapKeyOfT>_t;
	};


	void test_map()
	{
    
    
		map<string, string>dict;
		dict.insert(make_pair("sort", "排序"));
		dict.insert(make_pair("string", "字符串"));
		dict["string"] = "hahah";

		map<string, string>::iterator it = dict.begin();
		while (it != dict.end()) {
    
    
			cout << it->first << " " << it->second << endl;
			++it;
		}
		cout << endl;

	}
}

5.5 set的模拟实现

#pragma once
#include"RBTree.h"
namespace yyk {
    
    
	template<class K>
	class set
	{
    
    
	
		struct SetKeyOfT {
    
    
			const K& operator()(const K& key) {
    
    
				return key;
			}
		};
	public:
		typedef typename RBTree<K, K, SetKeyOfT>::iterator iterator;

		iterator begin() {
    
    
			return _t.begin();
		}
		iterator end() {
    
    
			return _t.end();
		}
		pair<iterator,bool> insert(const K& key) {
    
    
			return _t.Insert(key);
		}

	private:
		RBTree<K, K, SetKeyOfT>_t;
	};
	void test_set()
	{
    
    
		set<int>s;
		s.insert(1);
		s.insert(3);
		s.insert(4);
		s.insert(5);
		s.insert(6);
		set<int>::iterator it = s.begin();
		while (it != s.end()) {
    
    
			cout << *it << " ";
			++it;
		}
	}
}

【C++】手把手教你实现自己的set 和map

目录

1. 关联式容器

2. 键值对

2.1 键值对的概念

2.2 pair

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

3.1 set

3.1.1 set 简介

3.1.2 set 的使用

3.1.2.1 set的模板参数列表

3.1.2.2 set的构造函数

3.1.2.3 set的迭代器

3.1.2.4 set 的容量

3.1.2.5 set修改操作

3.1.2.6 使用举例

3.2 map

3.2.1 map简介

3.2.2 map的使用

3.2.2.1 map的模板参数说明

3.2.2.2 map 的构造函数

3.2.2.3 map的迭代器

3.2.2.4 map 的容器与元素访问

3.2.2.5 map 中元素的修改

3.2.2.6 使用举例

3.2.2.7 map对[ ]的重载原理

3.3 multiset

3.3.1 multiset简介

3.3.2 multiset 的使用

3.3.2 使用举例

3.4 multimap

3.4.1 简介

3.4.2 multimap的使用

4. 底层结构

4.1 AVL树

4.1.1 AVL树的概念

4.1.2 AVL树的节点的定义

4.1.3 AVL树的 插入

4.1.3.1 插入的思路

4.1.3.2 AVL树的 旋转

4.1.3.2 AVL树的 插入代码

4.1.4 AVL树的 删除

4.1.5 AVL树的 验证

4.1.6 AVL树的 性能

4.2 红黑树

4.2.1 红黑树的概念

4.2.2 红黑树的性质

4.2.3 红黑树节点的定义

4.2.4 红黑树的结构

4.2.5 红黑树的 插入

4.2.5.1 插入节点的颜色

4.2.5.2 调整红黑树平衡

情况1： cur 为红，p为红，g为黑，存在且为红

情况2: cur为红，p为红，g为黑，u不存在 或者 u为黑（c,p,g 不在一条直线上）

情况3： cur为红，p为红，g为红，u不存在 或者 u存在且为黑 （c,p,g 不在一条直线上）

4.2.5.3 插入代码实现

4.2.6 红黑树的 删除

4.2.7 红黑树的 验证

4.2.8 红黑树与AVL树的对比

4.2.9 红黑树的应用

5. set与map 的模拟实现

5.1 红黑树的改造

5.2 红黑树的迭代器

5.3 RBTree完整代码

5.4 map 的模拟实现

5.5 set的模拟实现

猜你喜欢

4.1.3 AVL树的插入

4.1.3.2 AVL树的旋转

4.1.3.2 AVL树的插入代码

4.1.4 AVL树的删除

4.1.5 AVL树的验证

4.1.6 AVL树的性能

4.2.5 红黑树的插入

情况2: cur为红，p为红，g为黑，u不存在或者 u为黑（c,p,g 不在一条直线上）

情况3： cur为红，p为红，g为红，u不存在或者 u存在且为黑（c,p,g 不在一条直线上）

4.2.6 红黑树的删除

4.2.7 红黑树的验证