setmapAVL树红黑树

关联式容器
树形结构的关联式容器
set
- set的模板参数列表
- set的构造函数
- set的迭代器
- set的容量操作
- set其他操作
multiset
map
键值对
- map的模板参数列表
- map的迭代器
- map中元素的修改
- map的容量与元素访问
multimap
底层结构
avl树
- avl树概念
- AVL树结点的定义
- AVL树的插入
- AVL树的旋转
- AVL树的验证
- AVL树的性能
红黑树
- 红黑树概念
- 红黑树的性质
- 红黑树的插入操作
- 红黑树的验证
- 红黑树与AVL树比较
简单模拟实现set和map
- 改造红黑树
- set的模拟实现
- 模拟实现map

关联式容器

vector、list、deque、forward_list（c++11）等这些容器称为序列式容器。
因为其底层为线性序列的数据结构，里面存储的是元素本身。

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

树形结构的关联式容器

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

set

set文档介绍
翻译：

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

set中的元素是不允许修改的，set的迭代器和const迭代器都是const迭代器。

set的模板参数列表

template < class T,                        // set::key_type/value_type
           class Compare = less<T>,        // set::key_compare/value_compare
           class Alloc = allocator<T>      // set::allocator_type
           > class set;

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

set的构造函数

//empty (1)	: 构造空的set
explicit set (const key_compare& comp = key_compare(),
              const allocator_type& alloc = allocator_type());
//range (2)	：用[first,last)区间中的元素构造set
template <class InputIterator>
  set (InputIterator first, InputIterator last,
       const key_compare& comp = key_compare(),
       const allocator_type& alloc = allocator_type());
//copy (3)	：set的拷贝构造
set (const set& x);

set的迭代器

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

set的容量操作

函数声明	功能介绍
bool empty() cosnt	检测set是否为空，为空返回true；否则返回
iterator end()	返回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位置上的元素
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的元素的个数

set其他操作

find

iterator find (const value_type& val) const;
返回值：
	成功返回一个指向要查找元素的迭代器；失败则返回std::end

void test_find()
{
	set<int> s;
	s.insert(3);
	s.insert(2);
	s.insert(4);
	s.insert(5);
	s.insert(1);
	set<int>::iterator pos = s.find(5);
	if (pos != s.end())
	{
		cout << "找到了：" << *pos << endl;
	}
	cout << endl;
	s.erase(s.find(3));
	for (auto e : s)
	{
		cout << e <<" ";
	}
	cout << endl;
}
//输出：
//找到了：5
//
//1 2 4 5
//

count

功能：判断所要查找的元素在不在set中。
size_type count (const value_type& val) const;
返回值：
	成功返回1；失败则返回0.

void test_count()
{
	set<int> s;
	s.insert(3);
	s.insert(2);
	s.insert(4);
	s.insert(5);
	s.insert(1);
	set<int>::iterator pos = s.find(5);
	if (s.count(5))
	{
		cout << *pos << " 找到了" << endl;
	}
}
//输出：
//5 找到了
//

lower_bound && upper_bound

功能：返回给定值在set中第一个大于等于该值的迭代器                    	功能：返回给定值在set中第一个大于该值的迭代器
iterator lower_bound (const value_type& val) const;			    iterator upper_bound (const value_type& val) const;**

void test_bound()
{
	set<int> myset;
	set<int>::iterator itlow, itup;

	for (int i = 1; i < 10; i++)
	{
		myset.insert(i * 10);
	}
	//myset:10 20 30 40 50 60 70 80 90

	itlow = myset.lower_bound(35);
	itup = myset.upper_bound(60);
	cout << "itlow: " << *itlow << endl;
	cout << "itlow: " << *itup << endl;
	myset.erase(itlow, itup);//erase是左闭右开的，[40, 70)
	//迭代器对于区间的控制，要求区间必须是左闭右开。所以取下边界用lower_bound，取上边界用upper_bound
	for (auto e : myset)
	{
		cout << e << " ";
	}
	cout << endl;
}
//输出：
//itlow: 40
//itlow: 70
//10 20 30 70 80 90
//

equal_range

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

void test_equal_range()
{
	set<int> myset;
	set<int>::iterator itlow, itup;

	for (int i = 1; i < 10; i++)
	{
		myset.insert(i * 10);
	}
	//myset:10 20 30 40 50 60 70 80 90
	pair<set<int>::const_iterator, set<int>::const_iterator> ret;
	ret = myset.equal_range(30);
	itlow = ret.first;
	itup = ret.second;
	cout << "itlow: " << *itlow << endl;
	cout << "itlow: " << *itup << endl;
}
//输出：
//itlow: 30
//itlow: 40
//

multiset

multiset文档介绍
翻译：

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

注意：
multiset的插入接口中只需要插入即可。
在multiset中找某个元素时间复杂度为： $O(log_2N)$
multiset的作用可以对元素进行排序。

void test_multiset()
{
	multiset<int> s;
	s.insert(3);
	s.insert(2);
	s.insert(3);
	s.insert(4);
	s.insert(3);
	s.insert(5);
	s.insert(1);
	s.insert(3);
	for (auto e : s)
	{
		cout << e << " ";
	}
	cout << endl;

	cout << "cout:" << s.count(3) << endl;
	
	pair<set<int>::const_iterator, set<int>::const_iterator> ret = s.equal_range(3);
	set<int>::iterator itlow = ret.first;
	set<int>::iterator itup = ret.second;
	cout << "itlow: " << *itlow << endl;
	cout << "itlow: " << *itup << endl;

	s.erase(itlow, itup);
	for (auto e : s)
	{
		cout << e << " ";
	}
	cout << endl;
}
//输出：

//1 2 3 3 3 3 4 5
//cout:4
//itlow: 3
//itlow: 4
//1 2 4 5
//

map

map文档介绍

翻译：

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

键值对

set中是将set的普通迭代器typedef成const迭代器，从而致使set中的元素无法被修改。
但map不能采用这种一刀切的手法，map只少要能修改value。

所以map用一个名为pair的键值对来对数据进行存储。

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

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

比如：英汉互译的字典，字典中必然有英文单词和对应的中文译义。而且，英文单词与中文译义是一一对应的关系，即通过英文单词，就可以在字典中查找到其对应的中文译义。

void dict()
{
	map<string, string> dict;//这里的第一个string，不用特意写成const，map内部会自动转换
	pair<string, string>kv1("insert", "插入");
	dict.insert(kv1);
	dict.insert(pair<string, string>("sort", "排序"));
	dict.insert(make_pair("string", "字符串"));//C++98
	dict.insert({ "iterator","迭代器" });//C++11支持了多参数类型的隐式类型转换，这样子写等价于调用pair
}

map的模板参数列表

template < class T,                        // multiset::key_type/value_type
           class Compare = less<T>,        // multiset::key_compare/value_compare
           class Alloc = allocator<T> >    // multiset::allocator_type
           > class multiset;

key：键值对中key的类型
T：键值对中value的类型
Compare：比较器的类型

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所指向的元素不能修改

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)区间中的元素
vodi 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中

//统计次数
void test_count()
{
	string arr[] = { "西瓜", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜", "苹果", "香蕉" };
	map<string, int> countMap;
	for (auto e : arr)
	{
		auto it = countMap.find(e);
		if (it == countMap.end())
		{
			countMap.insert(make_pair(e, 1));
		}
		else
		{
			it->second++;
		}
	}
	for (const auto& kv : countMap)
	{
		cout << kv.first << ":" << kv.second << endl;
	}
}
//输出：
//苹果:4
//西瓜:4
//香蕉:1
//

map的容量与元素访问

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

map::operator[]

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

在这里插入图片描述
map的[]，接受的是key，返回的是value。

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

//所以对于上面的统计次数代码可以用[]来进行简化
void test_count()
{
	string arr[] = { "西瓜", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜", "苹果", "香蕉" };
	map<string, int> countMap;
	//for (auto e : arr)
	//{
	//	auto it = countMap.find(e);
	//	if (it == countMap.end())
	//	{
	//		countMap.insert(make_pair(e, 1));
	//	}
	//	else
	//	{
	//		it->second++;
	//	}
	//}
	for (auto e : arr)
	{
		countMap[e]++;
	}
	for (const auto& kv : countMap)
	{
		cout << kv.first << ":" << kv.second << endl;
	}
}
//输出：
//苹果:4
//西瓜:4
//香蕉:1
//

//[]的运用
void test_map2()
{
	map<string, string>dict;
	dict.insert(make_pair("string", "字符串"));
	dict.insert(make_pair("sort", "排序"));
	dict.insert(make_pair("insert", "插入"));

	cout << dict["sort"] << endl;//查找和读
	dict["map"];//插入
	dict["map"] = "映射";//修改
	dict["insert"] = "xxx";//修改
	dict["set"] = "集合";//插入+修改

	for (const auto& kv : dict)
	{
		cout << kv.first << ":" << kv.second << endl;
	}
}
//输出：
//排序
//insert:xxx
//map:映射
//set:集合
//sort:排序
//string:字符串
//

multimap

multimap文档
翻译：

multimap是关联式容器，他按照特定的顺序，存储由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是可以重复的。
multimap中的接口可以参考map，功能都是类似的。

底层结构

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

avl树

avl树概念

二叉搜索树随可以缩短查找的效率，但如果数据有序或者接近有序二叉搜索树将退化成单支树，查找元素相当于再顺序表中搜索元素，效率低下。
在这里插入图片描述

数据有序或者接近有序二叉搜索树将退化成单支树

因此，有一种解决上述问题的方法：当想二叉搜索树中插入新节点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1（需要对树中的结点进行调整），即可降低树的高度，从而减少平均搜索长度。
一棵AVL树或者是空树，或者是具有以下性质的二叉搜索树：

它的左右子树都是AVL树
左右子树高度之差（简称平衡因子）的绝对值不超过1（-1/0/1）

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

在这里插入图片描述

AVL树结点的定义

template<class T>

struct AVLTreeNode//如果用class 记得给public
{
	AVLTreeNode(const T& data)
		:_pLeft(nullptr)
		,_pRight(nullptr)
		,_pParent(nullptr)
	{}
	AVLTreeNode<T>* _pleft;//该节点的左孩子
	AVLTreeNode<T>* _pright;//该节点的右孩子
	AVLTreeNode<T>* _pParent;//该节点的双亲
	T _data;
	int _bf;//该节点的平衡因子//balance factor
};

AVL树的插入

AVL树就是在二叉搜索树的基础上引入了平衡因子，因此AVL树也可以看成是二叉搜索树。
那么AVL树的插入的插入过程可以分成两步：
1.按照二叉搜索树的方式插入新节点
2.调整节点的平衡因子

在这里插入图片描述

template<class K, class V>
class AVLTree
{
	typedef AVLTreeNode<K, V> Node;
public:
	bool Insert(const pair<K, V>& kv)
	{
		if (_root == nullptr)
		{
			_root = new Node(kv);
			return true;
		}
		//1. 按照二叉搜索树的方式插入新节点
		Node* cur = _root;
		while (cur)
		{
			if (cur->_kv.first < kv.first)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_kv.first > kv.frist)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				return false;
			}
		}

		cur = new Node(kv);
		if (parent->_kv.first < kv.first)//与父节点比较，大于父节点放右边
		{
			parent->_right = cur;
		}
		else//if (parent->_kv.first > kv.fist)//小于父节点放左边
		{
			parent->_left = cur;
		}
		cur->_parent = parent;//保存父节点

		//控制平衡
		//更新平衡因子
		while (parent)
		{
			//更新双亲的平衡因子
			if (cur == parent->_left)
			{
				parent->_bf--;
			}
			else //if (cur == parent->_right)
			{
				parent->_bf++;
			}
			if (parent->_bf == 0)
			{
				//更新结束
				break;
			}
			else if (parent->_bf == 1 || parent->_bf == -1)
			{
				//继续往上更新
				break;
			}
			else if (parent->_bf == 2 || parent->_bf == -2)
			{
				//子树不平衡了，需要旋转
				break;//平衡后会降低这个子树的高度，所以满足break的条件
			}
			else
			{
				assert(false);
			}
		}
		return true;
	}

AVL树的旋转

如果在一颗原本是平衡的AVL树中插入一个新节点，可能造成不平衡，此时必须调整书的结构，使之平衡化。

旋转的时候需要注意的问题：
1. 保持他依旧是搜索树
2. 变成平衡树且降低这个子树的高度

根据节点插入位置的不同，AVL树的旋转分为四种：

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

左单旋

void RotateL(Node* parent)
	{
		Node* cur = parent->_right;
		Node* curleft = cur->_left;

		parent->_right = curleft;
		if (curleft)//curLeft可能为空
		{
			curleft->_parent = parent;
		}

		cur->_left = parent;
		Node* ppnode = parent->_parent;//ppnode == parent's parent
		parent->_parent = cur;

		if (parent == _root)//判断这棵树是不是子树
		{
			_root = cur;
			cur->_parent = nullpptr;//根节点的父节点指向空
		}
		else//这颗不平衡的树是一颗子树
		{//还得判断这颗子树在其父节点的左边还是右边
			if (ppnode->_left = parent)//左
			{
				ppnode->_left = cur;
			}
			else//右
			{
				ppnode->_right = cur;
			}
			cur->_parent = ppnode;
		}
		parent-> _bf = cur->_bf = 0;
	}

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

右单旋

void RotateR(Node* parent)
	{
		Node* cur = parent->_left;
		Node* curRight = cur->_right;

		parent->_left = curRight;
		if (curRight)//curLeft可能为空
		{
			curRight->_parent = parent;
		}

		cur->_right = parent;
		Node* ppnode = parent->_parent;//ppnode == parent's parent
		parent->_parent = cur;

		if (parent == _root)//判断这棵树是不是子树
		{
			_root = cur;
			cur->_parent = nullptr;//根节点的父节点指向空
		}
		else//这颗不平衡的树是一颗子树
		{//还得判断这颗子树在其父节点的左边还是右边
			if (ppnode->_left == parent)//左
			{
				ppnode->_left = cur;
			}
			else//右
			{
				ppnode->_right = cur;
			}
			cur->_parent = ppnode;
		}
		parent->_bf = cur->_bf = 0;
	}

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

右左单旋

	void RotateRL(Node* parent)
	{
		Node* cur = parent->_right;
		Node* curleft = cur->_left;
		int bf = curleft->_bf;

		RotateR(parent->_right);
		RotateL(parent);
		if (bf == 0)
		{
			cur->_bf = 0;
			curleft->_bf = 0;
			parent->_bf = 0;
		}
		else if (bf == -1)
		{
			cur->_bf = 0;
			curleft->_bf = 0;
			parent->_bf = -1;
		}
		else if (bf == 1)
		{
			cur->_bf = 1;
			curleft->_bf = 0;
			parent->_bf = -1;
		}
		else
		{
			assert(false);
		}
	}

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

右左单旋

void RotateLR(Node* parent)
	{
		Node* cur = parent->_left;
		Node* curRight = cur->_left;
		int bf = curRight->_bf;

		RotateL(parent->_left);
		RotateR(parent);
		
		if (bf == 0)
		{
			parent->_bf = 0;
			cur->_bf = 0;
			curRight->_bf = 0;
		}
		else if (bf == -1)
		{
			parent->_bf = 1;
			cur->_bf = 0;
			curRight->_bf = 0;
		}
		else if (bf == 1)
		{
			parent->_bf = 0;
			cur->_bf = -1;
			curRight->_bf = 0;
		}
	}

总结
假设以parent为根的子树不平衡，即parent的平衡因子为-2或2，可分以下情况考虑

parent的平衡因子为2，说明parent的右子树高，设parent的右子树的根为curRight

当curRight的平衡因子为1时，执行左单旋
当curRight的平衡因子为-1时，执行右左双旋

parent的平衡因子为-2时，说明parent的左子树高，设parent的左子树的根为curLeft

当curLeft的平衡因子为-1时，执行右单旋
当curleft的平衡因子为1时，执行左右双旋

AVL树的验证

AVL树是在二叉搜索树的基础上加入了平衡性的限制，因此要验证AVL树，可以分两步走：

验证其位二叉搜索树

如果中序遍历的到了一个有序的序列，就说明是二叉搜索树

验证其为平衡树

每个节点子树的高度的绝对值不超过1
节点的平衡因子是否计算正确

int Height()
	{
		return Height(_root);
	}

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

		return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
	}

	bool IsBalance()
	{
		return _IsBalance(_root);
	}
	
	bool _IsBalance(Node* root)//确认树是不是平衡的	
	{
		if (root == nullptr)//空树姑且也算平衡的
		{
			return true;
		}
		int leftHeight = Height(root->_left);//左子树高度=
		int rightHeight = Height(root->_right);//右子树高度

		if (rightHeight - leftHeight != root->_bf)//检测一下之前写的平衡因子对不对
		{
			cout << "平衡因子异常" << root->_kv.first << "->" << root->_bf << endl;
		}
		return false;

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

AVL树的性能

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

红黑树

红黑树概念

红黑树，是一种二叉搜索树，但在每个节点上增加一个存储位以表示节点的颜色，可以是红色或者黑色。通过任何一条从根到叶子的路径上各个节点颜色的限制，红黑树确保没有一条路径会比其他路径长出两倍，因而是接近平衡的。
在这里插入图片描述

红黑树中最短的路径：红节点最少的路径
最长的路径：一黑一红相间的路径

红黑树的性质

每个节点不是红色就是黑色
根节点是黑色的
如果一个节点是红色的，则他的两个孩子节点是黑色的（任何路径没有连续的红色节点）
对于每个节点，从该节点到其所有后代叶节点的简单路径上，均包含数目相同的黑色节点（每条路径上的黑色节点的数量相等）
每个叶子节点都是黑色的，这里的叶子节点指的是空节点–NIL（NIL叶节点都是黑色的）

红黑树的插入操作

红黑树是在二叉搜索树的基础上加入其限制平衡条件，因此红黑树的插入课分为两步：
1.按照二叉搜索树的规则插入节点
2.检测新节点插入后，红黑树的性质是否遭到破坏
因为新节点默认的颜色是红色，因此：
如果其父节点的颜色是黑色，则没有违反红黑树的任何性质，则不需要调整
但当新插入节点的父节点颜色为红色时，就违反了性质3（不能有连在一起的红色节点）。此时就需要对红黑树分情况讨论。
约定：cur为当前节点、p为父节点、g为祖父节点、u为叔叔节点

情况一：cur为红，p为红，g为黑，u存在且为红
ps：此处的树，可能是一棵完整的树，也可能是一颗子树
解决方式：将p、u改为黑色，g改为红。然后把g当成cur，继续向上调整。
在这里插入图片描述

情况一

如果g是根节点。调整完以后，需要将g改为黑色。
如果g是子树，g一定有父节点。且g的父节点如果是红色，则需要继续向上调整。
在这里插入图片描述

情况一

情况二:cur为红，p为红，g为黑，u不存在/u为黑
u的情况有两种：
1.如果u不存在，则cur一定是新插入的节点。因为如果cur不是新插入的节点，则cur和p一定有一个节点的颜色是黑色，就不满足性质四（每条路径黑色节点个数相同）
2.如果u节点存在，则其一定是黑色的，那么cur节点原来的颜色一定是黑色的。
解决方式：
1.p为g的左孩子，cur为p的左孩子，则进行右单旋转
2.p为g的右孩子孩子，cur为p的右孩子，则进行左单旋转

在这里插入图片描述

情况二：p为g的左孩子，cur为p的左孩子

在这里插入图片描述

情况二：p为g的右孩子孩子，cur为p的右孩子

bool Insert(const pair<K, V>& kv)
	{
		//按照二叉搜索树的方式插入新节点... 
		//新节点插入后，如果其双亲节点的颜色为空色，则违反性质3(不能有连在一起的红色结点)
		while (parent && parent->_color == RED)
		{
			Node* grandfather = parent->_parent;
			if (parent == grandfather->_left)
			{
				Node* uncle = grandfather->_right;
				//u存在且为红
				if (uncle && uncle->_col == RED)
				{
					//变色
					parent->_color = uncle->_color = BLACK;
					grandfather->_color = RED;
					//继续向上处理
					cur = grandfather;
					parent = cur->_parent;
				}
				else//u不存在或存在且为黑
				{
					if (cur == parent->_left)
					{
						RotateR(grandfather);
						parent->_color = BLACK;
						grandfather->_color = RED;
					}
					else
					{
						RotateL(parent);
						RotateR(grandfather);
						cur->_color = BLACK;
						grandfather->_color = RED;
					}
				}
			}
			else// if(parent == grandfather->_right)
			{
				Node* uncle = grandfather->_left;
				//u存在且为红
				if (uncle && uncle->_col == RED)
				{
					//变色
					parent->_color = uncle->_color = BLACK;
					grandfather->_color = RED;
					//继续向上处理
					cur = grandfather;
					parent = cur->_parent;
				}
				else//u不存在或存在且为黑
				{
					if (cur == parent->_right)
					{
						RotateL(grandfather);
						parent->_color = BLACK;
						grandfather->_color = RED;
					}
					else
					{
						RotateR(parent);
						RotateL(grandfather);
						cur->_color = BLACK;
						grandfather->_color = RED;
					}

					break;
				}
			}
		}
		_root->_color = RED;
		return true;
	}
	
	//复用AVL树的左单旋
	void RotateL(Node* parent)
	{
		Node* cur = parent->_right;
		Node* curleft = cur->_left;

		parent->_right = curleft;
		if (curleft)//curLeft可能为空
		{
			curleft->_parent = parent;
		}

		cur->_left = parent;
		Node* ppnode = parent->_parent;//ppnode == parent's parent
		parent->_parent = cur;

		if (parent == _root)//判断这棵树是不是子树
		{
			_root = cur;
			cur->_parent = nullptr;//根节点的父节点指向空
		}
		else//这颗不平衡的树是一颗子树
		{//还得判断这颗子树在其父节点的左边还是右边
			if (ppnode->_left == parent)//左
			{
				ppnode->_left = cur;
			}
			else//右
			{
				ppnode->_right = cur;
			}
			cur->_parent = ppnode;
		}
	}

	//复用AVL树的右单旋
	void RotateR(Node* parent)
	{
		Node* cur = parent->_left;
		Node* curRight = cur->_right;

		parent->_left = curRight;
		if (curRight)//curLeft可能为空
		{
			curRight->_parent = parent;
		}

		cur->_right = parent;
		Node* ppnode = parent->_parent;//ppnode == parent's parent
		parent->_parent = cur;

		if (parent == _root)//判断这棵树是不是子树
		{
			_root = cur;
			cur->_parent = nullptr;//根节点的父节点指向空
		}
		else//这颗不平衡的树是一颗子树
		{//还得判断这颗子树在其父节点的左边还是右边
			if (ppnode->_left == parent)//左
			{
				ppnode->_left = cur;
			}
			else//右
			{
				ppnode->_right = cur;
			}
			cur->_parent = ppnode;
		}
	}

红黑树的验证

红黑树的验证检测也分为两步：

检测其是否满足二叉搜素树（中序遍历是否为有序数列）
检测其是否满足红黑树性质

	bool CheckColour(Node* root, int blacknum, int benchmark)
	{
		if (root == nullptr)
		{
			if (blacknum != benchmark)
				return false;

			return true;
		}

		if (root->_color == BLACK)
		{
			++blacknum;
		}

		if (root->_color == RED && root->_parent && root->_parent->_color == RED)
		{
			cout << root->_kv.first << "出现连续红色节点" << endl;
			return false;
		}

		return CheckColour(root->_left, blacknum, benchmark)
			&& CheckColour(root->_right, blacknum, benchmark);
	}

	bool IsBalance()
	{
		return IsBalance(_root);
	}

	bool IsBalance(Node* root)
	{
		if (root == nullptr)
			return true;

		if (root->_color != BLACK)
		{
			return false;
		}

		// 基准值
		int benchmark = 0;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_color == BLACK)
				++benchmark;

			cur = cur->_left;
		}

		return CheckColour(root, 0, benchmark);
	}

红黑树与AVL树比较

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

简单模拟实现set和map

改造红黑树

#pragma once
#include<iostream>

using namespace std;

//节点的颜色
enum Color { RED, BLACK };

//红黑树节点的定义
template <class T>
class RBTreeNode
{
public:
	RBTreeNode(const T& data)
		:_left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		,_data(data)
		,_color(RED)
	{}
	 
	RBTreeNode<T>* _left;//节点的左孩子
	RBTreeNode<T>* _right;//节点的右孩子
	RBTreeNode<T>* _parent;//节点的父节点
	T _data;//节点的值域
	Color _color;//节点的颜色
};


template<class T, class Ptr, class Ref>
class __TreeIterator
{
	typedef RBTreeNode<T> Node;
public:
	typedef __TreeIterator<T, Ptr, Ref > Self;
	typedef __TreeIterator<T, T*, T&> Iterator;

	__TreeIterator(const Iterator& it)
		:_node(it._node)
	{}

	Node* _node;

	__TreeIterator(Node *node)
		:_node(node)
	{}

	Ref operator*()
	{
		return _node->_data;
	}

	Ptr operator->()
	{
		return &_node->_data;
	}

	bool operator!= (const Self& s)
	{
		return _node != s._node;
	}

	bool operator==(const Self& s) const
	{
		return _node != s._node;
	}

	Self& operator--()
	{
		if (_node->_left)
		{
			Node* subRight = _node->_left;
			while (subRight->_right)
			{
				subRight = subRight->_right;
			}
			_node = subRight;
		}
		else
		{
			//孩子是父亲右的节点
			Node* cur = _node;
			Node* parent = cur->_parent;
			while (parent && cur == cur->_left)
			{
				cur = cur->_parent;
				parent = parent->_parent;
			}
			_node = parent;
		}
		return *this;
	}

	Self& operator++()
	{
		if (_node->_right)//1. 右不为空，访问右树的最左节点（最小节点）
		{
			Node* subLeft = _node->_right;
			while (subLeft->_left)
			{
				subLeft = subLeft->_left;
			}
			_node = subLeft;
		}
		else//2. 右为空，下一个访问的是孩子是父亲左的那个祖先节点
		{
			Node* cur = _node;
			Node* parent = cur->_parent;
			while (parent)
			{
				if (cur == parent->_left)
				{
					break;
				}
				else
				{
					cur = cur->_parent;
					parent = parent->_parent;
				}
			}
			_node = parent;
		}
		return *this;
	}
};

//set->RBTree<K, pair<K, K, SetKeyOfT> _t;
//map->RBTree < K, pair<K, V>, MapKeyOfT> _t;
template<class K, class T, class KeyOfT>
class RBTree
{
	typedef RBTreeNode<T> Node;
public:
	typedef __TreeIterator<T, T*, T&> iterator;
	typedef __TreeIterator<T, const T*, const T&> const_iterator;

	iterator begin()
	{
		Node* leftMin = _root;
		while (leftMin && leftMin->_left)
		{
			leftMin = leftMin->_left;
		}
		return iterator(leftMin);
	}

	iterator end()
	{
		return iterator(nullptr);
	}

	const_iterator begin() const
	{
		Node* leftMin = _root;
		while (leftMin && leftMin->_left)
		{
			leftMin = leftMin->_left;
		}

		return const_iterator(leftMin);
	}

	const_iterator end() const
	{
		return const_iterator(nullptr);
	}

	Node* Find(const K& key)
	{
		Node* cur = _root;
		KeyOfT kot;
		while (cur)
		{
			if (kot(cur->_data) < key)
			{
				cur = cur->_right;
			}
			else if (kot(cur->_data) > key)
			{
				cur = cur->_left;
			}
			else
			{
				return cur;
			}
		}

		return nullptr;
	}

	pair<iterator, bool> Insert(const T& data)
	{
		if (_root == nullptr)
		{
			_root = new Node(data);
			_root->_color = BLACK;
			return make_pair(iterator(_root), true);
		}
		//1. 按照二叉搜索树的方式插入新节点
		Node* parent = nullptr;
		Node* cur = _root;

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

		cur = new Node(data);
		cur->_color = RED;
		Node* newnode = cur;

		if (kot(parent->_data) < kot(data))//与父节点比较，大于父节点放右边
		{
			parent->_right = cur;
		}
		else//if (parent->_kv.first > kv.fist)//小于父节点放左边
		{
			parent->_left = cur;
		}
		cur->_parent = parent;//保存父节点


		//新节点插入后，如果其双亲节点的颜色为空色，则违反性质3(不能有连在一起的红色结点)
		while (parent && parent->_color == RED)
		{
			Node* grandfather = parent->_parent;
			if (parent == grandfather->_left)
			{
				Node* uncle = grandfather->_right;
				//u存在且为红
				if (uncle && uncle->_color == RED)
				{
					//变色
					parent->_color = uncle->_color = BLACK;
					grandfather->_color = RED;
					//继续向上处理
					cur = grandfather;
					parent = cur->_parent;
				}
				else//u不存在或存在且为黑
				{
					if (cur == parent->_left)
					{
						RotateR(grandfather);
						parent->_color = BLACK;
						grandfather->_color = RED;
					}
					else
					{
						RotateL(parent);
						RotateR(grandfather);
						cur->_color = BLACK;
						grandfather->_color = RED;
					}
					break;
				}
			}
			else// if(parent == grandfather->_right)
			{
				Node* uncle = grandfather->_left;
				//u存在且为红
				if (uncle && uncle->_color == RED)
				{
					//变色
					parent->_color = uncle->_color = BLACK;
					grandfather->_color = RED;
					//继续向上处理
					cur = grandfather;
					parent = cur->_parent;
				}
				else//u不存在或存在且为黑
				{
					if (cur == parent->_right)
					{
						RotateL(grandfather);
						parent->_color = BLACK;
						grandfather->_color = RED;
					}
					else
					{
						RotateR(parent);
						RotateL(grandfather);
						cur->_color = BLACK;
						grandfather->_color = RED;
					}

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

	//复用AVL树的左单旋
	void RotateL(Node* parent)
	{
		++_rotateCount;
		Node* cur = parent->_right;
		Node* curleft = cur->_left;

		parent->_right = curleft;
		if (curleft)//curLeft可能为空
		{
			curleft->_parent = parent;
		}

		cur->_left = parent;
		Node* ppnode = parent->_parent;//ppnode == parent's parent
		parent->_parent = cur;

		if (parent == _root)//判断这棵树是不是子树
		{
			_root = cur;
			cur->_parent = nullptr;//根节点的父节点指向空
		}
		else//这颗不平衡的树是一颗子树
		{//还得判断这颗子树在其父节点的左边还是右边
			if (ppnode->_left == parent)//左
			{
				ppnode->_left = cur;
			}
			else//右
			{
				ppnode->_right = cur;
			}
			cur->_parent = ppnode;
		}
	}

	//复用AVL树的右单旋
	void RotateR(Node* parent)
	{
		++_rotateCount;
		Node* cur = parent->_left;
		Node* curRight = cur->_right;

		parent->_left = curRight;
		if (curRight)//curLeft可能为空
		{
			curRight->_parent = parent;
		}

		cur->_right = parent;
		Node* ppnode = parent->_parent;//ppnode == parent's parent
		parent->_parent = cur;

		if (ppnode == nullptr)//判断这棵树是不是子树
		{
			_root = cur;
			cur->_parent = nullptr;//根节点的父节点指向空
		}
		else//这颗不平衡的树是一颗子树
		{//还得判断这颗子树在其父节点的左边还是右边
			if (ppnode->_left == parent)//左
			{
				ppnode->_left = cur;
			}
			else//右
			{
				ppnode->_right = cur;
			}
			cur->_parent = ppnode;
		}
	}

	bool CheckColour(Node* root, int blacknum, int benchmark)
	{
		if (root == nullptr)
		{
			if (blacknum != benchmark)
				return false;

			return true;
		}

		if (root->_color == BLACK)
		{
			++blacknum;
		}

		if (root->_color == RED && root->_parent && root->_parent->_color == RED)
		{
			cout << root->_kv.first << "出现连续红色节点" << endl;
			return false;
		}

		return CheckColour(root->_left, blacknum, benchmark)
			&& CheckColour(root->_right, blacknum, benchmark);
	}

	bool IsBalance()
	{
		return IsBalance(_root);
	}

	bool IsBalance(Node* root)
	{
		if (root == nullptr)
			return true;

		if (root->_color != BLACK)
		{
			return false;
		}

		// 基准值
		int benchmark = 0;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_color == BLACK)
				++benchmark;

			cur = cur->_left;
		}

		return CheckColour(root, 0, benchmark);
	}

	int Height()
	{
		return Height(_root);
	}

	int Height(Node* root)
	{
		if (root == nullptr)
			return 0;

		int leftHeight = Height(root->_left);
		int rightHeight = Height(root->_right);

		return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
	}

private:
	Node* _root = nullptr;

public:
	int _rotateCount = 0;
};

set的模拟实现

#pragma once
#include"RBTree.h"

namespace yzk
{
	template<class K>
	class set
	{
	public:
		class SetKeyOfT
		{
		public:
			const K& operator()(const K& key)
			{
				return key;
			}
		};
	public:
		typedef typename RBTree<K, K, SetKeyOfT>::const_iterator iterator;
		typedef typename RBTree<K, K, SetKeyOfT>::const_iterator const_iterator;

		iterator begin()
		{
			return _t.begin();
		}

		iterator end()
		{
			return iterator(nullptr);
		}

		const iterator begin() const
		{
			return _t.begin();
		}

		const iterator end() const
		{
			return _t.end();
		}

		pair<iterator, bool> insert(const K& key)
		{
			pair<typename RBTree<K, K, SetKeyOfT>::iterator, bool> ret = _t.Insert(key);
			return pair<iterator, bool>(ret.first, ret.second);
		}

	private:
		RBTree<K, K, SetKeyOfT> _t;
	};
}

模拟实现map

#pragma once
#include"RBTree.h"

namespace yzk
{
	template<class K, class V >
	class map
	{
		class MapKeyOfT
		{
		public:
			const K& operator()(const pair<K, V>& kv)
			{
				return kv.first;
			}
		};
	public:
		typedef typename RBTree<K, pair<const K, V>, MapKeyOfT>::iterator iterator;
		typedef typename RBTree<K, pair<const K, V>, MapKeyOfT>::const_iterator const_iterator;

		iterator begin()
		{
			return _t.begin();
		}
		iterator end()
		{
			return _t.end();
		}

		const_iterator begin() const
		{
			return _t.begin();
		}

		const_iterator end() const
		{
			return _t.end();
		}

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

		pair<iterator, bool> insert(const pair<K, V>& kv)
		{
			return _t.Insert(kv);
		}
	private:
		RBTree<K, pair<const K, V>, MapKeyOfT> _t;
	};
}