我宁愿犯错,也不愿什么都不做。时间,不在于你拥有多少,而在于你怎样使用。——艾克
红黑树是一种二叉搜索树,说到二叉搜索树我们知道普通的二叉搜索树呢有可能会遇到特殊情况从而导致查找的时间复杂度变成O(N)因此呢很多大佬想了想了很多解决的办法之前我们学的AVL树以及现在的红黑树都是解决的办法,那么不同于avl树那么严格的标准,红黑树只要求最高的路线小于最小路径的2倍,红黑树通过一些条件的约束从而做到了这点从而接近于平衡,红黑树的节点颜色只有两个红和黑。
- 每个节点不是红色就是黑色
- 最长路径不能超过最短路径的2倍
- 根节点一定是黑色
- 红色节点的孩子一定是黑色节点(也可以理解成不能出现连续的红色节点)
- 每个叶子节点都是黑色的(此处的叶子节点指的是空节点)
- 每条路径的黑色节点数目相同。
那么给大家看一颗红黑树的图片吧
那么为什么满足上面的性质红黑树就可以做到最长路径不超过最短路径的二倍呢?
这里给大家讲解一下。
首先我们通过上面的性质我们可以知道,每条路径上的黑色节点数目相同,那么在相同黑色节点的情况下,最短的一定是全部都是黑色节点的路径,最长路径一定是红色和黑色节点交叉的树,那么红色节点和黑色节点交叉的这个路径中,红色节点的数目一定等于黑色节点的数目,那么最长路径和最短路径的黑色节点数目又相同说明最长路径最多也就是最短路径的二倍。
这里呢我们可以思考一个问题就是红黑树在插入新节点的时候默认的颜色应该是什么?、
其实呢红色和黑色都是可以的因为我们到最后可以通过像avl树那样旋转调整,那么红色和黑色哪个好一些呢?这里请同学门思考一下红黑树的条件中哪两个条件比较重要呢?
当然是第一每条路径的黑色节点数目相同 第二红色节点的孩子一定是黑色节点
那么假如说我们新插入的节点是黑色节点的话,那么不管怎么插入都势必会导致每条路径的黑色节点数目不相同了,因此极有可能我们插入一次就要调整一次,那这样的话无论是效率还是代价都太大了因此我们选择先默认节点颜色为红色。
那么如何定义呢?代码如下
enum colour {//节点颜色
RED,
BLACK
};
template<typename K,typename V>
struct RB_Node //节点所包含的元素
{
pair<K, V>_kv;
RB_Node<K, V>* _left;
RB_Node<K, V>* _right;
RB_Node<K, V>* _parent;
colour col = RED;
RB_Node(const pair<K,V>& kv)
:_left(nullptr)
,_right(nullptr)
,_parent(nullptr)
,_kv(kv)
,col(RED)
{
;
}
};
为了后续实现关联式容器简单,红黑树的实现中增加一个头结点,因为跟节点必须为黑色,为了
与根节点进行区分,将头结点给成黑色,并且让头结点的 pParent 域指向红黑树的根节点,pLeft
域指向红黑树中最小的节点,_pRight域指向红黑树中最大的节点,如下:
红黑树是在二叉搜索树的基础上加上其平衡限制条件,因此红黑树的插入可分为两步:
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 (kv.first > parent->_kv.first)
{
parent->_right = cur;
}
else
{
parent->_left=cur;
}
cur->_parent = parent;
while (parent && parent->col == RED)
{
Node* grandfather = parent->_parent;
if (parent == grandfather->_left)
{
Node*uncle = grandfather->_right;
if (uncle&&uncle->col==RED)
{
uncle->col = parent->col = BLACK;
grandfather->col = RED;
cur = grandfather;
parent = cur->_parent;
}
else
{
if (cur == parent->_left)
{
// g
// p
// c
RotateR(grandfather);//右单旋
grandfather->col = RED;
parent->col = BLACK;
}
else
{
// g
// p
// c
RotateL(parent);//左单旋
RotateR(grandfather);//右单旋
cur->col = BLACK;
grandfather->col = RED;
}
break;
}
}
else
{
Node* uncle = grandfather->_left;
if (uncle&&uncle->col==RED)
{
// g
// u p
// c
uncle->col = parent->col = BLACK;
grandfather->col = RED;
cur = grandfather;
parent = cur->_parent;
}
else
{
if (cur == parent->_left)
{
// g
// p
// c
RotateR(parent);//右单旋
RotateL(grandfather);//左单旋
grandfather->col = RED;
cur->col = BLACK;
}
else
{
// g
// p
// c
RotateL(grandfather);//左单旋
parent->col = BLACK;
grandfather->col = RED;
}
break;
}
}
}
_root->col = BLACK;
return true;
}
这里呢我们插入时需要不断的进行判断其是否违背了红黑树的性质,并对其进行不断的调整。其中这里面有一下几种情况。我给大家做了一个思维导图(cur是新插入节点grandfather是父亲的父亲,uncle是父亲的兄弟节点)
那么这里面中的有uncle且为黑色以及无uncle的情况我们都需要进行翻转
左单选的情况是哪种呢?其实就像我代码中的注释那样子这里呢给大家画一张图
可能会有人有疑问为什么不是下面这张图因为uncle如果存在且为黑色的话那么这颗树在还没有插入新节点前就不是一个红黑树。
这里呢左单选后变成了什么呢如下图
就变成了这样子。
那么右单选跟这个类似我们在avl树中讲过了旋转如果想了解的详细些可以看一下这篇文章avl树
红黑树通过各种条件的互斥从而达到了近似平衡的状态,和avl树的严格不同红黑树稍微轻松些,红黑树和AVL树都是高效的平衡二叉树,增删改查的时间复杂度都是O( l o g 2 N log_2 N log2N),红黑树不追求绝对平衡,其只需保证最长路径不超过最短路径的2倍,相对而言,降低了插入和旋转的次数,所以在经常进行增删的结构中性能比AVL树更优,而且红黑树实现比较简单,所以实际运用中红黑树更多。
#pragma once
#include
using namespace std;
namespace clzyf {
enum colour {
RED,
BLACK
};
template<typename K,typename V>
struct RB_Node
{
pair<K, V>_kv;
RB_Node<K, V>* _left;
RB_Node<K, V>* _right;
RB_Node<K, V>* _parent;
colour col = RED;
RB_Node(const pair<K,V>& kv)
:_left(nullptr)
,_right(nullptr)
,_parent(nullptr)
,_kv(kv)
,col(RED)
{
;
}
};
template<class K,class V>
class RBtree
{
typedef RB_Node<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;
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 (kv.first > parent->_kv.first)
{
parent->_right = cur;
}
else
{
parent->_left=cur;
}
cur->_parent = parent;
while (parent && parent->col == RED)
{
Node* grandfather = parent->_parent;
if (parent == grandfather->_left)
{
Node*uncle = grandfather->_right;
if (uncle&&uncle->col==RED)
{
uncle->col = parent->col = BLACK;
grandfather->col = RED;
cur = grandfather;
parent = cur->_parent;
}
else
{
if (cur == parent->_left)
{
// g
// p
// c
RotateR(grandfather);//右单旋
grandfather->col = RED;
parent->col = BLACK;
}
else
{
// g
// p
// c
RotateL(parent);//左单旋
RotateR(grandfather);//右单旋
cur->col = BLACK;
grandfather->col = RED;
}
break;
}
}
else
{
Node* uncle = grandfather->_left;
if (uncle&&uncle->col==RED)
{
// g
// u p
// c
uncle->col = parent->col = BLACK;
grandfather->col = RED;
cur = grandfather;
parent = cur->_parent;
}
else
{
if (cur == parent->_left)
{
// g
// p
// c
RotateR(parent);//右单旋
RotateL(grandfather);//左单旋
grandfather->col = RED;
cur->col = BLACK;
}
else
{
// g
// p
// c
RotateL(grandfather);//左单旋
parent->col = BLACK;
grandfather->col = RED;
}
break;
}
}
}
_root->col = BLACK;
return true;
}
void RotateL(Node* parent)
{
++_rotateCount;
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 = 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)
{
++_rotateCount;
Node* cur = parent->_left;
Node* curright = cur->_right;
parent->_left = curright;
if (curright)
curright->_parent = parent;
Node* ppnode = parent->_parent;
cur->_right = parent;
parent->_parent = cur;
if (ppnode == nullptr)
{
_root = cur;
cur->_parent = nullptr;
}
else
{
if (ppnode->_left == parent)
{
ppnode->_left = cur;
}
else
{
ppnode->_right = cur;
}
cur->_parent = ppnode;
}
}
// 17:20继续
bool CheckColour(Node* root, int blacknum, int benchmark)
{
if (root == nullptr)
{
if (blacknum != benchmark)
return false;
return true;
}
if (root->col == BLACK)
{
++blacknum;
}
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);
}
int Height()
{
return Height(_root);
}
int Height(Node* root)
{
if (root == nullptr)
return 0;
int leftHeight = Height(root->_left);
int rightHeight = Height(root->_right);
return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
}
private:
Node* _root = nullptr;
public:
int _rotateCount = 0;
};
}
#include
#include
#include"RBtree.h"
using namespace std;
int main()
{
srand(time(0));
vector<int>qu;
for (int i = 0; i < 10000000; i++)
{
int t = rand();
qu.push_back(t);
}
clzyf::RBtree<int, int>rbt;
for (auto c : qu)
{
rbt.insert(make_pair(c,c));
}
rbt.IsBalance();
return 0;
}