图2(RBTree左右双旋):
代码:
bool Insert(const K& key, const V& value)
{
if (_root == NULL)//如果根为空,创建一个根节点,把要插入的key给他,颜色置黑
{
_root = new Node(key, value);
_root->_col = BLACK;
return true;
}
Node* parent = NULL;//定义 parent为空
Node* cur = _root;
while (cur)
{
if (cur->_key > key)//插到左边
{
parent = cur;
cur = cur->_left;
}
else if (cur->_key < key)
{
parent = cur;
cur = cur->_right;
}
else
{
return false;
}
}
cur = new Node*(key, value);
if (parent->_key < key)
{
parent->_right = cur;
cur->_parent = parent;
}
else
{
parent->_left = cur;
cur->_parent = parent;
}
return true;
//检查
//1、p为黑
//2、p为红,u为红
//3、p为红,u不存在,或者为黑
while (parent->_col == RED)//parent的颜色为黑就截止了
{
Node* grandfa = parent->_parent;
if (parent == grandfa->_left)
{
Node* uncle = grandfa->_right;
if (uncle && uncle->_col == RED)
{
parent->_col = uncle->_col = BLACK;
grandfa->_col = RED;
//继续向上调整
cur = grandfa;
parent = cur->_parent;
}
else//叔叔不存在或叔叔为黑
{
if (cur == parent->_right)
{
RotateL(parent);
}
RotateR(grandfa);
parent->_col = BLACK;
grandfa->_col = RED;
}
}
else//parent==grandfa->_right
{
Node* uncle = grandfa->_left;
if (uncle && uncle->_col == RED)
{
parent->_col = uncle->_col = BLACK;
grandfa->_col = RED;
cur = grandfa;
parent = cur->_parent;
}
else
{
if (cur == parent->_left)
{
RotateR(parent);
}
RotateL(grandfa);
parent->_col = BLACK;
grandfa->_col = RED;
}
}
}
_root->_col = BLACK;
return true;
}
void RotateR(Node* parent)
{
Node* subL = parnet->_left;
Node* subLR = subL->_right;
parent->_left = subLR;
if (subLR)
{
subLR->_parent = parent;
}
subL->_right = parent;
Node* ppNode = parent->_parent;
parent->_parent = subL;
if (ppNode == NULL)
{
_root = subL;
}
else
{
if (ppNode->_left == parent)
{
ppNode->_left = subL;
}
else
{
ppNode->_right = subL;
}
subL->_parent = ppNode;
}
_root->_parent = NULL;
}
void RotateL(Node* parent)//左单旋
{
Node* subR = parent->_right;
Node* subRL = subR->_left;//先定义两节点
parent->_right = subRL;//parent的右指向subRL
if (subRL)//subRL可能不会存在,也可能存在
{
subRL->_parent = parent;
}
subR->_left = parent;//subR的左指向parent
subR->_parent = parent->_parent;//subR的父亲就是parent的父亲了
Node* ppNode = parent->_parent;//定义ppNode节点为parent的父亲节点
parent->_parent = subR;//parent的父亲节点也就是subR
if (ppNode == NULL)//如果ppNode为空,
{
_root = subR;
subR->_parent = NULL;
}
else if (ppNode->_left == parent)
{
ppNode->_left = subR;
}
else
{
ppNode->_right = subR;
}
subR->_parent = ppNode;
}
void InOrder()
{
_InOrder(_root);
cout << endl;
}
void _InOrder(Node* root)
{
if (root == NULL)
return;
_InOrder(root->_left);
cout << root->_key << " ";
_InOrder(root->_right);
}
bool IsBalance()//类似计算huffmannode,走一个加1
{
//检查
//1、根节点黑的
//2、每条路径上都有相同数量的黑节点,遇到黑节点加1,递归走每条路径
//3、需要一个数值来记录“从根节点到当前节点的黑节点的数量”
if (_root&&_root->_col == RED)
{
return false;
}
//如果是黑就继续走
int k = 0;
Node* cur = _root;
while (cur)
{
if (cur->_col == BLACK)
{
++k;
}
cur = cur->_left;
}
int blacknum = 0;
return _IsBalance(_root,k,blacknum);
}
bool _IsBalance(Node* cur,const int k,int blacknum)
{
if (cur == NULL)
{
if (k != blacknum)
{
cout << "黑节点的数量不相等" << endl;
return false;
}
return true;//空树不违反规则
}
if (cur->_col == RED && cur->_parent->_col == RED)//连续红节点
{
cout << "存在连续的红节点" << cur->_key << endl;
return false;
}
if (cur->_col == BLACK)
{
++blacknum;
}
return _IsBalance(cur->_left, k,blacknum)
&&_IsBalance(cur_ > _right, k, blacknum);
}