还没吃透面试必问的红黑树？图文并茂的让你彻底理解红黑树

1. 红黑树的概念

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

2. 红黑树的性质

2.1. 每个结点不是红色就是黑色

2.2. 根节点是黑色的

2.3. 如果一个节点是红色的，则它的两个孩子结点是黑色的（不会出现连在一起的红色节点）

2.4. 对于每个结点，从该结点到其所有后代叶结点的简单路径上，均包含相同数目的黑色结点（在计算一条路径中黑色节点个数的时候要带上叶子节点，因为叶子节点也是黑色的，也就是空节点）。

2.5. 每个叶子结点都是黑色的(此处的叶子结点指的是空结点)（为了保证空树也是红黑树）

2.6.红黑树确保没有一条路径会比其他路径长出俩倍（红黑树前面的性质保证了当前的性质）

3. 红黑树的实现

3.1. 带头节点的红黑树

这里我们将红黑树的实现给为带头的红黑树，因为红黑树是map和set的底层数据结构这里我们实现出来红黑树就可以直接用当前我们实现的带头红黑树来实现map和set至于头节点的给出是为了方便于map和set的遍历，在STL中我们区间给出都是左闭右开区间的，既然红黑树作为map和set的底层数据结构那么我们就一定有位置要来放map和set的迭代器，那么就可以将begin位置的迭代器放在head的左，end位置的迭代器可以放在head位置。这里我们将红黑树头节点的颜色给为红色。

3.2. 红黑树的节点

3.3. 红黑树插入节点的分析（实现红黑树最最最关键的一步）

可以看到我们上面在红黑树节点的构造的时候将节点的默认颜色给为红色，那么我们在插入节点的时候就要特别考虑性质3：不可以有两个红色节点连在一起。这里我们可以一共可以分为两大类，一类将节点插入当前红黑树的左子树中，另一类就是将节点插入红黑树的右子树当中。

第一大类（将节点插入红黑树的左子树中）

第一种情况（叔叔节点存在而且为红色，这里将节点插入红黑树的内测还是内测处理方式是一样的）

1.我们插入节点的parent节点为黑色：那么这种情况是不需要调整的。

2.我们插入节点的parent节点为红色，而且插入节点的叔叔节点也存在而且为红色的，那么当前节点插入之后就违反了红黑树的性质3，就需要对当前树进行调整。这里解决的时候我们就将当前parent节点和叔叔节点u的颜色变为黑色。

为什么要这样做呢？

答案：这里我们将cur节点插入之后要解决当前parent和cur颜色都为红色的问题，那么只能将cur和parnet其中一个节点的颜色变为黑色，但是肯定不能将cur节点变为黑色，因为这样在包含cur的路径中就多一个黑色节点，那么我们就要将除包含cur之外的路径中的黑色节点全部都减少一个，又因为此时cur是新插入的节点如果将cur颜色变为黑色那么此时就只有一条路径黑色节点个数+1，如果要调整的话，其他所有节点中黑色节点个数都要减少一个这样肯定是不行的，那么我们只能将parent节点的颜色变为黑色，那么当parent节点变为黑色之后我们可以看到在包含parent的路径中黑色节点增加，但是包含parent节点的路径一定包含parent的双亲节点也就是g节点那么我们将双亲节点g颜色改为红色，那么不就将包含parent路径的黑色节点个数减少一个了吗。然后我们发现又出现新的问题了，就是原本包含u节点的路径因为g节点变为了红色那么包含u节点的路径中少了一个黑色节点（因为包含u节点的路径一定包含g节点）那么我们此时只要将u节点的颜色变为黑色即可。

上面将parent和u的节点更新为红色之后，我们还要考虑g节点让我们更新为红色之后那它的双亲节点是否存在，是否是红色节点：

如果g的双亲不存在：

那么此时g就是根节点那么我们此时需要将g颜色更新为黑色，因为红黑树的根节点必须是黑色的。

如果g的双亲存在：

分为两种情况：1、g的双亲为黑色那么调整结束直接退出。2、如果g的双亲为红色（而且g的叔叔为红色，这里如果g的叔叔为黑色我们下面会讨论）那么我们更新cur和parent继续当前的调整过程。

我们可以总结一下我们的第一种情况：

第二种情况（叔叔节点存在而且一定为黑色或者叔叔节点不存在）

当前cur节点是新插入节点，那么叔叔节点一定是不存在的

当前cur不是新插入节点，那么就和我们第一种情况，我们更新完祖父节点后祖父节点还有叔叔节点的情况这时叔叔节点一定是黑色的，其实下面这种情况的出现就是为了解决上面第一种情况：更新完祖父节点之后祖父节点还有叔叔节点且叔叔节点为黑色。

那么我们如何解决当前场景呢？

我们这里一共给出三步：

1.将parent节点改为黑色

2.将g节点改为红色

3.将g节点右单旋

当叔叔节点不存在也是一样的做法

我们总结一下第二种情况：第二种情况其实就是对第一种情况其中的一种情况的分析解决。

第三种情况：第三种情况其实就是对第二种情况的变种，cur在parent的右侧。

如果你可以坚持看到这里，恭喜你你已经理解了手撕红黑树中基本最难的地方了，马上就能撕碎红黑树！！！

情况三的解决方案：（其实情况三就是转化为情况二来解决的）

至此我们就将红黑树插入的第一大类看完了，接下来就是第二大类基本就和我们的第一大类一样，不同的地方就是第二大类将节点插入到红黑树的右子树。

第二大类（将节点插入红黑树的右子树中）

第一种情况：插入节点的parent节点为红色而且叔叔节点存在为红色（这里将节点插入红黑树的内测还是内测处理方式是一样的）

那么我们和第一类中一样也分为g有双亲节点（g的叔叔为红色，g的叔叔为黑色两种情况）和没有双亲节点。

g没有双亲节点：没有双亲节点我们将g颜色更新为红色直接返回即可。

g的双亲节点如果存在:那么我们就又分为两种情况一种是双亲节点为黑色节点那么调整结束满足红黑树性质，另一种双亲节点为红色那么，就又分为两种情况：一种是当前叔叔节点为红色那么我们重复当前的调整步骤，另一种就是我们下面情况二要讨论的叔叔节点为黑色。

第二情况：叔叔节点存在但颜色一定是黑色||叔叔节点不存在

如果叔叔节点u为黑色节点当前节点一定不是新插入节点。

那么就是我们遗留的第一种情况中未处理的情况就是下面这种情况：

由于与第一大类中第二种情况类似我们这里直接将解决方式给出，这里的叔叔节点不存在也是同样的做法

第三种情况：叔叔节点存在但颜色一定是黑色||将节点插入内侧

4. 红黑树模拟实现

看到这里恭喜你，你已经彻底掌握了红黑树的插入，接下来你可以动手试一下红黑树的模拟实现，这里我也给出红黑树的模拟实现代码可以作为参考。

#pragma once
#include<iostream>
#include<vector>
#include<string>
usingnamespacestd;

// 节点的颜色
//我们可以使用 #define 定义常量，为什么非要使用枚举？ 枚举的优点：
//1. 增加代码的可读性和可维护性
//2. 和#define定义的标识符比较枚举有类型检查，更加严谨。
//3. 防止了命名污染（封装）
//4. 便于调试
//5. 使用方便，一次可以定义多个常量
//6. 这些可能取值都是有值的，默认从0开始，一次递增1，当然在定义的时候也可以赋初值。
enum Color{ RED, BLACK };



// 红黑树节点的定义
template<class ValueType>
struct RBTreeNode
{
RBTreeNode(constValueType data = ValueType(), Color color = RED)
//这里构造节点的时候颜色默认给为红色因为如果给为黑色就有可能会破坏当前红黑树的性质，导致每条路径的黑色节点个数不同
: _Left(nullptr), _Right(nullptr), _Parent(nullptr)
, _data(data), _color(color)
{}
RBTreeNode<ValueType>* _Left;// 节点的左孩子
RBTreeNode<ValueType>* _Right;// 节点的右孩子
RBTreeNode<ValueType>* _Parent;// 节点的双亲(红黑树需要旋转，为了实现简单给出该字段)
ValueType _data;// 节点的值域
Color _color;// 节点的颜色
};

//红黑树迭代器：
template<class T, class Ref, class Ptr>
struct RBTree_iterator
{
typedef RBTreeNode<T> Node;
typedef RBTree_iterator<T, Ref, Ptr>self;
//构造函数就将红黑树的节点指针传入进来：
RBTree_iterator(Node* node = nullptr)
:_pnode(node)
{}
//迭代器解引用：
Ref operator*()
{
return_pnode->_data;
}
Ptr operator->()
{
return(operator*());
}
//迭代器加加:前置加加
selfoperator++()
{
Increament();
return*this;
}
selfoperator++(int)
{
selftemp = *this;
Increament();
returntemp;
}
selfoperator--()
{
Decreament();
return*this;
}
selfoperator--(int)
{
selftemp = *this;
Decreament();
returntemp;
}
//将当前迭代器指针的值放到后面大的值上
void Increament()
{
//如果当前迭代器存在右子树的时候我们将_pnode更新到右子树
if(_pnode->_Right)
{
_pnode = _pnode->_Right;
//去右子树中找最小的节点：
while(_pnode->_Left)
{
_pnode = _pnode->_Left;
}
}
else
{
Node*parent= _pnode->_Parent;
while(parent->_Right == _pnode)
{
_pnode =parent;
parent= _pnode->_Parent;
}
///----------------------------->>>>>>>>>>>一定要注意下面的情况当红黑树没有右子树，那么当前的head节点的右就指向
//红黑树的根那么此时如果将_pnode放在parent处那么就相当于将while循环中的做了无用功。
if(_pnode->_Right !=parent)
{
_pnode =parent;
}
}
}
void Decreament()
{
if(_pnode->_Parent->_Parent == _pnode_pnode->_color == RED)
{//当前节点是head节点的时候那么我们就要找到当最右边节点也就是最大节点，而判断当前节点是否是最大的节点的时候
//不可只有一个_pnode->_Parent->_Parent因为根节点也满足这个条件，因为我们将红黑树的head节点设为红色所以我们加上_color==RED
_pnode = _pnode->_Right;
}
//如果当前的pnode的左子树存在那么我们就将节点放在左子树
elseif(_pnode->_Left)
{
_pnode = _pnode->_Left;
while(_pnode->_Right)
{
_pnode = _pnode->_Right;
}
}
else
{
Node*parent= _pnode->_Parent;
//这里如果_pnode到了begin的位置就不可以再减了
while(_pnode ==parent->_Left)
{
_pnode =parent;
parent= _pnode->_Parent;
}
_pnode =parent;
}
}
bool operator==(constselfs)const
{
return_pnode == s._pnode;
}
bool operator!=(constselfs)const
{
return_pnode != s._pnode;
}
Node* _pnode;
};

template<class T,class Keyofvalue>
class RBtree{
typedef RBTreeNode<T> Node;
public:

typedef RBTree_iterator<T, T, T*> RBiterator;
public:
RBtree()
:_head(newNode()), _size(0)
{
_head->_Left = _head;
_head->_Right = _head;
}

pair<RBiterator,bool> insert(constT val)//插入节点
{
Keyofvalue key;
//先按照二叉搜索树的方式插入
Node* new_node=nullptr;
Node* _root = get_root();
if(_root == nullptr)
{//为空树
_root =newNode(val, RED);
_root->_Parent = _head;
new_node = _root;
//_head->_Parent = _root;
}
else
{//树非空
Node* cur = _root;
Node*parent= _head;
while(cur)
{
parent= cur;
if(key(val) < key(cur->_data))
{
cur = cur->_Left;
}
elseif(key(val)>key(cur->_data))
{
cur = cur->_Right;
}
else
{//我们这里不允许插入相同值域的节点
returnmake_pair(RBiterator(cur),false);
}
}
cur =newNode(val);
new_node = cur;
if(key(val) < key(parent->_data))
{
parent->_Left = cur;
}
else
{
parent->_Right = cur;
}
cur->_Parent =parent;
//插入成功之后我们调整当前红黑树的节点：
//这里我们在插入红黑树中调整的时候只有当第一中情况才继续向上更新节点，那么我们只要考虑第一中情况的终止条件即可
//第一中情况中如果parent为红色节点那么当前节点就需要继续向上更新，但是我们将head节点也设为红色那么当我们parent
//节点更新到head节点那么当前也就不更新了
while(parent!= _headparent->_color == RED)
{
//插入节点双亲为黑色：
if(parent->_color == BLACK)
{
break;
}
else
{//插入节点双亲为红色
Node* grandparent =parent->_Parent;//这里如果双亲的节点是红色那么双亲一定是有双亲节点的
if(parent== grandparent->_Left)
{//第一大类插入节点在红黑树的左子树：
Node* uncle = grandparent->_Right;//当前节点的叔叔节点
if(uncleuncle->_color == RED)
{//第一种情况：叔叔节点存在而且为红色：
parent->_color = BLACK;
uncle->_color = BLACK;
grandparent->_color = RED;
cur = grandparent;
parent= cur->_Parent;
}
//第二三种情况：
else
{
//因为我们要将第三种情况转化为第二种情况处理所以我们先写第三种情况：cur插在内侧
if(cur ==parent->_Right)
{
rotate_left(parent);
std::swap(parent, cur);
}
//第二种情况：先将parent和grandparent颜色互换然后右旋
parent->_color = BLACK;
grandparent->_color = RED;
rotate_right(grandparent);
}
}
else
{//第二大类插入节点在红黑树的右子树：
Node* uncle = grandparent->_Left;//当前节点的叔叔节点
if(uncleuncle->_color == RED)
{//第一种情况：叔叔节点存在而且为红色：
parent->_color = BLACK;
uncle->_color = BLACK;
grandparent->_color = RED;
cur = grandparent;
parent= cur->_Parent;
}
//第二三种情况：
else
{
//因为我们要将第三种情况转化为第二种情况处理所以我们先写第三种情况：cur插在内侧
if(cur ==parent->_Left)
{
rotate_right(parent);
std::swap(parent, cur);
}
//第二种情况：先将parent和grandparent颜色互换然后右旋
parent->_color = BLACK;
grandparent->_color = RED;
rotate_left(grandparent);
}
}
}
}

}
_root->_color = BLACK;
_head->_Left = get_mostleftnode();
_head->_Right = get_mostrightnode();
returnmake_pair(RBiterator(new_node),true);
}
//这里的销毁节点一定要传因为因为下面要修改root=nullptr的时候要将指针所指向的地址修改为nullptr不然如果后面再调用destroy的时候
//其实root所指向的地址并没有指向nullptr所以就有可能出错。
void Destroy(Node* root)
{
if(root)
{
Destroy(root->_Left);
Destroy(root->_Right);
delete root;
root = nullptr;
}

}
void Clear()
{
Destroy(get_root());
_size =0;
}
~RBtree()
{
Destroy(get_root());
delete _head;
}
//查找方法
RBiterator Find(T value)
{
Keyofvalue key;
Node* cur = get_root();
while(cur)
{
if(key(cur->_data) < key(value))
{
cur = cur->_Right;
}
elseif(key(cur->_data)>key(value))
{
cur = cur->_Left;
}
else
{
returnRBiterator(cur);
}
}
returnEnd();
}
RBiterator End()
{
returnRBiterator(_head);
}
RBiterator Begin()
{
returnRBiterator(_head->_Left);
}
size_t Size()const
{
return_size;
}
boolEmpty()const
{
return_size ==0;
}
//中序遍历//
void inoder()
{
cout <<"中序遍历结果为：";
Node* _root = get_root();
mid(_root);
cout << endl;
}
/判断当前树是否是红黑树//
bool isRBtree()
{
Node* root = get_root();
if(root == nullptr)
{
returntrue;
}
//判断根节点是否是黑色节点：
if(root->_color == RED)
{
returnfalse;
}
//判断每条路径中黑色节点个数是否相同
size_t black_count =0;
Node* cur = root;
while(cur)
{
if(cur->_color == BLACK)
{
black_count++;
}
cur = cur->_Left;
}
int k =0;
return_isRBtree(black_count, k, root);
}
//判断红黑树中是否满足性质三（两个红色节点不挨在一起）性质四（每条路径中黑色节点树相同）
bool _isRBtree(size_t black_count, int k, Node* root)
{
if(root == nullptr)
{
if(k != black_count)
{
cout <<"当前树不是红黑树，有一条路径黑色节点个数为："<< k <<"少于路径节点："<< black_count << endl;
returnfalse;

}
returntrue;
}
if(root->_color == BLACK)
{
k++;
}
else
{
if(root->_Parent->_color == RED)
{
cout <<"当前树不是红黑树,有两个红色节点挨在一起。"<< endl;
returnfalse;
}
}
return_isRBtree(black_count, k, root->_Left)  _isRBtree(black_count, k, root->_Right);
}
/
void Swap(RBtree<T,Keyofvalue> _t)
{
std::swap(_head, _t._head);
}
private:
//中序遍历：
void mid(Node* root)
{
if(root)
{
mid(root->_Left);
cout << root->_data <<" ";
mid(root->_Right);
}
}
//这里因为我们红黑树中没有设置根节点在代码实现的时候不容易理解所以这里我们写一个私有函数返回红黑树的根节点：
Node* get_root()
{
return_head->_Parent;
}
//获取最左侧节点也就是最小节点：
Node* get_mostleftnode()
{
Node* _root = get_root();
if(_root)
{
while(_root->_Left)
{
_root = _root->_Left;
}
}
return_root;
}
//获取最右侧节点也就是最大节点：
Node* get_mostrightnode()
{
Node* _root = get_root();
if(_root)
{
while(_root->_Right)
{
_root = _root->_Right;
}
}
return_root;
}
//左单旋
void rotate_left(Node*parent)
{
Node* pparent =parent->_Parent;
Node* subR =parent->_Right;
Node* subRL = subR->_Left;
parent->_Right = subRL;
//更新subRL的双亲：
if(subRL)
{
subRL->_Parent =parent;
}
subR->_Left =parent;
parent->_Parent = subR;
subR->_Parent = pparent;
if(pparent == _head)//------------------------------------->>>>一定要注意这里的pparent如果是头节点那么一定要将pparent的指向为subR
{
_head->_Parent = subR;
}
if(pparent)
{
if(pparent->_Left ==parent)
{
pparent->_Left = subR;
}
else
{
pparent->_Right = subR;
}
}
}
//右单旋
void rotate_right(Node*parent)
{
Node* subL =parent->_Left;
Node* subLR = subL->_Right;
Node* pparent =parent->_Parent;
parent->_Left = subLR;
//如果subLR存在那么将其父节点更新
if(subLR)
{
subLR->_Parent =parent;
}
//将parent右旋下来：
subL->_Right =parent;
//parent旋下来就要更新parent的父节点
parent->_Parent = subL;
//此时subL就要更新父节点
subL->_Parent = pparent;
if(pparent == _head)
{
_head->_Parent = subL;
}
if(pparent)
{
if(parent== pparent->_Right)
{
pparent->_Right = subL;
}
else
{
pparent->_Left = subL;
}
}
}
private:
size_t _size;
Node* _head;
};

5. 基于红黑树的map的模拟实现

#pragma once
#include"RBtree.hpp"

//红黑树里面放的键值对
namespacewbx
{
template<class K,class V>
class map
{
public:

typedefpair<K,V> valuetype;
//这里是因为我们红黑树中存放的是键值对，而我们红黑树在实现的时候只有一个模板类型参数，
//也就是我们要存放在红黑树中的节点，而我们的map是用pair（键值对来存放节点的）但是比较
//的时候我们是通过pair中的key值来比较的，所以我们这里就要定义一个类来返回我们map中要
//比较的类型。
struct Keyofvalue
{
const Koperator()(constvaluetype value)
{
returnvalue.first;
}
};
typedefRBtree<valuetype,Keyofvalue> Tree;
typedeftypenameTree::RBiterator iterator;

map()
:_t()
{}
iterator begin()
{
return_t.Begin();
}
iterator end()
{
return_t.End();
}
size_tsize()const
{
return_t.Size();
}
size_tempty()const
{
return_t.Empty();
}
//这里map的operator[]我们实现的时候直接用insert来实现，这里我们在红黑树中实现insert的时候
//是不允许插入相同的元素的，所以这里我们operator[]如果是一个新的key值那么我们就将其直接
//插入了如果是一个原有的key值那么红黑树中的inset插入就会将它的迭代器返回那么我们这里将
//返回的迭代器解引用得到它的value值的引用那么我就可以对其进行修改
Voperator[](constK key)
{
return(*(_t.insert(make_pair(key, V() ) ).first ) ).second;
}
pair<iterator,bool> insert(constvaluetype val)
{
return_t.insert(val);
}
void swap(map<K, V> m)
{
_t.Swap(m._t);
}
void clear()
{
_t.Clear();
}
iterator find(constK key )
{
return_t.Find(make_pair(key,V()));
}
private:
Tree_t;
};
};

6. 基于红黑树的set的模拟实现

#pragma once
#include"RBtree.hpp"

//红黑树里面放的键值对
namespacewbx
{
template<class K>
class set
{
public:

typedefK valuetype;
struct Keyofvalue
{
const Koperator()(constvaluetype value)
{
returnvalue;
}
};
typedefRBtree<valuetype, Keyofvalue> Tree;
typedeftypenameTree::RBiterator iterator;

set()
:_t()
{}
iterator begin()
{
return_t.Begin();
}
iterator end()
{
return_t.End();
}
size_tsize()const
{
return_t.Size();
}
size_tempty()const
{
return_t.Empty();
}
pair<iterator,bool> insert(constvaluetype val)
{
return_t.insert(val);
}
void swap(set<K> s)
{
_t.Swap(s._t);
}
void clear()
{
_t.Clear();
}
iterator find(constvaluetype key)
{
return_t.Find(key);
}
private:
Tree_t;
};
};