1. 红黑树概念
红黑树,本质是一颗二叉搜索树 + 节点颜色限制(红/黑) + 规则约定(最长路径中的节点个数不超过最短路径中节点个数的2倍)
在二叉搜索树中,每个节点上增加一个存储位表示节点的颜色,可能是红色或黑色。
对于任何一条根到叶子节点路径上各个节点的着色方式的限制,红黑树确保没有没有一条比其它路径长出两倍,因而接近平衡二叉树,或者说近似平衡。
2. 红黑树性质
- 每个节点不是黑色就是红色
- 根节点是黑色
- 如果有一个节点是红色的,则它的两个孩子节点必定是黑色,不可能出现连在一起的红色节点
- 对于每个节点,从该节点到其它所有后代叶节点的路径上,均包含相同数据的黑色节点,每条路径中的黑色节点数量相同
- 每个空指针域都是黑色
为什么满足上述性质,就能保证红黑树最长路径长度不超过最短路径的2倍?
最重要的是要保证每条路径中黑色节点的个数相同,并且红色节点不能连续出现,所以就保证了最长路径不超过最短路径的二倍。
3. 红黑树的调整算法
新插入节点默认位红色,因为在向红黑树中插入新节点时,如果其双亲结点的颜色是黑色的,则不会违反红黑树的性质,如果其双亲是红色的,插入红色结点后,就会违反性质四,需要对红黑树进行调整。如果新插入结点颜色位黑色,那么每次插入新节点都会违反性质四。
3.1 红黑树插入时需要调整的情况
根据上述我们知道,插入默认节点的颜色时红色,当其父节点为黑色时,树不需要进行调整,但当其父节点为红色时需要调整。
当前结点:cur,父节点:p,祖父结点:g,叔叔结点:u
1. 当前结点为红色,父节点为红色,祖父结点为黑色,叔叔结点存在且为红色
此种情况较简单,只需要修改父节点为黑色,叔叔节点为黑色,祖父结点为红色即可。
注意: 如果祖父为树中的一颗子树,则需要注意祖父结点的父节点的状态,如果祖父结点的父节点为红色,那么违反了性质三,还需要向上调整。
2. 当前结点为红色,父节点为红色,祖父结点为黑色,叔叔结点不存在/为黑,cur是p的左孩子
- 如果叔叔结点不存在,则cur一定是新插入结点,如果cur不是新插入结点,则cur和p一定有一个结点的颜色时黑色,则cur和p一定有一个颜色是黑色,已经不满足性质了,所以不会到这一步。
- 如果叔叔几结点存在,则其一定为黑色,并且cur原来的结点一定是黑色的,cur变红的原因是cur的子树在调整的过程中影响了该结点。
这里我们只看一种情况,因为上述两种情况差不了多少。
p是g的左孩子,cur是p的左孩子: 先右单旋,修改p为黑色,g为红色
3. 当前结点为红,父节点为红,祖父结点为黑,叔叔结点不存在/为黑,cur是p的右孩子
先针对p
结点进行左旋,就会变成情况二的样子,之后按照情况二的处理方式处理即可。
注意:还有以上三种情况的逆情况,即树型与上述相仿,就不再赘述,只需要将操作反过来即可,下方代码中会有实现。
4. 模拟一下
序列:1 2 9 4 6 5
5. 代码实现
// 请模拟实现红黑树的插入--注意:为了后序封装map和set,本文在实现时给红黑树多增加了一个头结点
enum Color { RED, BLACK };
template<class T>
struct RBTreeNode
{
RBTreeNode<T>* _pLeft;
RBTreeNode<T>* _pRight;
RBTreeNode<T>* _pParent;
T _data;
Color _color;
RBTreeNode(const T& val = T(), Color c = RED)
: _pLeft(nullptr)
, _pRight(nullptr)
, _pParent(nullptr)
, _data(val)
, _color(c)
{}
};
template<class T>
class RBTree
{
typedef RBTreeNode<T> Node;
public:
RBTree()
{
_pHead = new Node;
_pHead->_pLeft = _pHead;
_pHead->_pRight = _pHead;
}
// 在红黑树中插入值为data的节点,插入成功返回true,否则返回false
// 注意:为了简单起见,本次实现红黑树不存储重复性元素
bool Insert(const T& data)
{
Node* pRoot = GetRoot();
// 如果为空树, 则插入头节点并且为黑色
if (nullptr == pRoot)
{
pRoot = new Node(data, BLACK);
pRoot->_pParent = pHead;
return true;
}
// 非空树
else
{
// 1.查找待插入节点在红黑树中的位置
Node* pCur = pRoot;
Node* pParent = nullptr;
while (pCur)
{
pParent = pCur;
if (data < pCur->_data)
{
pCur = pCur->_pLeft;
}
else if (data > pCur->_data)
{
pCur = pCur->_pRight;
}
else
{
return false;
}
}
// 2. 插入新节点,调整使其满足红黑树的性质
pCur = new Node(data);
if (data < pParent->_data)
{
pParent->_pLeft = pCur;
}
else
{
pParent->_pRight = pCur;
}
pCur->_pParent = pParent;
// 3. 红黑树性质可能遭到破坏
// 插入的新节点默认为红色
// 看pCur双亲是否时黑色,如果是黑色,则没有破坏性质
// 不是黑色,破坏了性质3,需要调整
// 子树调整完之后,可能破坏了上面树的性质,所以还需要向上调整
while (pParent != _pHead && RED == pParent->_color)
{
Node* granderFather = pParent->_pParent;
// 情况分为三种
if (pParent == granderFather->_pLeft)
{
Node* uncle = granderFather->_pRight;
// 情况一: cur为红, pParent为红,grand为黑,uncle存在且为红
// 该情况下,只需要判断叔叔节点,引为其它节点颜色一定满足,因为他们之前是一颗满足条件的红黑树
if (uncle && RED == uncle->_color)
{
// 只需要调整颜色即可
// 祖父节点黑色,父节点与叔叔节点调整为红色
granderFather->_color = RED;
pParent->_color = BLACK;
uncle->_color = BLACK;
// 移动节点位置,继续向上调整
pCur = granderFather;
pParent = pCur->_pParent;
}
else
{
// 情况二 三:cur为红,parent为红,grander为黑,u不存在或者为黑
// 情况二:cur为parent的左子树
// 情况三:cur为parent的右子树-->旋转一下,调整为parent的左子树即可
if (pCur == pParent->_rRight)
{
RotateL(pParent);
std::swap(pParent, pCur);
}
// 调整颜色后旋转 使其满足性质4
pParent->_color = BLACK;
granderFather->_color = RED;
RotateR(granderFather);
}
}
else
{
// 反着的情况一二三
Node* uncle = granderFather->_pLeft;
if (uncle && RED == uncle->_color)
{
// 只需要调整颜色即可
// 祖父节点黑色,父节点与叔叔节点调整为红色
granderFather->_color = RED;
pParent->_color = BLACK;
uncle->_color = BLACK;
// 移动节点位置,继续向上调整
pCur = granderFather;
pParent = pCur->_pParent;
}
else
{
if (pCur == pParent->_rLeft)
{
RotateL(pParent);
std::swap(pParent, pCur);
}
// 调整颜色后旋转 使其满足性质4
pParent->_color = BLACK;
granderFather->_color = RED;
RotateR(granderFather);
}
}
}
}
// 根节点一定要为黑色
pRoot->_color = BLACK;
_pHead->_pLeft = LeftMost();
_pHead->_pRight = RightMost();
return true;
}
// 检测红黑树中是否存在值为data的节点,存在返回该节点的地址,否则返回nullptr
Node* Find(const T& data)
{
Node* pCur = GetRoot();
while (pCur)
{
if (data < pCur->_data)
{
pCur = pCur->_pLeft;
}
else if (data > pCur->_data)
{
pCur = pCur->_pRight;
}
else
{
return pCur;
}
}
return nullptr;
}
// 获取红黑树最左侧节点
Node* LeftMost()
{
Node* pCur = GetRoot();
if (nullptr == pCur)
{
return _pHead;
}
while (pCur->_pLeft)
{
pCur = pCur->_pLeft;
}
return pCur;
}
// 获取红黑树最右侧节点
Node* RightMost()
{
Node* pCur = GetRoot();
if (nullptr == pCur)
{
return _pHead;
}
while (pCur->_pRight)
{
pCur = pCur->_pRight;
}
return pCur;
}
// 检测红黑树是否为有效的红黑树,注意:其内部主要依靠_IsValidRBTRee函数检测
bool IsValidRBTRee()
{
Node* pRoot = GetRoot();
// 空树满足红黑树的性质
if (nullptr == pRoot)
{
return true;
}
if (BLACK != pRoot->_color)
{
cout << "违反性质2:根节点应为黑色" << endl;
return false;
}
// 检测性质4:每条路径的黑色节点应当一致
// 获取一条路径的黑色节点个数
Node* pCur = root;
size_t blackCount = 0;
while (pCur)
{
if (BLACK == pCur->_color)
{
blackCount++;
}
pCur = pCur->_pLeft;
}
// 检测其它路径黑色节点的个数
return _IsValidRBTRee(pRoot, blackCount, 0);
}
private:
bool _IsValidRBTRee(Node* pRoot, size_t blackCount, size_t pathBlack)
{
if (nullptr == pRoot)
{
return true;
}
Node* pParent = pRoot->_pParent;
// 顺便检测性质三
if (pParent != _pHead && RED == pParent->_color && RED == pRoot->_color)
{
cout << "违反性质3:出现了连在一起的红色节点" << endl;
return false;
}
if (BLACK == pRoot->_color)
{
pathBlack++;
}
// pRoot已经遍历到了某条路径的末尾
if (nullptr == pRoot->_pLeft && nullptr == pRoot->_pRight)
{
if (pathBlack != blackCount)
{
cout << "违反性质4:每条路径黑色节点个数不相同" << endl;
reutrn false;
}
}
return _IsValidRBTRee(pRoot->_pLeft, blackCount, pathBlack) && _IsValidRBTRee(pRoot->_pRight, blackCount, pathBlack);
}
// 左单旋
void RotateL(Node* pParent)
{
Node* subR = pParent->_pRight;
Node* subRL = subR->_pLeft;
pParent->_pRight = subRL;
if (subRL)
{
subRL->_pParent = pParent;
}
subR->_pLeft = pParent;
Node* ppParent = pParent->_pParent;
pParent->_pParent = subR;
subR->_pParent = ppParent;
if (ppParent == _pHead)
{
_pHead->_pParent = subR;
}
else
{
if (pParent == ppParent->_pLeft)
{
ppParent->_pLeft = subR;
}
else
{
ppParent->_pRight = subR;
}
}
}
// 右单旋
void RotateR(Node* pParent)
{
Node* subL = pParent->_pLeft;
Node* subLR = subL->_pRight;
pParent->_pLeft = subRL;
if (subRL)
{
subRL->_pParent = pParent;
}
subR->_pRight = pParent;
Node* ppParent = pParent->_pParent;
pParent->_pParent = subR;
subR->_pParent = ppParent;
if (ppParent == _pHead)
{
_pHead->_pParent = subR;
}
else
{
if (pParent == ppParent->_pRight)
{
ppParent->_pRight = subR;
}
else
{
ppParent->_pLeft = subR;
}
}
}
// 为了操作树简单起见:获取根节点
Node*& GetRoot()
{
return _pHead->_pParent;
}
private:
Node* _pHead;
};