Beispiel #1
0
rbtree_node_t *rbtree_insert(rbtree_t *tree, rbtree_key_t key)
{
  rbtree_node_t *node, *parent;
  node = tree->root;
  parent = tree->sentinel;
  while (node != tree->sentinel) {
    parent = node;
    if (key <= node->key)
      node = node->left;
    else
      node = node->right;
  }

  node = rbtree_node_create(key, tree->sentinel);
  if (node) {
    node->parent = parent;
    if (parent == tree->sentinel)
      tree->root = node;
    else if (node->key <= parent->key)
      parent->left = node;
    else
      parent->right = node;

    rbtree_set_red(node);
    rbtree_insert_fixup(tree, node);
  }

  return node;
}
Beispiel #2
0
/*
 * 添加节点:将节点(node)插入到红黑树中
 *
 * 参数说明:
 *     root 红黑树的根
 *     node 插入的结点        // 对应《算法导论》中的z
 */
static void rbtree_insert(RBRoot *root, Node *node)
{
    Node *y = NULL;
    Node *x = root->node;

    // 1. 将红黑树当作一颗二叉查找树,将节点添加到二叉查找树中。
    while (x != NULL)
    {
        y = x;
        if (node->key < x->key)
            x = x->left;
        else
            x = x->right;
    }
    rb_parent(node) = y;

    if (y != NULL)
    {
        if (node->key < y->key)
            y->left = node;                // 情况2:若“node所包含的值” < “y所包含的值”,则将node设为“y的左孩子”
        else
            y->right = node;            // 情况3:(“node所包含的值” >= “y所包含的值”)将node设为“y的右孩子” 
    }
    else
    {
        root->node = node;                // 情况1:若y是空节点,则将node设为根
    }

    // 2. 设置节点的颜色为红色
    node->color = RED;

    // 3. 将它重新修正为一颗二叉查找树
    rbtree_insert_fixup(root, node);
}
Beispiel #3
0
Datei: rbt.c Projekt: 1587/ltp
rb_node *insert_predecessor_at(rb_tree * tree, rb_node * at_node,
			       datatype object)
{
	rb_node *parent;
	rb_node *new_node;

	if (!(tree->root)) {
		/* Assign a new root node (the root is always
		 * black)
		 */
		new_node = rbnode_construct(object, black);
		if (!new_node)
			return NULL;
		tree->root = new_node;
		tree->isize = 1;
		return new_node;
	}

	/* Insert the new object as a red leaf, being the predecessor
	 * of at_node
	 */
	new_node = rbnode_construct(object, red);
	if (!new_node)
		return NULL;

	if (!at_node) {
		/* The new node should become the tree maximum. Place
		 * is as the right child of the current maximal leaf
		 */
		parent = rbnode_maximum(tree->root);
		parent->right = new_node;
	} else {
		/* Make sure the insertion does not violate the tree
		 * order In case given node has no left child, place
		 * the new node as its left child. Otherwise, place it
		 * at the rightmost position at the sub-tree rooted at
		 * its left side.
		 */
		if (!(at_node->left)) {
			parent = at_node;
			parent->left = new_node;
		} else {
			parent = rbnode_maximum(at_node->left);
			parent->right = new_node;
		}
	}

	new_node->parent = parent;

	/* Mark that a new node was added */
	tree->isize++;

	/* Fix the tree properties */
	rbtree_insert_fixup(tree, new_node);

	return new_node;
}
Beispiel #4
0
/*
 * Inserts a node into a red black tree.
 *
 * Returns NULL on failure or the pointer to the newly added node
 * otherwise.
 */
rbnode_t *
rbtree_insert (rbtree_t *rbtree, rbnode_t *data)
{
    /* XXX Not necessary, but keeps compiler quiet... */
    int r = 0;

    /* We start at the root of the tree */
    rbnode_t	*node = rbtree->root;
    rbnode_t	*parent = RBTREE_NULL;

    /* Lets find the new parent... */
    while (node != RBTREE_NULL) {
        /* Compare two keys, do we have a duplicate? */
        if ((r = rbtree->cmp(data->key, node->key)) == 0) {
            return NULL;
        }
        parent = node;

        if (r < 0) {
            node = node->left;
        } else {
            node = node->right;
        }
    }

    /* Initialize the new node */
    data->parent = parent;
    data->left = data->right = RBTREE_NULL;
    data->color = RED;
    rbtree->count++;

    /* Insert it into the tree... */
    if (parent != RBTREE_NULL) {
        if (r < 0) {
            parent->left = data;
        } else {
            parent->right = data;
        }
    } else {
        rbtree->root = data;
    }

    /* Fix up the red-black properties... */
    rbtree_insert_fixup(rbtree, data);

    return data;
}
Beispiel #5
0
/*Insert*/
void
mln_sarbt_insert(mln_sarbt_t *t, mln_sarbt_node_t *n)
{
    mln_sarbt_node_t *y = &(t->nil);
    mln_sarbt_node_t *x = t->root;
    while (x != &(t->nil)) {
        y = x;
        if (t->cmp(n->data, x->data) < 0) x = x->left;
        else x = x->right;
    }
    n->parent = y;
    if (y == &(t->nil)) t->root = n;
    else if (t->cmp(n->data, y->data) < 0) y->left = n;
    else y->right = n;
    n->left = &(t->nil);
    n->right = &(t->nil);
    n->color = M_SARB_RED;
    rbtree_insert_fixup(t, n);
}
Beispiel #6
0
void util_rbtree_insert(util_rbtree_t *rbtree, util_rbtree_node_t *node)
{
    util_rbtree_node_t *x, *y;
	if((rbtree==NULL) || (node==NULL) || (node==_NULL(rbtree)))
	{
		return;
	}
    /* the tree is empty */
    if(rbtree->root == _NULL(rbtree))
    {
        rbtree->root = node;
        node->parent = _NULL(rbtree);
    }
    else /* find the insert position */
    {
        x = rbtree->root;
        while(x != _NULL(rbtree))
        {
            y = x;
            if(node->key < x->key) x = x->left;
            else x = x->right;
        }
        /* now y is node's parent */
        node->parent = y;
        if(node->key < y->key) y->left = node;
        else y->right = node;
    }

    /* initialize node's link & color */
    node->left = _NULL(rbtree);
    node->right = _NULL(rbtree);
    util_rbt_red(node);
    /* fix up insert */
    rbtree_insert_fixup(rbtree, node);
	rbtree->size++;
}
Beispiel #7
0
Datei: rbt.c Projekt: 1587/ltp
rb_node *rbtree_insert(rb_tree * tree, datatype object)
{
	rb_node *cur_node;
	rb_node *new_node;
	int comp_result = 0;

	if (!(tree->root)) {
		/* Assign a new root node (the root is always
		 * black)
		 */
		new_node = rbnode_construct(object, black);
		if (!new_node)
			return NULL;
		tree->root = new_node;
		tree->isize = 1;
		return new_node;
	}

	/* Find a spot for the new object, insert the object as a red
	 * leaf
	 */

	cur_node = tree->root;
	new_node = rbnode_construct(object, red);
	if (!new_node)
		return NULL;

	while (cur_node) {
		/* Compare inserted object with the object stored in
		 * the current node
		 */
		comp_result = COMP_NODES(object, cur_node->object);
		if (comp_result == 0) {
			printf
			    ("Attempted to insert duplicate node, aborting\n");
			free(new_node);
			return NULL;
		}
		if (comp_result > 0) {
			if (!(cur_node->left)) {
				/* Insert the new leaf as the left
				 * child of the current node
				 */
				cur_node->left = new_node;
				new_node->parent = cur_node;
				cur_node = NULL;	/* Terminate the while loop */
			} else {
				/* Go to the left subtree */
				cur_node = cur_node->left;
			}
		} else {
			if (!(cur_node->right)) {
				/* Insert the new leaf as the right
				 * child of the current node
				 */
				cur_node->right = new_node;
				new_node->parent = cur_node;
				cur_node = NULL;	/* Terminate the while loop */
			} else {
				/* Go to the right subtree */
				cur_node = cur_node->right;
			}
		}
	}

	/* Mark the fact that a new node was added */
	tree->isize++;

	/* Fix the tree properties */
	rbtree_insert_fixup(tree, new_node);

	return new_node;
}
Beispiel #8
0
/*! 
 * Insert a new object to the tree as the a predecessor of a given node
 *
 * \param tree The tree
 *
 * \return The new node
 */
rbnode_t * rbtree_insert_predecessor_object_at
    (
    rbtree_t * tree,
    rbnode_t * at_node, 
    void * object
    )
    {
    rbnode_t * parent;
    rbnode_t * new_node;

    if (!(tree->root))
        {
        /* Assign a new root node. Notice that the root is always black */
        new_node = rbnode_create(object, RB_BLACK);
        
        if (!new_node) 
            return NULL;
        
        tree->root = new_node;
        tree->size = 1;

        new_node->tree = tree;
        
        return new_node;
        }

    /* Insert the new object as a red leaf, being the predecessor of at_node */
    new_node = rbnode_create(object, RB_RED);
    
    if (!new_node) 
        return NULL;

    if (!at_node)
        {
        /* The new node should become the tree maximum: Place is as the right
         * child of the current maximal leaf.
         */
        parent = rbnode_maximum(tree->root);
        parent->right = new_node;
        }
    else
        {
        /* Make sure the insertion does not violate the tree order */

        /* In case given node has no left child, place the new node as its
         * left child. Otherwise, place it at the rightmost position at the
         * sub-tree rooted at its left side.
         */
        if (!(at_node->left))
            {
            parent = at_node;
            parent->left = new_node;
            }
        else
            {
            parent = rbnode_maximum (at_node->left);
            parent->right = new_node;
            }
        }

    new_node->parent = parent;

    /* Mark that a new node was added */
    tree->size++;

    /* Fix up the tree properties */
    rbtree_insert_fixup(tree, new_node);

    new_node->tree = tree;

    return new_node;
    }
Beispiel #9
0
/*!
 * Insert an object to the tree [takes O(log n) operations]
 *
 * \param tree The tree
 *
 * \param object The object to be inserted
 *
 * \return the inserted object node
 */
rbnode_t * rbtree_insert_object
    (
    rbtree_t * tree, 
    void * object
    )
    {
    rbnode_t * cur_node;
    rbnode_t * new_node;

    if (!(tree->root))
        {
        /*
         * Assign a new root node.
         * Notice that the root is always black
         */
        new_node = rbnode_create(object, RB_BLACK);

        if (!new_node)
            return NULL;

        tree->root = new_node;
        tree->size = 1;
        
        new_node->tree = tree;
        
        return new_node;
        }

    /* Find a place for the new object, and insert it as a red leaf */
    cur_node = tree->root;

    new_node = rbnode_create(object, RB_RED);
    if (!new_node)
        return NULL;

    while (cur_node)
        {
        /*
         * Compare inserted object with the object stored
         * in the current node
         */
        if ((tree->compare)(object, cur_node->object) > 0)
            {
            if (!(cur_node->left))
                {
                /*
                 * Insert the new leaf as the left
                 * child of the current node
                 */
                cur_node->left = new_node;
                new_node->parent = cur_node;

                /* Terminate the while loop */
                cur_node = NULL;
                }
            else
                {
                /* Go to the left sub-tree */
                cur_node = cur_node->left;
                }
            }
        else
            {
            if (!(cur_node->right))
                {
                /*
                 * Insert the new leaf as the right
                 * child of the current node
                 */
                cur_node->right = new_node;
                new_node->parent = cur_node;

                /* Terminate the while loop */
                cur_node = NULL;
                }
            else
                {
                /* Go to the right sub-tree */
                cur_node = cur_node->right;
                }
            }
        }

    /* Mark that a new node was added */
    tree->size++;

    /* Fix up the tree properties */
    rbtree_insert_fixup(tree, new_node);
    
    new_node->tree = tree;
    
    return new_node;
    }