1. 红黑树概念
红黑树 是一种二叉搜索树,但在每个节点上增加一个存储位表示节点的颜色,可以是red或black,
通过对任何一条从根到叶子的路径上各个节点着色的方式的限制,红黑树确保没有一条路径会比其他路径长处两倍,所以是接近平衡的
![](https://i-blog.csdnimg.cn/blog_migrate/9a680c9c048df83e0cc001fa3fbee00e.png)
2. 红黑树性质
1. 每个结点不是红色就是黑色
2. 根节点是黑色的
3. 如果一个节点是红色的,则它的两个孩子结点是黑色的
(不能出现连续的红色节点)
4. 对于每个结点,从该结点到其所有后代叶结点的简单路径上,均包含相同数目的黑色结点
(每条路径上都有相同数量的黑色节点)
5. 每个叶子结点都是黑色的(此处的叶子结点指的是空结点)
(走到NULL才算一条路径)
3. 结构定义
![](https://i-blog.csdnimg.cn/blog_migrate/7281c299cac2dc74a2390bdead493297.png)
使用枚举来记录红色与黑色,用_col表示当前节点颜色
但是在构造函数中为什么默认是红色呢?为什么不能是黑色呢?
关于默认节点为红/黑色的讨论
![](https://i-blog.csdnimg.cn/blog_migrate/a4b8a75435b5bd8ef6755999bceb8940.png)
若在红框中插入黑色节点则违反规则4 即每条路径上都有相同数量的黑色节点,还需要再次将不同路径上都添加黑色节点,影响太大
![](https://i-blog.csdnimg.cn/blog_migrate/14ae93d9956c64967b1919acc798f7d6.png)
若在红框中插入红色节点,则有可能违反规则3(存在两个连续的红色节点)
当前情况违反规则3
![](https://i-blog.csdnimg.cn/blog_migrate/ab373e353e7b69a16041987a5de40b06.png)
若插入红色节点后,父节点为黑色,则不违反规则3
所以默认节点为红色更利于去解决问题
4. insert
grandfather节点省略为g ,uncle节点省略为u ,parent节点省略为p,cur节点省略为c
情况1—— uncle节点存在且为红色(g p c左斜形成一条直线)
![](https://i-blog.csdnimg.cn/blog_migrate/3ddb42fff0d0afbf525ca3372e2fdd31.png)
当插入红色节点后,与父节点形成连续的红色节点
把parent节点变成黑色,uncle节点置为黑色,并将grandfather节点置为红色
若grandfather节点的父节点为黑色,则不需要继续处理
若grandfather节点的父节点为红色,把当前的grandfather节点作为新增节点cur,继续向上调整
![](https://i-blog.csdnimg.cn/blog_migrate/02ea55769bdb54554018c94507a4ec23.png)
情况2——uncle节点不存在/存在且为黑色(g p c 左斜形成直线 右单旋)
uncle节点不存在
![](https://i-blog.csdnimg.cn/blog_migrate/a58f3575a7c4c7a651b6230975088117.png)
当uncle节点不存在时,则cur作为新增节点,
因为红黑树也是一种二叉搜索树,因为左边高,所以进行右单旋
uncle节点存在并且为黑色
![](https://i-blog.csdnimg.cn/blog_migrate/bdba3b9fe5e684a445ba75d1bde66cff.png)
首先进行变色,将新增节点的上面两个节点置为黑色,再将cur节点置为红色
同时需要进行右旋转
将c作为g的左子树,将g作为p的右子树
将g置为红色
将p置为黑色
![](https://i-blog.csdnimg.cn/blog_migrate/ad529c731959d54603d4a5a62421a1e9.png)
RotateR/RotateL的实现,与AVL树的类似,只需把原来的代码的平衡因子去掉即可
不懂查看:AVL树的实现
情况3——uncle节点不存在/存在且为黑色(g p c 形成左折线 双旋)
因为 grandfather(g) parent( p) cur( c) 节点为一条折线,所以为双旋
uncle节点不存在
![](https://i-blog.csdnimg.cn/blog_migrate/c32335bd5945a816c61c79746a878dae.png)
作为这样的折线存在,所以要进行双旋
uncle节点存在并且为黑色
![](https://i-blog.csdnimg.cn/blog_migrate/d1458db6a9692f54b04606e8df965a52.png)
首先进行变色,将新增节点上面的两个节点由红色置为黑色
再将cur节点由黑色置为红色
![](https://i-blog.csdnimg.cn/blog_migrate/cce81b26b79dc0f3e0dd586291a47156.png)
在进行左单旋,将cur的左子树节点 作为p的右子树,将p作为cur的左子树
进行右单旋,将cur的右子树节点作为g的左子树,将g作为cur的右子树
最终cur变为黑色,g变为红色
![](https://i-blog.csdnimg.cn/blog_migrate/e1e3dbcd8d720602b6e87291b3b6a2e6.png)
情况1—— uncle节点存在且为红色(g p c右斜形成一条直线)
当插入红色节点后,与父节点形成连续的红色节点
把parent节点变成黑色,uncle节点置为黑色,并将grandfather节点置为红色
若grandfather节点的父节点为红色,把当前的grandfather节点作为新增节点cur,继续处理
与上述左斜形成直线的写法相同
情况2——uncle节点不存在/存在且为黑色(g p c 右斜形成直线 左单旋)
这里以节点不存在举例
此时的uncle节点处于NULL
将parent节点置为黑色,将grandfather节点置为红色
并进行旋转,将1作为6的左子树,将6作为8的左子树
相当于进行左单旋
![](https://i-blog.csdnimg.cn/blog_migrate/6ff8b62c194ef6b395ab23e03d12d6c9.png)
情况3——uncle节点不存在/存在且为黑色(g p c 形成右折线 双旋)
![](https://i-blog.csdnimg.cn/blog_migrate/0bdbaef20efb2fe1e9757d224529a501.png)
首先进行变色,将新增节点上面的两个节点由红色置为黑色
再将cur节点由黑色置为红色
在进行右单旋,将cur的右子树节点 作为p的左子树,将p作为cur的右子树
进行左单旋,将cur的左子树节点作为g的右子树,将g作为cur的左子树
最终cur变为黑色,g变为红色
![](https://i-blog.csdnimg.cn/blog_migrate/44cf0c8f5251a9dc76ffc92257d77295.png)
5.判断是否为红黑树
![](https://i-blog.csdnimg.cn/blog_migrate/efd3927bfb2cfbe9f4da8bdb1541c960.png)
规则中要求根节点为黑色,所以当根为红色时就返回false
连续的红色节点
若当前节点为红时,检查儿子是否为红,但是儿子节点有可能为空
所以采用当前节点为红时,若父节点也为红,则返回false
使用blacknum用于记录每条路径的黑色节点个数
blacknum作为一个形参传值调用,下一层的++不会影响上一层
如果当前节点的颜色为黑色,则blacknum++
6. 整体代码
#pragma once
#include<iostream>
#include<cassert>
using namespace std;
enum colour
{
RED,//红色 默认为0
BLACK,//黑色 默认为1
};
template<class K, class V>
struct RBTreeNode
{
RBTreeNode<K, V>* _left;
RBTreeNode<K, V>* _right;
RBTreeNode<K, V>* _parent;
pair<K, V> _kv;//当前节点值
colour _col;//表示颜色
RBTreeNode(const pair<K, V>& kv)
:_left(nullptr),
_right(nullptr),
_parent(nullptr),
_kv(kv),
_col(RED)
{
}
};
template<class K,class V>
class RBTree
{
typedef RBTreeNode<K,V> Node;
public:
bool insert(const pair<K, V>& kv)
{
if (_root == nullptr)
{
_root = new Node(kv);
_root->_col = BLACK;//若刚插入一个节点,则该节点颜色是黑色
return true;
}
Node* parent = nullptr;//用于记录cur的前一个节点
Node* cur = _root;
while (cur)
{
//若插入的值比当前树的值小 插入左边
if (cur->_kv.first > kv.first)
{
parent = cur;
cur = cur->_left;
}
//若插入的值比当前树的值大 插入右边
else if (cur->_kv.first < kv.first)
{
parent = cur;
cur = cur->_right;
}
else
{
//若插入的值,在树中有相同的值 ,则插入失败
return false;
}
}
cur = new Node(kv);
//再次判断parent当前节点值与插入值大小
if (parent->_kv.first > kv.first)
{
parent->_left = cur;
}
else
{
parent->_right = cur;
}
//cur的上一个节点即为 刚才的记录cur前一个节点的parent
cur->_parent = parent;
//当父节点不为NULL并且父节点为红色
while (parent != nullptr && parent->_col == RED)
{
Node* grandfather = parent->_parent;//爷爷节点
//若父节点为爷爷节点的左子树,则unlce为爷爷节点的右子树
if (grandfather->_left == parent)
{
Node* uncle = grandfather->_right;
// g
// p u
// c
//情况1:u存在并且为红,直接变色即可,并继续往上处理
if (uncle && uncle->_col == RED)
//若uncle节点为红色,将parent与uncle都置为黑色,爷爷节点置为红色
{
parent->_col = BLACK;
uncle->_col = BLACK;
grandfather->_col = RED;
//继续往上调整
cur=grandfather;
parent = cur->_parent;
}
//情况2+3:u不存在或者u存在且为黑,旋转+变色
else
{
//情况2
//g p c 作为一条直线 所以为单旋
// g
// p u
//c
if (cur == parent->_left)
{
//右旋转
RotateR(grandfather);
//最终p作为最终的根 为黑 g为红
parent->_col = BLACK;
grandfather->_col = RED;
}
//情况3
//g p c 作为一条折线 所以为双旋
// g
// p u
// c
else
{
//左单旋
RotateL(parent);
//右单旋
RotateR(grandfather);
//最终cur作为最终的根 为黑 g为红
cur->_col = BLACK;
grandfather->_col = RED;
//父节点继续保持红色
parent->_col = RED;
}
break;
}
}
else//grandfather->_right == parent
若父节点为爷爷节点的右子树,则unlce为爷爷节点的左子树
{
// g
// u p
// c
Node* uncle = grandfather->_left;
//情况1:u存在并且为红,直接变色即可,并继续往上处理
if (uncle && uncle->_col == RED)
//若uncle节点为红色,将parent与uncle都置为黑色,爷爷节点置为红色
{
parent->_col = BLACK;
uncle->_col = BLACK;
grandfather->_col = RED;
//继续往上调整
cur = grandfather;
parent = cur->_parent;
}
//情况2+3:u不存在或者u存在且为黑,旋转+变色
else
{
//情况2
//g p c 作为一条直线 所以为单旋
// g
// u p
// c
if (cur == parent->_right)
{
//左旋转
RotateL(grandfather);
//最终p作为最终的根 为黑 g为红
parent->_col = BLACK;
grandfather->_col = RED;
}
//情况3
//g p c 作为一条折线 所以为双旋
// g
// u p
// c
else
{
//右单旋
RotateR(parent);
//左单旋
RotateL(grandfather);
//最终cur作为最终的根 为黑 g为红
cur->_col = BLACK;
grandfather->_col = RED;
}
break;
}
}
}
//为了避免grandfather节点正好为根时,会被更新成红色的情况
_root->_col = BLACK;
return true;
}
void inorder()//中序遍历
{
_inorder(_root);
cout << endl;
}
//判断一颗二叉树是否为红黑树
bool isbalance()
{
//检查根是否为黑
if (_root && _root->_col == RED)
{
cout << "根节点颜色是红色" << endl;
return false;
}
//连续的红色节点
return _check(_root,0);
}
private:
bool _check(Node* root,int blacknum)
{
if (root == nullptr)
{
//为空时,blacknum代表一条路径的黑色节点个数
cout << blacknum << " ";
return true;
}
//blacknum代表黑色节点的个数
if (root->_col == BLACK)
{
blacknum++;
}
//若当前节点为红 父节点也为红
if (root->_col == RED
&&root->_parent
&&root->_parent->_col==RED)
{
cout << "存在连续的红色节点" << endl;
return false;
}
//遍历整棵树
return _check(root->_left,blacknum) && _check(root->_right,blacknum);
}
void _inorder(Node* root)
{
if (root == nullptr)
{
return;
}
_inorder(root->_left);
cout << root->_kv.first << " ";
_inorder(root->_right);
}
void RotateL(Node* parent)//左单旋
{
Node* subR = parent->_right;
Node* subRL = subR->_left;
parent->_right = subRL;
if (subRL != nullptr)
{
subRL->_parent = parent;
}
Node* ppnode = parent->_parent;//记录parent的前一个节点
subR->_left = parent;
parent->_parent = subR;
if (ppnode == nullptr)//说明parent是根即代表整棵树
{
_root = subR;//subR作为新的根
_root->_parent = nullptr;//subR的父节点指向原来的parent,所以要置nullptr
}
else//说明旋转的是一部分,所以要跟ppnode相连接
{
if (ppnode->_left == parent)//若连接在左子树上
{
ppnode->_left = subR;
}
else//若连接在右子树上
{
ppnode->_right = subR;
}
subR->_parent = ppnode;//将subR父节点置为ppnode
}
}
void RotateR(Node* parent)//右单旋
{
Node* subL = parent->_left;
Node* subLR = subL->_right;
parent->_left = subLR;
if (subLR != nullptr)
{
subLR->_parent = parent;
}
Node* ppnode = parent->_parent;//记录parent的父节点
subL->_right = parent;
parent->_parent = subL;
if (ppnode == nullptr)//若旋转整棵树
{
_root = subL;
_root->_parent = nullptr;
}
else//若旋转整棵树的部分子树
{
if (ppnode->_left == parent)
{
ppnode->_left = subL;
}
else
{
ppnode->_right = subL;
}
subL->_parent = ppnode;//使subL的父节点为ppnode
}
}
private:
Node* _root = nullptr;
};
void test_RBTree1()
{
int a[]={16, 3, 7, 11, 9, 26, 18, 14, 15};
//int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16,14 };
RBTree<int, int>v1;
for (auto e : a)
{
v1.insert(make_pair(e, e));
}
v1.inorder();
cout << v1.isbalance() << endl;
}