/******************************************************************************
**函数名称: rbt_delete_fixup
**功 能: 修复删除操作造成的黑红树性质的破坏(内部接口)
**输入参数:
** tree: 红黑树
** node: 实际被删结点的替代结点(注: node有可能是叶子结点)
**输出参数: NONE
**返 回: RBT_OK:成功 RBT_ERR:失败
**实现描述:
**注意事项: 被删结点为黑色结点，才能调用此函数进行性质调整
**作 者: # Qifeng.zou # 2013.12.28 #
******************************************************************************/
static int rbt_delete_fixup(rbt_tree_t *tree, rbt_node_t *node)
{
rbt_node_t *parent = NULL, *brother = NULL;
while (rbt_is_black(node) && (tree->root != node)) {
/* Set parent and brother */
parent = node->parent;
if (node == parent->lchild) {
brother = parent->rchild;
/* Case 1: 兄弟结点为红色: 以parent为支点, 左旋处理 */
if (rbt_is_red(brother)) {
rbt_set_red(parent);
rbt_set_black(brother);
rbt_left_rotate(tree, parent);
/* 参照结点node不变, 兄弟结点改为parent->rchild */
brother = parent->rchild;
/* 注意: 此时处理还没有结束，还需要做后续的调整处理 */
}
/* Case 2: 兄弟结点为黑色(默认), 且兄弟结点的2个子结点都为黑色 */
if (rbt_is_black(brother->lchild) && rbt_is_black(brother->rchild)) {
rbt_set_red(brother);
node = parent;
}
else {
/* Case 3: 兄弟结点为黑色(默认),
兄弟节点的左子结点为红色, 右子结点为黑色: 以brother为支点, 右旋处理 */
if (rbt_is_black(brother->rchild)) {
rbt_set_black(brother->lchild);
rbt_set_red(brother);
rbt_right_rotate(tree, brother);
/* 参照结点node不变 */
brother = parent->rchild;
}
/* Case 4: 兄弟结点为黑色(默认),
兄弟结点右孩子结点为红色: 以parent为支点, 左旋处理 */
rbt_copy_color(brother, parent);
rbt_set_black(brother->rchild);
rbt_set_black(parent);
rbt_left_rotate(tree, parent);
node = tree->root;
}
}
else
{
brother = parent->lchild;
/* Case 5: 兄弟结点为红色: 以parent为支点, 右旋处理 */
if (rbt_is_red(brother)) {
rbt_set_red(parent);
rbt_set_black(brother);
rbt_right_rotate(tree, parent);
/* 参照结点node不变 */
brother = parent->lchild;
/* 注意: 此时处理还没有结束，还需要做后续的调整处理 */
}
/* Case 6: 兄弟结点为黑色(默认), 且兄弟结点的2个子结点都为黑色 */
if (rbt_is_black(brother->lchild) && rbt_is_black(brother->rchild)) {
rbt_set_red(brother);
node = parent;
}
else {
/* Case 7: 兄弟结点为黑色(默认),
兄弟节点的右子结点为红色, 左子结点为黑色: 以brother为支点, 左旋处理 */
if (rbt_is_black(brother->lchild)) {
rbt_set_red(brother);
rbt_set_black(brother->rchild);
rbt_left_rotate(tree, brother);
/* 参照结点node不变 */
brother = parent->lchild;
}
/* Case 8: 兄弟结点为黑色(默认),
兄弟结点左孩子结点为红色: 以parent为支点, 右旋处理 */
rbt_copy_color(brother, parent);
rbt_set_black(brother->lchild);
rbt_set_black(parent);
rbt_right_rotate(tree, parent);
node = tree->root;
}
}
}
rbt_set_black(node);
rbt_assert(tree, node);
rbt_assert(tree, brother);
rbt_assert(tree, parent);
return RBT_OK;
}
void
rbtree_delete( rbtree_t *tree , rbtree_node_t *node )
{
uint_t red;
rbtree_node_t **root,*sentinel,*subst,*temp,*w;
/* a binary tree delete */
root = (rbtree_node_t **) &tree->root;
sentinel = tree->sentinel;
if (node->left == sentinel)
{
temp = node->right;
subst = node;
}
else if (node->right == sentinel)
{
temp = node->left;
subst = node;
}
else
{
subst = rbtree_min( node->right , sentinel );
if (subst->left != sentinel)
{
temp = subst->left;
}
else
{
temp = subst->right;
}
}
if (subst == *root)
{
*root = temp;
rbt_black( temp );
/* DEBUG stuff */
node->left = NULL;
node->right = NULL;
node->parent = NULL;
node->key = 0;
return;
}
red = rbt_is_red(subst);
if (subst == subst->parent->left)
{
subst->parent->left = temp;
}
else
{
subst->parent->right = temp;
}
if (subst == node)
{
temp->parent = subst->parent;
}
else
{
if (subst->parent == node)
{
temp->parent = subst;
}
else
{
temp->parent = subst->parent;
}
subst->left = node->left;
subst->right = node->right;
subst->parent = node->parent;
rbt_copy_color( subst , node );
if (node == *root)
{
*root = subst;
}
else
{
if (node == node->parent->left)
{
node->parent->left = subst;
}
else
{
node->parent->right = subst;
}
}
if (subst->left != sentinel)
{
subst->left->parent = subst;
}
if (subst->right != sentinel)
{
subst->right->parent = subst;
}
}
/* DEBUG stuff */
node->left = NULL;
node->right = NULL;
node->parent = NULL;
node->key = 0;
if (red)
{
return;
}
/* a delete fixup */
while (temp != *root && rbt_is_black(temp) )
{
if (temp == temp->parent->left)
{
w = temp->parent->right;
if (rbt_is_red(w) )
{
rbt_black( w );
rbt_red( temp->parent );
rbtree_left_rotate( root , sentinel , temp->parent );
w = temp->parent->right;
}
if (rbt_is_black(w->left) && rbt_is_black(w->right) )
{
rbt_red( w );
temp = temp->parent;
}
else
{
if (rbt_is_black(w->right) )
{
rbt_black( w->left );
rbt_red( w );
rbtree_right_rotate( root , sentinel , w );
w = temp->parent->right;
}
rbt_copy_color( w , temp->parent );
rbt_black( temp->parent );
rbt_black( w->right );
rbtree_left_rotate( root , sentinel , temp->parent );
temp = *root;
}
}
else
{
w = temp->parent->left;
if (rbt_is_red(w) )
{
rbt_black( w );
rbt_red( temp->parent );
rbtree_right_rotate( root , sentinel , temp->parent );
w = temp->parent->left;
}
if (rbt_is_black(w->left) && rbt_is_black(w->right) )
{
rbt_red( w );
temp = temp->parent;
}
else
{
if (rbt_is_black(w->left) )
{
rbt_black( w->right );
rbt_red( w );
rbtree_left_rotate( root , sentinel , w );
w = temp->parent->left;
}
rbt_copy_color( w , temp->parent );
rbt_black( temp->parent );
rbt_black( w->left );
rbtree_right_rotate( root , sentinel , temp->parent );
temp = *root;
}
}
}
rbt_black( temp );
}
/******************************************************************************
**函数名称: rbt_insert_fixup
**功 能: 插入操作修复(内部接口)
**输入参数:
** tree: 红黑树
** node: 新增节点的地址
**输出参数: NONE
**返 回: RBT_OK:成功 RBT_ERR:失败
**实现描述:
** 1. 检查红黑树性质是否被破坏
** 2. 如果被破坏，则进行对应的处理
**注意事项: 插入节点操作只可能破坏性质④
**作 者: # Qifeng.zou # 2013.12.23 #
******************************************************************************/
static int rbt_insert_fixup(rbt_tree_t *tree, rbt_node_t *node)
{
rbt_node_t *parent = NULL, *uncle = NULL, *grandpa = NULL, *gparent = NULL;
while (rbt_is_red(node)) {
parent = node->parent;
if (rbt_is_black(parent)) {
return RBT_OK;
}
grandpa = parent->parent;
if (parent == grandpa->lchild) { /* 父节点为左节点 */
uncle = grandpa->rchild;
/* case 1: 父节点和叔节点为红色 */
if (rbt_is_red(uncle)) {
rbt_set_black(parent);
rbt_set_black(uncle);
if (grandpa != tree->root) {
rbt_set_red(grandpa);
}
node = grandpa;
continue;
}
/* case 2: 叔结点为黑色，结点为左孩子 */
else if (node == parent->lchild) {
/* 右旋转: 以grandpa为支点 */
gparent = grandpa->parent;
rbt_set_red(grandpa);
rbt_set_black(parent);
rbt_right_rotate(tree, grandpa);
node = gparent;
continue;
}
/* case 3: 叔结点为黑色，结点为右孩子 */
else
{
/* 左旋转: 以parent为支点 */
rbt_left_rotate(tree, parent);
node = parent;
continue;
}
}
else /* 父节点为右孩子 */
{
uncle = grandpa->lchild;
/* case 1: 父节点和叔节点为红色 */
if (rbt_is_red(uncle)) {
rbt_set_black(parent);
rbt_set_black(uncle);
if (grandpa != tree->root) {
rbt_set_red(grandpa);
}
node = grandpa;
continue;
}
/* case 2: 叔结点为黑色，结点为左孩子 */
else if (node == parent->lchild) {
/* 右旋转: 以parent为支点 */
rbt_right_rotate(tree, parent);
node = parent;
continue;
}
/* case 3: 叔结点为黑色，结点为右孩子 */
else {
/* 左旋转: 以grandpa为支点 */
gparent = grandpa->parent;
rbt_set_black(parent);
rbt_set_red(grandpa);
rbt_left_rotate(tree, grandpa);
node = gparent;
continue;
}
}
}
return RBT_OK;
}
