红黑树的性质和实现
红黑树
由于AVL树为了保持平衡需要经常旋转，开销是很大的。因此，红黑树比起AVL树放宽了平衡的限制。
概念
红黑树，在每个节点上增加一个存储位表示节点的颜色，可以是RED或BLACK。
通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍
因而AVL树是严格平衡，红黑树是接近平衡的
红黑树的性质
首先声明一个定义：简单路径。
从根节点走到NIL节点就是一条简单路径。（NIL节点也就是空节点）
-
每个节点不是黑色就是红色
-
根节点是黑色的
-
如果一个节点是红色的，则它的两个孩子节点必须是黑色的
也就是说：任何路径上没有连续的红色节点
-
对于每个结点，从该结点到其所有后代叶结点的简单路径上，均包含相同数目的黑色结点
可以简单的认为：每条路径上黑色节点的数量相同
-
每个NIL节点都是黑色的
思考：为什么满足上面的性质，红黑树就能保证：其最长路径中节点个数不会超过最短路径节点个数的两倍？
首先要知道：红黑树中，最短路径为全黑路径，最长路径为一黑一红交替路径
再由于每条路径的黑色节点数相同，就能够保证：2*最短路径≤最长路径
红黑树的节点设计
enum Color
{
RED,
BLACK
};
template
struct RETreeNode
{
RETreeNode* _parent;
RETreeNode* _left;
RETreeNode* _right;
pair _kv;
Color _col;
RETreeNode(const pair& kv)
:_kv(kv)
, _parent(nullptr)
, _left(nullptr)
, _right(nullptr)
, _col(RED)
{}
};
插入的新结点的默认颜色应该是红色。（宁愿是违反性质三也不去违反性质四）
假设插入的是黑色节点，那么路径之间的黑节点的个数不再相同，所有路径都出现了问题
假设插入的是红节点：如果其父亲是黑节点那么一点问题都没有；如果父亲是红节点，那么也只有这一条路径有问题
红黑树的框架设计
template
class RBTree
{
typedef RETreeNode Node;
public:
//……
private:
Node* _root = nullptr;
};
红黑树的插入
红黑树是在二叉搜索树的基础上加上其平衡限制条件，因此红黑树的插入可分为两步：
- 按照二叉搜索的树规则插入新节点
- 检测新节点插入后，红黑树的性质是否造到破坏
bool Insert(const pair，下面分布来讲：
第一步：插入节点
//如果为空，则直接新建节点插入即可
if (_root == nullptr)
{
_root = new Node(kv);
_root->_col = BLACK;//根节点为黑
return true;
}
Node* cur = _root;
Node* parent = _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);
cur->_parent = parent;
if (parent->_kv.first < kv.first)
{
parent->_right = cur;
}
else
{
parent->_left = cur;
}
这里的逻辑就是二叉搜索树插入的逻辑
第二步：检测红黑树性质是否被破坏
因为新节点的默认颜色是红色，因此：
- 如果其双亲节点的颜色是黑色，没有违反红黑树任何性质，则不需要调整
- 但当新插入节点的双亲节点颜色为红色时，就违反了性质三不能有连在一起的红色节点
此时需要对红黑树分情况来讨论：
约定:cur为当前节点，p为父节点，g为祖父节点，u为叔叔节点
情况一：cur为红，p为红，g为黑，u存在且为红
此处看到的树，可能是一棵完整的树，也可能是一棵子树
此外cur并不一定是新插入的节点，有可能是正好向上调整到这个节点
处理方法：
-
p和u变黑，g变红
此时，局部子树里面，已满足红黑树的性质
-
继续向上处理：
- g没有父亲，即g就是根节点，那么将g变黑即可。插入完成
- g有父亲，且父亲是黑色。那么此时插入完成
- g有父亲，父亲是红色。将g作为cur，和刚才是相同的处理方式。
这里向上处理是个循环，而循环的结束条件为：g的父亲不存在或者g的父亲存在且为黑
情况二：cur为红，p为红，g为黑，u不存在或者u存在且为黑
u的情况有两种：
-
如果u不存在，则cur一定是新插入的节点。因为如果不是，那么cur和p一定有一个节点为黑色，此时就不满足性质4了
-
如果u存在且为黑，那么cur节点原来的颜色一定是黑色。现在看到其是红色的原因是因为cur在子树调整的过程中将cur从黑色变成红色了
由于涉及旋转，所以需要对g、p、u的位置进行判断，以便使用对应的旋转
最终代码：
//判断是否破坏红黑树的性质
while (parent && parent->_col == RED)
{
Node* grandfather = parent->_parent;
if (parent == grandfather->_left) //parent在grandfather的左边
{
Node* uncle = grandfather->_right;
if (uncle && uncle->_col == RED)//uncle存在且为红
{
//直接变色
parent->_col = uncle->_col = BLACK;
grandfather->_col = RED;
//再向上判断调整
cur = grandfather;
parent = cur->_parent;
}
else//uncle不存在或为黑
{
if (cur == parent->_left) //cur在parent左侧，需要右单旋
{
RotateR(grandfather);
parent->_col = BLACK;
grandfather->_col = RED;
}
else//cur在parent右侧，需要左右双旋
{
RotateL(parent);
RotateR(grandfather);
cur->_col = BLACK;
grandfather->_col = RED;
}
break;
}
}
else//parent在grandfather的右边
{
Node* uncle = grandfather->_left;
if (uncle && uncle->_col == RED)//uncle存在且为红
{
//直接变色
parent->_col = uncle->_col = BLACK;
grandfather->_col = RED;
//再向上判断调整
cur = grandfather;
parent = cur->_parent;
}
else//uncle不存在或为黑
{
if (cur == parent->_right) //cur在parent右侧，需要左单旋
{
RotateL(grandfather);
parent->_col = BLACK;
grandfather->_col = RED;
}
else //cur在parent左侧，需要右左双旋
{
RotateR(parent);
RotateL(grandfather);
cur->_col = BLACK;
grandfather->_col = RED;
}
break;
}
}
}
//不管三七二十一，根节点一定为黑
_root->_col = BLACK;
return true;
插入的完整代码
bool Insert(const pair& kv)
{
if (_root == nullptr)
{
_root = new Node(kv);
_root->_col = BLACK;//根节点为黑
return true;
}
Node* cur = _root;
Node* parent = _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);
cur->_parent = parent;
if (parent->_kv.first < kv.first)
{
parent->_right = cur;
}
else
{
parent->_left = cur;
}
//判断是否破坏红黑树的性质
while (parent && parent->_col == RED)
{
Node* grandfather = parent->_parent;
if (parent == grandfather->_left) //parent在grandfather的左边
{
Node* uncle = grandfather->_right;
if (uncle && uncle->_col == RED) //uncle存在且为红
{
//直接变色
parent->_col = uncle->_col = BLACK;
grandfather->_col = RED;
//再向上判断调整
cur = grandfather;
parent = cur->_parent;
}
else //uncle不存在或为黑
{
if (cur == parent->_left) //cur在parent左侧，需要右单旋
{
RotateR(grandfather);
parent->_col = BLACK;
grandfather->_col = RED;
}
else //cur在parent右侧，需要左右双旋
{
RotateL(parent);
RotateR(grandfather);
cur->_col = BLACK;
grandfather->_col = RED;
}
break;
}
}
else //parent在grandfather的右边
{
Node* uncle = grandfather->_left;
if (uncle && uncle->_col == RED) //uncle存在且为红
{
//直接变色
parent->_col = uncle->_col = BLACK;
grandfather->_col = RED;
//再向上判断调整
cur = grandfather;
parent = cur->_parent;
}
else //uncle不存在或为黑
{
if (cur == parent->_right) //cur在parent右侧，需要左单旋
{
RotateL(grandfather);
parent->_col = BLACK;
grandfather->_col = RED;
}
else //cur在parent左侧，需要右左双旋
{
RotateR(parent);
RotateL(grandfather);
cur->_col = BLACK;
grandfather->_col = RED;
}
break;
}
}
}
//根节点一定为黑
_root->_col = BLACK;
return true;
}
//左单旋
void RotateL(Node* parent)
{
Node* cur = parent->_right;
Node* curleft = cur->_left;
parent->_right = curleft;
if (curleft)
{
curleft->_parent = parent;
}
cur->_left = parent;
Node* ppnode = parent->_parent;//记录parent的原父亲节点
parent->_parent = cur;
//对cur的父亲进行更新
if (parent == _root)
{
_root = cur;
cur->_parent = nullptr;
}
else//说明左旋的部分只是某棵树的局部
{
if (ppnode->_left == parent)
{
ppnode->_left = cur;
}
else
{
ppnode->_right = cur;
}
cur->_parent = ppnode;
}
}
//右单旋
void RotateR(Node* parent)
{
Node* cur = parent->_left;
Node* curright = cur->_right;
//让右节点接到parent的左边，再将parent接到cur的右边
parent->_left = curright;
if (curright)
{
curright->_parent = parent;
}
cur->_right = parent;
Node* ppnode = parent->_parent;//记录parent的原父亲节点
parent->_parent = cur;
//对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)//这里的blacknum不能是引用，为的就是当回退到根节点时blacknum的值为1，这样能使各路径的黑节点个数之间不会相互影响
{
//当root为空，说明该路径走到头了，此时将统计的黑节点个数与基准值进行比较
if (root == nullptr)
{
if (blacknum != benchmark)
return false;
return true;
}
if (root->_col == BLACK)
++blacknum;
//若root为红，且root的父亲存在也为红
if (root->_col == RED && root->_parent && root->_parent->_col == 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->_col != BLACK)
return false;
//为了判断各路径的黑节点个数是否相同，先给出一个基准值(以最左或最右路径为基准值)
int benchmark = 0;//基准值
Node* cur = root;
while (cur)
{
if (cur->_col == BLACK)
++benchmark;
cur = cur->_left;
}
return CheckColour(root, 0, benchmark);
}
AVL树和红黑树的比较
AVL树优势在于树的高度低，而红黑树的优势在于旋转次数少
单看搜索，AVL树的效率大概是红黑树的两倍
但其实对于CPU而言，搜索30次和搜索60次，几乎没有区别
所以我们认为两者的性能是同一量级的
但是AVL树控制严格平衡是付出代价的，插入和删除时需要进行大量旋转。而红黑树减少了旋转的次数
我们通过如下代码对AVL树和红黑树的高度和旋转次数进行对比：
分别在AVLTree.h和RBTree.h中添加如下代码：
public:
//计算高度
//获取树的高度
int TreeHeight()
{
return TreeHeight(_root);
}
int TreeHeight(Node* root)
{
if (root == nullptr)
return 0;
int leftHeight = TreeHeight(root->_left);
int rightHeight = TreeHeight(root->_right);
return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
}
//增加一个公有成员：旋转次数
public:
int _rotateCount = 0;//旋转次数
//分别在红黑树和AVL树的左单旋与右单旋的开头增加一行代码： ++_rotateCount
main.cpp中调用代码如下：
#include"RBTree.h"
#include"AVLTree.h"
#include
int main()
{
const int N = 1000000;
vector v;
v.reserve(N);
srand(time(0));
for (size_t i = 0; i < N; i++)
{
v.push_back(rand());
}
RBTree rbt;
for (auto e : v)
{
rbt.Insert(make_pair(e, e));
}
cout <<"红黑树是否平衡："< avlt;
for (auto e : v)
{
avlt.Insert(make_pair(e, e));
}
cout <<"AVL树是否平衡："< 两次运行结果：
总结：两个树都是高效的平衡二叉树，增删查改的时间复杂度都是logN。不过红黑树降低了旋转次数，因此相对AVL树更优一点，所以被使用的也更多