Beispiel #1
0
 void RBTree :: RBdelete( NodePtr z )
 {
    NodePtr x ;
    NodePtr y = z ;
    char y_original_color = y->color ;
    if(z->left == nil){
     x = z->right;
     RBTransplant(z, z->right);
    }
    else if(z->right == nil){
     x = z->left;
     RBTransplant(z, z->left);
    }
    else{
       y = Tree_minimum(z->right);
       y_original_color = y->color;
       x = y->right;
       if(y->p == z){
         x->p = y;
       }else{
         RBTransplant(y, y->right);
         y->right = z->right;
         y->right->p = y;
       }
       RBTransplant(z,y);
       y->left =  z->left;
       y->left->p = y;
       y->color = z->color;
     }
    if ( y_original_color == 'B' )
        deleteFixup( x ) ;
 }
Beispiel #2
0
void RedBlackTree::RBDelete(RedBlackNode *pNode)
{
    RedBlackNode *pPost = pNode;
    RedBlackNode *pPostOrigin = nullptr;
    NodeColor postOrigColor = pPost->m_nColor;
    if (pNode->m_pLeft == m_pNull)
    {
        pPostOrigin = pNode->m_pRight;
        RBTransplant(pNode, pNode->m_pRight);
    }
    else if (pNode->m_pRight == m_pNull)
    {
        pPostOrigin = pNode->m_pLeft;
        RBTransplant(pNode, pNode->m_pLeft);
    }
    else
    {
        pPost = Mininum(pNode->m_pRight);
        postOrigColor = pPost->m_nColor;
        pPostOrigin = pPost->m_pRight;
        if (pPost->m_pParent == pNode)
        {
            pPostOrigin->m_pParent = pPost;
        }
        else
        {
            RBTransplant(pPost, pPost->m_pRight);
            pPost->m_pRight = pNode->m_pRight;
            pPost->m_pRight->m_pParent = pPost;
        }
        RBTransplant(pNode, pPost);
        pPost->m_pLeft = pNode->m_pLeft;
        pPost->m_pLeft->m_pParent = pPost;
        pPost->m_nColor = pNode->m_nColor;
    }

    if (postOrigColor == black)
    {
        RBDeleteFix(pPostOrigin);
    }
}
Beispiel #3
0
void deleteFromRBTree(Tree *tree, Node *node)
{
	if (node == tree->nil)	return;

	int node_original_color = node->color;
	Node *changeNode = node;

	Node *n = node;
	while (n->parent != tree->nil)
	{
		n = n->parent;
		n->size--;
	}

	if (node->left == tree->nil)
	{
		changeNode = node->right;
		transplant(tree, node, node->right);
	}
	else if (node->right == tree->nil)
	{
		changeNode = node->left;
		transplant(tree, node, node->left);
	}
	else
	{
		Tree t;
		t.root = node->right;
		t.nil = tree->nil;
		Node *min = RBMinimum(&t);
		Node *end = min->right;

		node_original_color = min->color;
		changeNode = end;

		min->size = node->size - 1;
		if (node == tree->root)	tree->root = min;

		if (node->right != min)
		{
			RBTransplant(tree, min, min->right);
			min->right = node->right;
			node->right->parent = min;
		}
		min->left = node->left;
		node->left->parent = min;
		RBTransplant(tree, node, min);

		n = min->right;
		while (n != end)
		{
			n->size--;
			n = n->left;
		}

		min->color = node->color;
	}

	free(node);

	if (node_original_color == BLACK)
	{
		RBDeleteFixup(tree, changeNode);
	}
}