关联式容器

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_typeclass Compare = less<T>,        // set::key_compare/value_compareclass 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 90itlow = 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_boundfor (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 90pair<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(lo{g}_{2}N)$
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++98dict.insert({ "iterator","迭代器" });//C++11支持了多参数类型的隐式类型转换，这样子写等价于调用pair
}

---

map的模板参数列表

template < class T,                        // multiset::key_type/value_typeclass Compare = less<T>,        // multiset::key_compare/value_compareclass 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(lo{g}_{2}n)$，搜索时的时间复杂度：$O(lo{g}_{2}n)$。

---

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树的旋转分为四种：

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

左单旋

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 parentparent->_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;}

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

右单旋

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 parentparent->_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;}

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

右左单旋

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

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

右左单旋

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，可分以下情况考虑

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

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

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

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

---

AVL树的验证

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

1. 验证其位二叉搜索树

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

2. 验证其为平衡树

• 每个节点子树的高度的绝对值不超过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，这样可以保证查询时高效的时间复杂度，即$lo{g}_{2}N$。但是如果要对AVL树做一些结构性的修改操作，性能会非常低下。比如：插入时要维护其绝对平衡，旋转的次数比较多；更差的是删除时，有可能一直要让旋转持续到根的位置。因此：如果需要一种查询高效且有序的数据结构，而且数据的个数为静态的（即不会改变），可以考虑AVL树；但如果是一种结构经常修改，就不太适合。

---

红黑树

红黑树概念

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

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

---

红黑树的性质

1. 每个节点不是红色就是黑色
2. 根节点是黑色的
3. 如果一个节点是红色的，则他的两个孩子节点是黑色的（任何路径没有连续的红色节点）
4. 对于每个节点，从该节点到其所有后代叶节点的简单路径上，均包含数目相同的黑色节点（每条路径上的黑色节点的数量相等）
5. 每个叶子节点都是黑色的，这里的叶子节点指的是空节点–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 parentparent->_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 parentparent->_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;}}

---

红黑树的验证

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

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

	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(lo{g}_{2}N)$,红黑树不追求绝对平衡，其只需保证最长路径不超过最短路径的两倍。相对而言，降低了插入和旋转的次数，所以在经常进行增删的结构中性能比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 parentparent->_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 parentparent->_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;};
}