コード例 #1
0
ファイル: interval_tree.cpp プロジェクト: dalibor-matura/mcl
SimpleInterval* IntervalTree::deleteNode(IntervalTreeNode* z)
{
  IntervalTreeNode* y;
  IntervalTreeNode* x;
  SimpleInterval* node_to_delete = z->stored_interval;

  y= ((z->left == nil) || (z->right == nil)) ? z : getSuccessor(z);
  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;
    }
  }

  /// @brief y should not be nil in this case
  /// y is the node to splice out and x is its child
  if(y != z)
  {
    y->max_high = -std::numeric_limits<double>::max();
    y->left = z->left;
    y->right = z->right;
    y->parent = z->parent;
    z->left->parent = z->right->parent = y;
    if(z == z->parent->left)
      z->parent->left = y;
    else
      z->parent->right = y;

    fixupMaxHigh(x->parent);
    if(!(y->red))
    {
      y->red = z->red;
      deleteFixup(x);
    }
    else
      y->red = z->red;
    delete z;
  }
  else
  {
    fixupMaxHigh(x->parent);
    if(!(y->red)) deleteFixup(x);
    delete y;
  }

  return node_to_delete;
}
コード例 #2
0
ファイル: rbTree.cpp プロジェクト: Sandarmann/Programming
 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 ) ;
 }
コード例 #3
0
ファイル: red_black_tree.c プロジェクト: 529038378/BLASX
void rbt_delete(rbt_node *z, rbt_node **root) {
    rbt_node *x, *y;

   /*****************************
    *  delete node z from tree  *
    *****************************/

    if (!z || z == NIL) return;


    if (z->left == NIL || z->right == NIL) {
        /* y has a NIL node as a child */
        y = z;
    } else {
        /* find tree successor with a NIL node as a child */
        y = z->right;
        while (y->left != NIL) y = y->left;
    }

    /* x is y's only child */
    if (y->left != NIL)
        x = y->left;
    else
        x = y->right;

    /* remove y from the parent chain */
    x->parent = y->parent;
    if (y->parent)
        if (y == y->parent->left)
            y->parent->left = x;
        else
            y->parent->right = x;
    else
    {
        *root = x;
    }

    if (y != z) {
        z->key = y->key;
        //CHANGE
        z->associated_LRU_elem = y->associated_LRU_elem;
    }


    if (y->color == BLACK)
        deleteFixup (x, root);
    
    y->key = NULL;
    y->associated_LRU_elem = NULL;
    y->left = NULL;
    y->right = NULL;
    y->parent = NULL;
    free (y);
}
コード例 #4
0
ファイル: RBTree.c プロジェクト: bashell/alg_and_ds
void deleteRBNode(ppRBNode root, int val) {
    // If z is the node to be deleted, then the original color of z's successor is: original_color
    char original_color;  

    // 1. Perform standard binary-search-tree deletion
    pRBNode x = BSTdelete(*root, val, &original_color);
    if(x == NULL)
        return ;

    // 2. Fix the RB-tree if necessary
    if(original_color == 'B')
        deleteFixup(root, x);
}
コード例 #5
0
ファイル: rbtree.cpp プロジェクト: prophile/crisscross
		bool RedBlackTree<Key, Data>::killNode(RedBlackNode<Key, Data> * z)
		{
			RedBlackNode<Key, Data> *x, *y;

			if (!valid(z->left) || !valid(z->right)) {
				/* y has a null node as a child */
				y = z;
			} else {
				/* find tree successor with a null node as a child */
				y = z->right;

				while (valid(y->left))
					y = y->left;
			}

			/* x is y's only child */
			if (valid(y->left))
				x = y->left;
			else
				x = y->right;

			/* remove y from the parent chain */
			if (valid(x)) x->parent = y->parent;

			if (valid(y->parent)) {
				if (y == y->parent->left)
					y->parent->left = x;
				else
					y->parent->right = x;
			} else
				rootNode = x;

			if (y != z) {
				Dealloc(z->id);
				z->id = Duplicate(y->id);
				z->data = y->data;
			} else {
				Dealloc(y->id);
			}

			if (y->color == BLACK)
				deleteFixup(x);

			m_cachedSize--;

			y->left = NULL;
			y->right = NULL;
			delete y;

			return true;
		}
コード例 #6
0
ファイル: rbtree.c プロジェクト: nask0/calipso
// delete node
RbtStatus rbtErase(RBTreeType *tree, NodeType * z) 
{
	NodeType **root = &tree->root;
    NodeType *x, *y;

    if (z->left == SENTINEL || z->right == SENTINEL) {
        // y has a SENTINEL node as a child
        y = z;
    } else {
        // find tree successor with a SENTINEL node as a child
        y = z->right;
        while (y->left != SENTINEL) y = y->left;
    }

    // x is y's only child
    if (y->left != SENTINEL)
        x = y->left;
    else
        x = y->right;

    // remove y from the parent chain
    x->parent = y->parent;
    if (y->parent)
        if (y == y->parent->left)
            y->parent->left = x;
        else
            y->parent->right = x;
    else
        *root = x;

    if (y != z) {
        z->key = y->key;
        z->val = y->val;
    }


    if (y->color == BLACK)
        deleteFixup (root, x, SENTINEL);

    free (y);

    return RBT_STATUS_OK;
}
コード例 #7
0
void deleteNode(Node *z) {
    Node *x, *y;

   /*****************************
    *  delete node z from tree  *
    *****************************/

    if (!z || z == NIL) return;


    if (z->left == NIL || z->right == NIL) {
        /* y has a NIL node as a child */
        y = z;
    } else {
        /* find tree successor with a NIL node as a child */
        y = z->right;
        while (y->left != NIL) y = y->left;
    }

    /* x is y's only child */
    if (y->left != NIL)
        x = y->left;
    else
        x = y->right;

    /* remove y from the parent chain */
    x->parent = y->parent;
    if (y->parent)
        if (y == y->parent->left)
            y->parent->left = x;
        else
            y->parent->right = x;
    else
        root = x;

    if (y != z) z->data = y->data;


    if (y->color == BLACK)
        deleteFixup (x);

    free (y);
}
コード例 #8
0
RbtStatus rbtErase(RbtHandle h, RbtIterator i) {
    NodeType *x, *y;
    RbtType *rbt = h;
    NodeType *z = i;

    if (z->left == SENTINEL || z->right == SENTINEL) {
        /* y has a SENTINEL node as a child */
        y = z;
    } else {
        /* find tree successor with a SENTINEL node as a child */
        y = z->right;
        while (y->left != SENTINEL) y = y->left;
    }

    /* x is y's only child */
    if (y->left != SENTINEL)
        x = y->left;
    else
        x = y->right;

    /* remove y from the parent chain */
    x->parent = y->parent;
    if (y->parent)
        if (y == y->parent->left)
            y->parent->left = x;
        else
            y->parent->right = x;
    else
        rbt->root = x;

    if (y != z) {
        z->key = y->key;
        z->val = y->val;
    }


    if (y->color == BLACK)
        deleteFixup (rbt, x);

    xfree(y);

    return RBT_STATUS_OK;
}
コード例 #9
0
ファイル: red-black-tree.c プロジェクト: polo070770/SO2
void deleteNode(RBTree *tree, Node *z) {
  Node *x, *y;

  if (!z || z == NIL) return;


  if (z->left == NIL || z->right == NIL) {
    /* y has a NIL node as a child */
    y = z;
  } else {
    /* find tree successor with a NIL node as a child */
    y = z->right;
    while (y->left != NIL) y = y->left;
  }

  /* x is y's only child */
  if (y->left != NIL)
    x = y->left;
  else
    x = y->right;

  /* remove y from the parent chain */
  x->parent = y->parent;
  if (y->parent)
    if (y == y->parent->left)
      y->parent->left = x;
    else
      y->parent->right = x;
  else
    tree->root = x;

  /* free data pointed to by the node */
  freeRBdata(z->data);

  if (y != z) 
    z->data = y->data; 

  if (y->color == BLACK)
    deleteFixup (tree, x);

  free(y);
}
コード例 #10
0
ファイル: RedBlackTree.cpp プロジェクト: cfanchk/Code
//红黑树删除操作
void RBTree::TreeDelete(int key)
{
	Node* z = &TreeSearch(key);
	Node* y = z;
	Node* x;
	bool y_original_colour = y->getColour();

	if (z->getLeft() == NIL)
	{
		x = z->getRight();
		transplant(z, z->getRight());
	}
	else if (z->getRight() == NIL)
	{
		x = z->getLeft();
		transplant(z, z->getLeft());
	}
	else
	{
		y = &(TreeMinimum(z->getRight(), 0));
		y_original_colour = y->getColour();
		x = y->getRight();
		if (y->getParent() == z)
			x->setParent(y);
		else
		{
			transplant(y, y->getRight());
			y->setRight(z->getRight());
			y->getRight()->setParent(y);
		}
		transplant(z, y);
		y->setLeft(z->getLeft());
		y->getLeft()->setParent(y);
		y->setColour(z->getColour());
	}
	if (y_original_colour == BLACK)
		deleteFixup(x);
	delete z;
}
コード例 #11
0
ファイル: srbt.c プロジェクト: Dmdv/olymp-docs
//-----------------------------------------------------------------------------
/// detach node from tree
/// \param[in] z -- the node to detach
/// \param[in] p_root - the root of the tree
//-----------------------------------------------------------------------------
void detachNode(Node *z, Node**p_root)
{
    Node *x, *y, *x_par;
    int f;

    if(!*p_root)return;

    if (!z || z == NIL) return;

    if (z->left == NIL || z->right == NIL) {
        /* y has a NIL node as a child */
        y = z;
    } else {
        /* find tree successor with a NIL node as a child */
        y = z->right;
        while (y->left != NIL) y = y->left;
    }

    /* x is y's only child */
    if (y->left != NIL)
        x = y->left;
    else
        x = y->right;

    /* remove y from the parent chain */
    x_par = y->parent;
    if(x!=NIL) x->parent = x_par;
        
    if (y->parent)
        if (y == y->parent->left)
            y->parent->left = x;
        else
            y->parent->right = x;
    else
        *p_root = x;

    f = (y->color == BLACK);
    
    if (y != z)
    {   /* replace z with y */ 
        y->color = z->color ;
        y->left = z->left;
        y->right = z->right;
        y->parent = z->parent;

        if (y->parent)
            if (z == y->parent->left)
                y->parent->left = y;
            else
                y->parent->right = y;
        else
            *p_root = y;

        if(y->left != NIL)
            y->left->parent = y;

        if(y->right != NIL)
            y->right->parent = y;

        if(x_par==z) x_par=y;
    }

    if(f)
        deleteFixup (x, x_par, p_root);

}
コード例 #12
0
ファイル: nl-symbol.c プロジェクト: baisoo/kitphone
int deleteSymbol(char * key)
{
SYMBOL *x, *y, *z;
int color, c;

/* find node in tree */
z = (root == NULL) ? NIL_SYM : root;

while(z != NIL_SYM)
	{
	if( ((c = str2cmp(key, z->name)) == 0) && ((c = strcmp(key, z->name)) == 0) )
		break;
	else
		z = (c < 0) ? z->left : z->right;
	}

if (z == NIL_SYM) return(0); /* key to delete not found */


if (z->left == NIL_SYM || z->right == NIL_SYM)
	{
	/* y has a NIL_SYM node as a child */
	y = z;
	}
else 
	{
	/* find tree successor with a NIL_SYM node as a child */
	y = z->right;
	while (y->left != NIL_SYM) y = y->left;
	}

/* x is y's only child */
if (y->left != NIL_SYM)
	x = y->left;
else
	x = y->right;

/* remove y from the parent chain */
x->parent = y->parent;
if (y->parent)
	{
	if (y == y->parent->left)
		y->parent->left = x;
        else
            y->parent->right = x;
	}
else
	root = x;


color = y->color;
if (y != z)
	{
	/* swap y and z */
	y->left = z->left;
	y->right = z->right;
	y->parent = z->parent;

	if(z->parent)
		{
		if(z->parent->left == z)
			z->parent->left = y;
		else
			z->parent->right = y;
		}
	else root = y;

	y->right->parent = y;
	y->left->parent = y;

	y->color = z->color;
	}

if (color == BLACK)
	deleteFixup (x);

--symbolCount;
return TRUE;
}