Beispiel #1
0
static
HRESULT RBDelete(std_map* self, std_map_node* z)
{
	std_map_node* y;
	std_map_node* x;
	std_map_node* nil=self->m_pNil;
	std_map_node* root=self->m_pRoot;

	y= ((z->pLeft == nil) || (z->pRight == nil)) ? z : TreeSuccessor(self,z);
	x= (y->pLeft == nil) ? y->pRight : y->pLeft;
	if (root == (x->pParent = y->pParent))
	{ /* assignment of y->p to x->p is intentional */
		root->pLeft=x;
	}
	else
	{
		if (y == y->pParent->pLeft)
		{
			y->pParent->pLeft=x;
		} else {
			y->pParent->pRight=x;
		}
	}
	if (y != z)
	{ /* y should not be nil in this case */

		/* y is the node to splice out and x is its child */

		if (!(y->bRed)) RBDeleteFixUp(self,x);
  
		KeyDtor(self, z->pKey);
		DataDtor(self, z->pData);
		y->pLeft=z->pLeft;
		y->pRight=z->pRight;
		y->pParent=z->pParent;
		y->bRed=z->bRed;
		z->pLeft->pParent=z->pRight->pParent=y;
		if (z == z->pParent->pLeft)
		{
			z->pParent->pLeft=y; 
		}
		else
		{
			z->pParent->pRight=y;
		}
		GaloisFree(z); 
	}
	else
	{
		KeyDtor(self, y->pKey);
		DataDtor(self, y->pData);
		if (!(y->bRed)) RBDeleteFixUp(self,x);
		GaloisFree(y);
	}
	return S_OK;
}
void rb_tree_delete(rb_red_blk_tree* tree, rb_red_blk_node* z){
  rb_red_blk_node* y;
  rb_red_blk_node* x;
  rb_red_blk_node* nil=tree->nil;
  rb_red_blk_node* root=tree->root;

  y= ((z->left == nil) || (z->right == nil)) ? z : rb_tree_successor(tree,z);
  x= (y->left == nil) ? y->right : y->left;
  if (root == (x->parent = y->parent)) { /* assignment of y->p to x->p is intentional */
    root->left=x;
  } else {
    if (y == y->parent->left) {
      y->parent->left=x;
    } else {
      y->parent->right=x;
    }
  }
  if (y != z) { /* y should not be nil in this case */

#ifdef DEBUG_ASSERT
    Assert( (y!=tree->nil),"y is nil in RBDelete\n");
#endif
    /* y is the node to splice out and x is its child */

    if (!(y->red)) RBDeleteFixUp(tree,x);
  
    tree->key_dtor_func(z->key);
    tree->info_dtor_func(z->info);
    y->left=z->left;
    y->right=z->right;
    y->parent=z->parent;
    y->red=z->red;
    z->left->parent=z->right->parent=y;
    if (z == z->parent->left) {
      z->parent->left=y; 
    } else {
      z->parent->right=y;
    }
    free(z); 
  } else {
    tree->key_dtor_func(y->key);
    tree->info_dtor_func(y->info);
    if (!(y->red)) RBDeleteFixUp(tree,x);
    free(y);
  }
  
#ifdef DEBUG_ASSERT
  Assert(!tree->nil->red,"nil not black in RBDelete");
#endif
}
Beispiel #3
0
void RBTree::RBDelete(int key) {
  rb_red_blk_node* y;
  rb_red_blk_node* x;
  rb_red_blk_node* nil=tree->nil;
  rb_red_blk_node* root=tree->root;
  rb_red_blk_node* z = RBExactQuery(key);

  if (!z) {
    return;
  }

  y= ((z->left == nil) || (z->right == nil)) ? z : TreeSuccessor(z);
/* XXX: original code was :   x= (y->left == nil) ? y->right : y->left; */
  x= (y->left  >  nil) ? y->right : y->left;
  if (root == (x->parent = y->parent)) {     root->left=x;
  } else {
    if (y == y->parent->left) {
      y->parent->left=x;
    } else {
      y->parent->right=x;
    }
  }
  if (y != z) { 
    
    if (!(y->red)) RBDeleteFixUp(x);
  
    y->left=z->left;
    y->right=z->right;
    y->parent=z->parent;
    y->red=z->red;
    z->left->parent=z->right->parent=y;
    if (z == z->parent->left) {
      z->parent->left=y; 
    } else {
      z->parent->right=y;
    }
    free(z); 
  } else {
    if (!(y->red)) RBDeleteFixUp(x);
    free(y);
  }
  
}
/*
* This function is used to delete a node z from the tree
* specified by root
*
* @param Root reference to the main tree
* @param z node to delete to the main tree
* @return N/A
*/
void RBDelete(RBTNode **Root, RBTNode *z)
{
	RBTNode *yNode;
	RBTNode *xNode;
	RBTNode *parentNode;
	BOOL leftNode = false;

	//if the node has less than two children, we can use it.
	//otherwise we have to find the successor
	if (z->leftChild == NULL || z->rightChild == NULL)
	{
		yNode = z;
	}
	else
	{
		yNode = Successor(z);
	}

	//if y has a left child, use it
	//otherwise just assign right child even if its NULL
	if (yNode->leftChild != NULL)
	{
		xNode = yNode->leftChild;
	}
	else
	{
		xNode = yNode->rightChild;
	}

	//assign xNode's parent as yNode if not NULL
	if (xNode != NULL)
	{
		xNode->parent = yNode->parent;
	}

	parentNode = yNode->parent;

	//if parent is false, we have the root
	if (yNode->parent == NULL)
	{
		*Root = xNode;
	}
	//if y's parent leftChild, then we have the left child
	//to delete
	else if (yNode == yNode->parent->leftChild)
	{
		yNode->parent->leftChild = xNode;
		leftNode = TRUE;
	}
	else
	{
		yNode->parent->rightChild = xNode;
		leftNode = FALSE;
	}

	//make sure y and z are matching before the call
	//to fixup
	if (yNode != z)
	{
		z->key = yNode->key;
	}

	//if the node we deleted was black, call fix up.
	//for a red node it doesnt matter
	if (yNode->color == BLACK)
	{
		RBDeleteFixUp(Root, xNode, parentNode, leftNode);
	}
}
bool RedBlackTree<T>::Remove(T item) {
    Node<T>* x = NULL;
    Node<T>* y = NULL;
    Node<T>* z = getNodeFromTree(root, item); // The node to be removed (it's value
    //   will be gone, and it is going to be replaced
    //   by the predecessor's value if a predecessor exists
    //   for this node, and the predecessor's node will be
    //   deleted, or delete this node if no predecessor exists).


    if (z == NULL) { // If no such item was found in the tree, then return false.
        return false;
    }


    if (z->left == NULL || z->right == NULL) { // If z has at most one child.
        y = z;
    } else { // z has two children.
        y = Predecessor(z);
    }

    if (y != NULL && y->left != NULL) { // The two conditions below are to
        //   find whether is y's only child
        //   is left or right.
        x = y->left;
    } else {
        if (y != NULL) {
            x = y->right;
        }
    }

    bool xIsLeft = false;
    Node<T>* xParent = NULL;
    if (x != NULL && y != NULL) { // If x is not NULL, detach x from y.
        x->p = y->p;
        xParent = y->p;
    }

    if (y != NULL && y->p == NULL) { // Check if y is root (i.e. it has no parent).
        root = x;
    } else {
        // Attach x to y's parent.
        if (y == y->p->left) { // y is a left child.
            y->p->left = x;
            xIsLeft = true;
        } else { // y is a right child.
            y->p->right = x;
            xIsLeft = false;
        }
    }

    if (y != NULL && z != NULL && y != z) { // Check to see if y has been moved up.
        z->data = y->data;
    }

    if (y != NULL && y->is_black == true) {
        if (x == NULL) {
            if (xParent == NULL) {
                if (root != NULL && root->right != NULL && root->left != NULL && CalculateHeight(root->right) > CalculateHeight(root->left)) {
                    x = root->right;
                    xParent = root;
                    xIsLeft = false;
                } else if (root != NULL && root->right != NULL && root->left != NULL && CalculateHeight(root->left) > CalculateHeight(root->right)) {
                    x = root->left;
                    xParent = root;
                    xIsLeft = true;
                } else if (root != NULL && root->left == NULL) {
                    x = root->right;
                    xParent = root;
                    xIsLeft = false;
                } else if (root != NULL && root->right == NULL) {
                    x = root->left;
                    xParent = root;
                    xIsLeft = true;
                }
            }
        }
        RBDeleteFixUp(x, xParent, xIsLeft);
    }
    delete y; // It can be the original predecessor's node, since its
    //   value has been moved up, or it can be z itself.
    --size; // Decrement the size counter.

    if (root != NULL && root->left != NULL && root->right == NULL) {
        if (root->left->left == NULL && root->left->right == NULL) {
            root->is_black = true;
            root->left->is_black = false;
        }
    } else if (root != NULL && root->right != NULL && root->left == NULL) {
        if (root->right->left == NULL && root->right->right == NULL) {
            root->is_black = true;
            root->right->is_black = false;
        }
    }

    return true;
}
Beispiel #6
0
bool RedBlackTree<T>::Remove(T item) {
	//if item not found return false
	if (Search(item) == false) {
		return false;
	}
	//Find the node z that has the value item 
	Node<T>*z = root;
	while (z != NULL) {
		if (item == z->data) {
			break;
		}
		else if (item < z->data) {
			z = z->left;
		}
		else {
			z = z->right;
		}
	}
	//item has at most one child
	Node<T>* y;
	Node<T>* x;
	if (z->left == NULL || z->right == NULL) {
		y = z;
	}
	else {
		y = Predecessor(z);
	}
	if (y->left != NULL) {
		x = y->left;
	}
	else {
		x = y->right;
	}
	//x->p = y->p; cant do this because x could be NULL
	//check if y is root, replace it by x
	if (y->p == NULL) {
		root = x;
	}
	else {
		if (y == y->p->left) {
			y->p->left = x;
		}
		else {
			y->p->right = x;
		}
		//need to check x is not null ptr
		if (x != NULL) {
			x->p = y->p;
		}
	}
	if (y != z) {
		z->data = y->data;
	}
	if (y->is_black == true) {

		if (x == y->p->left) {
			RBDeleteFixUp(x, y->p, true);
		}
		//x is rightchold
		else {
			RBDeleteFixUp(x, y->p, false);
		}
	}
	delete y;
	size--;
	return true;
}