目录
一、红黑树的概念
红黑树是一种二叉搜索树，但是在每个节点上增加一个存储位表示表示节点的颜色，Red或Black
从根到叶子节点的任何一条路径上的各个节点，都有颜色的限制来保证没有一条路径的长度会比其他路径的长度超出两倍，因此确保二叉搜索树是接近平衡的。
二、红黑树的性质
1.每个节点不是红色就是黑色
2.根节点是黑色
3.如果一个节点是红色的，那么它的两个孩子都是黑色的（不存在连续的红色节点）
4.对于每个节点，从该节点到其所有后代叶子节点的路径上，黑色节点数目相同（每条路径都存在相同数目的黑色节点）
5.每个叶子节点都是黑色的（此处叶子节点指的是空节点）
三、红黑树与AVL树的比较
由红黑树的概念来看，红黑树的高度比AVL树高得多，那么查找效率如何呢？
实际上红黑树与AVL树的查找效率没有区别，效率都相当高，因为它们底层都是二叉搜索树，查找的时间复杂度为log2N，10亿的数据也仅仅只需要查找30次。
那么红黑树的意义何在？
红黑树由于是通过节点颜色来限制二叉搜索树接近平衡，所以相比于AVL树插入新节点时旋转和调节的次数更少，因此在插入和删除时效率更高。
四、红黑树节点定义
红黑树和AVl树节点定义基本相同，只是将AVL树的平衡因子换为节点颜色
enum Colour {
RED,
BLACK
};
template<class K, class V>
struct AVLTreeNode {
pair<K, V> _kv;//键值对
AVLTreeNode<K, V>* _left;
AVLTreeNode<K, V>* _right;
AVLTreeNode<K, V>* _parent;
Colour _col;
//构造函数
AVLTreeNode(const pair<K, V>& kv)
:_kv(kv),
_left(nullptr),
_right(nullptr),
_parent(nullptr),
_col(RED)
{}
};五、红黑树节点插入规则
红黑树插入的新节点默认为红色
这是因为如果插入新节点为黑色，那么路径中黑色节点的数量就会改变，其余所有路径都会受到影响；而插入红色节点，如果父亲结点是黑色节点并不会有影响，只有当父亲节点也是红色节点才会影响平衡，即使有影响也只影响新节点所在路径。所以新节点插入默认为红色节点。
红黑树节点插入规则：
1.按照二叉搜索树规则插入
2.检查是否红黑树性质是否遭到破坏：没有影响性质则插入完成；影响性质则进行颜色调整、
部分插入代码
//插入
bool Insert(const pair<K, V>& kv)
{
//1.按照二叉搜索树规则插入
Node* cur = _root;
Node* parent = nullptr;
if (cur == nullptr)//树为空
{
_root = new Node(kv);
return true;
}
else//树不为空
{
while (cur)
{
if (kv.first < cur->_kv.first)
{
parent = cur;
cur = cur->_left;
}
else if (kv.first > cur->_kv.first)
{
parent = cur;
cur = cur->_right;
}
else
{
return false;//二叉搜索树不允许数据冗余
}
}
cur = new Node(kv);
if (parent->_kv.first < kv.first)
{
parent->_right = cur;
}
else
{
parent->_left = cur;
}
cur->_parent = parent;
}
//2.检查新节点是否影响平衡
//......
}六、红黑树的颜色调整规则
分为两种情况：
1.cur为红，p为红，g为黑，u存在且为红
2.cur为红，p为红，g为黑，u不存在/u为黑
基本调节规则是：
p、u变黑，g变红；
若g为根节点，则再将g变黑，调整结束；
若g为子树节点，其父亲节点为黑，调整结束；父亲节点为红，继续向上调整
1.cur为红，p为红，g为黑，u存在且为红
无论cur是p的左孩子还是右孩子，调节都是相同的
p、u变黑，g变红
2.cur为红，p为红，g为黑，u不存在/u为黑
u有两种情况：
如果u不存在，则cur一定为新节点，否则p、cur中必定有一个黑色节点，不符合规则4
如果u存在，则一定为黑色节点
因此u无论是否存在，调整规则都是相同的
（1）p为g的左孩子，cur为p的左孩子
g进行右单旋，p变黑，g变红
（2）p为g的左孩子，cur为p的右孩子
先对p进行左单旋，再对g进行右单旋，p变黑，g变红
（3）p为g的右孩子，cur为p的右孩子
g进行左单旋，p变黑，g变红
（4）p为g的右孩子，cur为p的左孩子
先对p进行右单旋，再对g进行左单旋，p变黑，g变红
七、完整插入代码
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;
}
else
{
parent->_left = cur;
}
cur->_parent = parent;
// parent的颜色是黑色也结束
while (parent && parent->_col == RED)
{
// 关键看叔叔
Node* grandfather = parent->_parent;
if (parent == grandfather->_left)
{
Node* uncle = grandfather->_right;
// 叔叔存在且为红，-》变色即可
if (uncle && uncle->_col == RED)
{
parent->_col = uncle->_col = BLACK;
grandfather->_col = RED;
// 继续往上处理
cur = grandfather;
parent = cur->_parent;
}
else // 叔叔不存在，或者存在且为黑
{
if (cur == parent->_left)
{
// g
// p u
// c
RotateR(grandfather);
parent->_col = BLACK;
grandfather->_col = RED;
}
else
{
// g
// p u
// c
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 // 叔叔不存在，或者存在且为黑
{
// 情况二：叔叔不存在或者存在且为黑
// 旋转+变色
// g
// u p
// c
if (cur == parent->_right)
{
RotateL(grandfather);
parent->_col = BLACK;
grandfather->_col = RED;
}
else
{
// g
// u p
// c
RotateR(parent);
RotateL(grandfather);
cur->_col = BLACK;
grandfather->_col = RED;
}
break;
}
}
}
_root->_col = BLACK;
return true;
}八、判断平衡
public:
bool IsBalance()
{
if (_root->_col == RED)
{
return false;
}
int refNum = 0;
Node* cur = _root;
while (cur)
{
if (cur->_col == BLACK)
{
++refNum;
}
cur = cur->_left;
}
return Check(_root, 0, refNum);
}
void InOrder()
{
_InOrder(_root);
cout << endl;
}
private:
bool Check(Node* root, int blackNum, const int refNum)
{
if (root == nullptr)
{
//cout << blackNum << endl;
if (refNum != blackNum)
{
cout << "存在黑色节点的数量不相等的路径" << endl;
return false;
}
return true;
}
if (root->_col == RED && root->_parent->_col == RED)
{
cout << root->_kv.first << "存在连续的红色节点" << endl;
return false;
}
if (root->_col == BLACK)
{
blackNum++;
}
return Check(root->_left, blackNum, refNum)
&& Check(root->_right, blackNum, refNum);
}九、红黑树完整代码
#pragma once
namespace RBTree {
enum Colour {
RED,
BLACK
};
template<class K, class V>
struct RBTreeNode {
pair<K, V> _kv;//键值对
RBTreeNode<K, V>* _left;
RBTreeNode<K, V>* _right;
RBTreeNode<K, V>* _parent;
Colour _col;
//构造函数
RBTreeNode(const pair<K, V>& kv)
:_kv(kv),
_left(nullptr),
_right(nullptr),
_parent(nullptr),
_col(RED)
{}
};
template<class K,class V>
class RBTree {
typedef RBTreeNode<K,V> Node;
public:
//插入
//bool Insert(const pair<K, V>& kv)
//{
// //1.按照二叉搜索树规则插入
// Node* cur = _root;
// Node* parent = nullptr;
// if (cur == nullptr)//树为空
// {
// _root = new Node(kv);
// _root->_col = BLACK;
// return true;
// }
// else//树不为空
// {
// while (cur)
// {
// if (kv.first < cur->_kv.first)
// {
// parent = cur;
// cur = cur->_left;
// }
// else if (kv.first > cur->_kv.first)
// {
// parent = cur;
// cur = cur->_right;
// }
// else
// {
// return false;//二叉搜索树不允许数据冗余
// }
// }
// cur = new Node(kv);
// cur->_col = RED;
// if (parent->_kv.first < kv.first)
// {
// parent->_right = cur;
// }
// else
// {
// parent->_left = cur;
// }
// cur->_parent = parent;
// }
// //2.检查新节点是否影响平衡
// while (parent && parent->_col == RED)//只要parent存在并且颜色为红色就要继续调整
// {
// Node* grandfather = parent->_parent;//g节点
// if (parent == grandfather->_left)//p为左孩子，u为右孩子
// {
// Node* uncle = grandfather->_right;
// if (uncle && uncle->_col == RED)//u存在且为红
// {
// parent->_col = uncle->_col = BLACK;//p,u变黑
// grandfather->_col = RED;//g变红
// //继续向上处理
// cur = grandfather;
// parent = cur->_parent;
// }
// else//u不存在或者u为黑
// {
// if (cur == parent->_left)//p为g的左孩子，cur为p的左孩子
// {
// //g进行右单旋，p变黑，g变红
// RotateR(grandfather);
// parent->_col = BLACK;
// grandfather->_col = RED;
// }
// else//p为g的左孩子，cur为p的右孩子
// {
// //先对p进行左单旋，再对g进行右单旋，p变黑，g变红
// RotateL(parent);
// RotateR(grandfather);
// cur->_col = BLACK://两次旋转后，p和cur交换了位置，这里的cur其实是p
// grandfather->_col = RED;
// }
// break;
// }
// }
// else//p为右孩子，u为左孩子
// {
// Node* uncle = grandfather->_left;
// if (uncle && uncle->_col == RED)//u存在且为红
// {
// //p、u变黑，g变红
// parent->_col = uncle->_col = BLACK;
// grandfather->_col = RED;
// // 继续往上处理
// cur = grandfather;
// parent = cur->_parent;
// }
// else // u不存在或u为黑
// {
// if (cur == parent->_right)//p为g的右孩子，cur为p的右孩子
// {
// //g进行左单旋，p变黑，g变红
// RotateL(grandfather);
// parent->_col = BLACK;
// grandfather->_col = RED;
// }
// else//p为g的右孩子，cur为p的左孩子
// {
// //先对p进行右单旋，再对g进行左单旋，p变黑，g变红
// RotateR(parent);
// RotateL(grandfather);
// cur->_col = BLACK;//两次旋转后，p和cur交换了位置，这里的cur其实是p
// grandfather->_col = RED;
// }
// break;
// }
// }
// }
// _root->_col = BLACK;
// return true;
//}
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;
}
else
{
parent->_left = cur;
}
cur->_parent = parent;
// parent的颜色是黑色也结束
while (parent && parent->_col == RED)
{
// 关键看叔叔
Node* grandfather = parent->_parent;
if (parent == grandfather->_left)
{
Node* uncle = grandfather->_right;
// 叔叔存在且为红，-》变色即可
if (uncle && uncle->_col == RED)
{
parent->_col = uncle->_col = BLACK;
grandfather->_col = RED;
// 继续往上处理
cur = grandfather;
parent = cur->_parent;
}
else // 叔叔不存在，或者存在且为黑
{
if (cur == parent->_left)
{
// g
// p u
// c
RotateR(grandfather);
parent->_col = BLACK;
grandfather->_col = RED;
}
else
{
// g
// p u
// c
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 // 叔叔不存在，或者存在且为黑
{
// 情况二：叔叔不存在或者存在且为黑
// 旋转+变色
// g
// u p
// c
if (cur == parent->_right)
{
RotateL(grandfather);
parent->_col = BLACK;
grandfather->_col = RED;
}
else
{
// g
// u p
// c
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;//需要旋转节点的左孩子的右孩子
//Node* ppNode = parent->_parent;//旋转节点的父亲节点
parent->_left = subLR;//将旋转节点左孩子的右孩子给成旋转节点的左孩子
if (subLR)
subLR->_parent = parent;//父亲节点也需要修改（但前提是旋转节点左孩子的右孩子存在，所以有个判断条件）
subL->_right = parent;//将旋转节点给成旋转节点左孩子的右孩子
Node* ppNode = parent->_parent;//旋转节点的父亲节点
parent->_parent = subL;//父亲节点也需要修改
if (parent == _root)//parent是根节点
{
_root = subL;
_root->_parent = nullptr;
}
else//parent是子树
{
if (ppNode->_left == parent)//旋转节点是左节点，则将subL作为左节点
ppNode->_left = subL;
else//旋转节点是右节点，则将subL作为右节点
ppNode->_right = subL;
subL->_parent = ppNode;
}
//parent->_bf = subL->_bf = 0;//最后旋转后的节点平衡因子为0
}
//左单旋
void RotateL(Node* parent)
{
Node* subR = parent->_right;//旋转节点的右孩子
Node* subRL = subR->_left;//旋转节点右孩子的左孩子
//Node* ppNode = parent->_parent;//旋转节点的父亲节点
parent->_right = subRL;//将旋转节点右孩子的左孩子给成旋转节点的右孩子
if (subRL)
subRL->_parent = parent;//父亲节点也需要修改（但前提是旋转节点右孩子的左孩子存在，所以有个判断条件）
subR->_left = parent;//将旋转节点给成旋转节点的右孩子的左孩子
Node* ppNode = parent->_parent;//旋转节点的父亲节点
parent->_parent = subR;//父亲节点也需要修改
if (parent == _root)//旋转节点是根节点
{
_root = subR;
_root->_parent = nullptr;
}
else//旋转节点是子树
{
if (ppNode->_left == parent)//旋转节点是左节点，则将subR作为左节点
ppNode->_left = subR;
else//旋转节点是右节点，则将subR作为右节点
ppNode->_right = subR;
subR->_parent = ppNode;
}
//subR->_bf = parent->_bf = 0;//最后旋转后的节点平衡因子为0
}
//判断平衡
bool IsBalance()
{
if (_root->_col == RED)
{
return false;
}
int refNum = 0;
Node* cur = _root;
while (cur)
{
if (cur->_col == BLACK)
{
++refNum;
}
cur = cur->_left;
}
return Check(_root, 0, refNum);
}
//中序遍历
void InOrder()
{
_InOrder(_root);
cout << endl;
}
private:
//检查平衡
bool Check(Node* root, int blackNum, const int refNum)
{
if (root == nullptr)
{
//cout << blackNum << endl;
if (refNum != blackNum)
{
cout << "存在黑色节点的数量不相等的路径" << endl;
return false;
}
return true;
}
if (root->_col == RED && root->_parent->_col == RED)
{
cout << root->_kv.first << "存在连续的红色节点" << endl;
return false;
}
if (root->_col == BLACK)
{
blackNum++;
}
return Check(root->_left, blackNum, refNum)
&& Check(root->_right, blackNum, refNum);
}
//中序遍历
void _InOrder(Node* root)
{
if (root == nullptr)
{
return;
}
_InOrder(root->_left);
cout << root->_kv.first << ":" << root->_kv.second << endl;
_InOrder(root->_right);
}
private:
Node* _root = nullptr;
};
}
