红黑树
什么是红黑树
红黑树是一种特殊的由二叉搜索树为底的数据结构,**之所以被成为红黑树,是因为在每个节点增加一个存储位表示这个节点的颜色,不是黑色就是红色,**因为其特数的规则,红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的。并具有更优的算法复杂度.
红黑树的规则
正是因为有以下规则的限制,红黑树才能是红黑树
- 每个结点不是红色就是黑色
- 根节点是黑色的
- 红色节点的两个孩子结点是黑色的,即
不存在两个连续的红色节点 - 从任一节点到其每个叶子节点的所有简单路径都包含相同数目的黑色节点：这也称为黑色平衡，确保树的高度相对平衡，从而保证了最长路径不超过最短路径的两倍。
- 叶子节点均为黑色
红黑树节点的定义
在定义节点之前,最好先定义一个枚举类型,用来记录每个节点的颜色
并且因为涉及到旋转调整,因此红黑树和AVL树一样需要记录父亲节点
enum Color
{
RED,
BLACK
};
template<class T>
struct RBTreeNode
{
RBTreeNode* _parent;
RBTreeNode* _left;
RBTreeNode* _right;
T _data;
Color _col;
RBTreeNode(const T& data = T(),Color color = RED)
:_parent(nullptr)
, _left(nullptr)
, _right(nullptr)
, _col(color)
, _data(data)
{}
};
红黑树的插入
红黑树的插入和AVL树的插入相似,但不同点是AVL树插入完成后改变的是平衡因子,而红黑树插入后改变的是节点的颜色.仅凭节点的旋转调整和节点颜色的改变就可以使之成为红黑树,不得不说发明红黑树的人真的是个天才!
因为涉及到后续迭代器的实现,因此我这里使用带头的红黑树来举例
我们将红黑树的插入分成几种情况依次来看
空树插入
当红黑树是空树时则直接插入,并且每次插入完成后将红黑树的根置为黑色,没什么特别的思路,直接上代码
if (_root == nullptr)
{
//根节点必须为黑色
Node* root = new Node(data, BLACK);
_root = root;
_root->_parent = _pHead;
_pHead->_parent = _root;
}
非空插入条件判断
新插入的节点为红色,并且按照正常的二叉搜索树的条件去依次插入
Node* cur = _root;
//像搜索二叉树一样插入
while (cur)
{
if (cur->_data > data)
{
parent = cur;
cur = cur->_left;
}
else if (cur->_data < data)
{
parent = cur;
cur = cur->_right;
}
else
{
return false;
}
}
//到位置了,创建节点并赋予红色
cur = new Node(data, RED);
//判断是父节点的左还是右并进行链接
if (data < parent->_data)
{
parent->_left = cur;
}
else
{
parent->_right = cur;
}
cur->_parent = parent;
链接完成后,查看父亲节点是否为红色
因为新节点为红色,若父节点也为红就需要进行调整
并且在每次插入完成后需要进行检查,若还是这种情况,则需要继续调整
新插入的节点 cur 不为 root 且 parent->_col 为红就需要调整
因为新插入的节点默认为红色,此时父亲节点也为红就需要进行调整
而红黑树的调整不仅仅只看cur节点和parent节点,还需要查看uncle(叔叔节点)和grandf(爷爷节点)节点及其颜色来进行判断
uncle节点:
接下来根据条件来进行调整
父节点为左 grandf->left == parent
当uncle节点为红色时,只需要进行颜色调整,即可
这种情况下这颗子树的黑色节点的高度依然没有发生变化
在进行颜色的调整后继续检查父亲节点
当uncle为空 或 者存在但是为黑
此时就要进行旋转和变色了,因为已经没有办法仅仅只通过变色来使这个子树的黑色节点的高度不发生变化了
parent 为left , cur 为 left 单纯的grandf右旋
uncle 为空
uncle不为空
此时当前的这个新插入的节点一定是从子树中调节变色变上来的,因为在有当前节点之前,parent一定有一个黑色节点的子树,否则这颗红黑树不平衡,
这种情况下这颗子树的黑色节点的高度依然没有发生变化
此时插入完成
parent 为left , cur 为 right 先左旋parent再右旋grandf
uncle为空
uncle不为空
父节点为右 grandf->right == parent
父节点为右时,与父节点为左完全相反,对照查看即可
代码实现
为了方便后续迭代器的实现,我使用了带头的红黑树:
定义头文件 RBTree.h
#pragma once
#include<iostream>
using namespace std;
enum Color
{
RED,
BLACK
};
template<class T>
struct RBTreeNode
{
RBTreeNode* _parent;
RBTreeNode* _left;
RBTreeNode* _right;
T _data;
Color _col;
RBTreeNode(const T& data = T(),Color color = RED)
:_parent(nullptr)
, _left(nullptr)
, _right(nullptr)
, _col(color)
, _data(data)
{}
};
template<class T>
class RBTree
{
typedef RBTreeNode<T> Node;
public:
RBTree()
{
_pHead = new Node();
_pHead->_left = _pHead;
_pHead->_right = _pHead;
}
// 在红黑树中插入值为data的节点，插入成功返回true，否则返回false
// 注意：为了简单起见，本次实现红黑树不存储重复性元素
bool Insert(const T& data)
{
Node*& _root = _pHead->_parent;
if (_root == nullptr)
{
//根节点必须为黑色
Node* root = new Node(data, BLACK);
_root = root;
_root->_parent = _pHead;
_pHead->_parent = _root;
}
else
{
Node* parent = nullptr;
Node* cur = _root;
//像搜索二叉树一样插入
while (cur)
{
if (cur->_data > data)
{
parent = cur;
cur = cur->_left;
}
else if (cur->_data < data)
{
parent = cur;
cur = cur->_right;
}
else
{
return false;
}
}
//到位置了,创建节点并赋予红色
cur = new Node(data, RED);
//判断是父节点的左还是右并进行链接
if (data < parent->_data)
{
parent->_left = cur;
}
else
{
parent->_right = cur;
}
cur->_parent = parent;
//链接完成后,查看父亲节点是否为红色
//因为新节点为红色,若父节点也为红就需要进行调整
while (parent != _pHead && parent->_col == RED)
{
Node* uncle = nullptr;
Node* grandf = parent->_parent;
if (grandf->_left == parent)
{
// g
// p u
// c/c
uncle = grandf->_right;
//叔叔存在且为红
if (uncle && uncle->_col == RED)
{
//变色
parent->_col = uncle->_col = BLACK;
grandf->_col = RED;
//继续往上更新
cur = grandf;
parent = cur->_parent;
}
//叔叔为空 或 者存在但是为黑
else
{
//p 为left cur 为 left 单纯的右旋
if (cur == parent->_left)
{
RotateR(grandf);
parent->_col = BLACK;
grandf->_col = RED;
}
//p 为left cur 为 right 先左旋p再右旋grandf
else
{
RotateL(parent);
RotateR(grandf);
cur->_col = BLACK;
grandf->_col = RED;
}
break;
}
}
else //grandf->_right == parent
{
// g
// u p
// c/c
uncle = grandf->_left;
//叔叔存在且为红
if (uncle && uncle->_col == RED)
{
//变色
parent->_col = uncle->_col = BLACK;
grandf->_col = RED;
//继续往上更新
cur = grandf;
parent = cur->_parent;
}
//叔叔不存在或者 叔叔为黑
else
{
//p 为 right c 为 right 单纯的左旋
if (cur == parent->_right)
{
RotateL(grandf);
parent->_col = BLACK;
grandf->_col = RED;
}
//p 为 right c 为 left 先右旋parent再左旋grandf
else
{
RotateR(parent);
RotateL(grandf);
cur->_col = BLACK;
grandf->_col = RED;
}
break;
}
}
}
}
_root->_col = BLACK;
_pHead->_left = LeftMost();
_pHead->_right = RightMost();
return true;
}
// 检测红黑树中是否存在值为data的节点，存在返回该节点的地址，否则返回nullptr
Node* Find(const T& data)
{
Node*& _root = _pHead->_parent;
Node* cur = _root;
while (cur)
{
if (cur->_data > data)
{
cur = cur->_left;
}
else if (cur->_data < data)
{
cur = cur->_right;
}
else
{
return cur;
}
}
return nullptr;
}
// 获取红黑树最左侧节点
Node* LeftMost()
{
if (_pHead->_parent == nullptr)
{
return _pHead;
}
Node* root = _pHead->_parent;;
while (root->_left)
{
root = root->_left;
}
return root;
}
// 获取红黑树最右侧节点
Node* RightMost()
{
if (_pHead->_parent == nullptr)
{
return _pHead;
}
Node* root = _pHead->_parent;;
while (root->_right)
{
root = root->_right;
}
return root;
}
// 检测红黑树是否为有效的红黑树，注意：其内部主要依靠_IsValidRBTRee函数检测
bool IsValidRBTRee()
{
Node*& _root = _pHead->_parent;
//空树
if (_root == nullptr)
{
return true;
}
else if(_root->_col == BLACK)
{
size_t blacknum = 0;
Node* cur = _root;
while (cur)
{
if (cur->_col == BLACK)
{
blacknum++;
}
cur = cur->_left;
}
size_t k = 0;
return _IsValidRBTRee(_root, k , blacknum);
}
else
{
return false;
}
}
void InOrder()
{
_InOrder(_pHead->_parent);
cout << endl;
}
private:
void _InOrder(Node* root)
{
if (root == nullptr)
{
return;
}
_InOrder(root->_left);
cout << root->_data << ":";
if (root->_col == RED)
{
cout << "red"<<endl;
}
else
{
cout << "black" << endl;
}
_InOrder(root->_right);
}
bool _IsValidRBTRee(Node* root, size_t k, size_t blacknum )
{
if (root == nullptr)
{
if (k != blacknum)
{
cout << "黑色节点平衡" << endl;
return false;
}
return true;
}
if (root->_col == BLACK)
{
k++;
}
Node* parent = root->_parent;
if (parent && parent->_col == RED && parent != _pHead && root->_col == RED)
{
cout << "有连续的红色节点" << endl;
return false;
}
return _IsValidRBTRee(root->_left, k, blacknum)
&& _IsValidRBTRee(root->_right, k, blacknum);
}
// 左单旋
void RotateL(Node* parent)
{
Node*& _root = _pHead->_parent;
Node* subR = parent->_right;
Node* subRL = subR->_left;
parent->_right = subRL;
subR->_left = parent;
Node* pparent = parent->_parent;
parent->_parent = subR;
if (subRL)
{
subRL->_parent = parent;
}
if (parent == _root)
{
_root = subR;
subR->_parent = _pHead;
}
else
{
if (pparent->_left == parent)
{
pparent->_left = subR;
}
else
{
pparent->_right = subR;
}
subR->_parent = pparent;
}
}
// 右单旋
void RotateR(Node* parent)
{
Node*& _root = _pHead->_parent;
Node* pparent = parent->_parent;
Node* subL = parent->_left;
Node* subLR = subL->_right;
parent->_left = subLR;
parent->_parent = subL;
subL->_right = parent;
if (subLR)
{
subLR->_parent = parent;
}
if (_root == parent)
{
_root = subL;
subL->_parent = _pHead;
}
else
{
if (pparent->_left == parent)
{
pparent->_left = subL;
}
else
{
pparent->_right = subL;
}
subL->_parent = pparent;
}
}
// 为了操作树简单起见：获取根节点
Node* GetRoot()
{
return _pHead->_parent;
}
private:
Node* _pHead;
};
小小测试以下
#define _CRT_SECURE_NO_WARNINGS 1
#include"RBTree.h"
void test1()
{
int arr[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };
RBTree<int> rb;
for (auto& e : arr)
{
rb.Insert(e);
}
rb.InOrder();
if (rb.Find(11) != nullptr)
{
cout << "get find" << endl;
}
if (rb.IsValidRBTRee())
{
cout << "is RBTree" << endl;
}
else
{
cout << "is not BRTree" << endl;
}
}
int main()
{
test1();
return 0;
}
343
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
