void rbtree_insert(rbtree t, void* key, void* value, compare_func compare) {
node inserted_node = new_node(key, value, RED, NULL, NULL);
if (t->root == NULL) {
t->root = inserted_node;
} else {
node n = t->root;
while (1) {
int comp_result = compare(key, n->key);
if (comp_result == 0) {
n->value = value;
return;
} else if (comp_result < 0) {
if (n->left == NULL) {
n->left = inserted_node;
break;
} else {
n = n->left;
}
} else {
assert (comp_result > 0);
if (n->right == NULL) {
n->right = inserted_node;
break;
} else {
n = n->right;
}
}
}
inserted_node->parent = n;
}
insert_case1(t, inserted_node);
}
static inline void
rbtree_add_node_impl(struct RBTREE_TYPENAME* target,
struct RBTREE_NODE* N)
{
DEBUG_RBTREE("rbtree_add_node_impl: "RBTREE_KEY_PRNF"\n",
RBTREE_KEY_PRN(N->key));
DEBUG_RBTREE("before:\n");
// RBTREE_PRINT(target);
N->color = RED;
if (target->size == 0)
{
target->root = N;
target->size = 1;
insert_case1(target, N);
}
else
{
// Normal tree insertion
struct RBTREE_NODE* root = target->root;
rbtree_add_loop(target, N, root);
insert_case2(target, N);
}
DEBUG_RBTREE("after:\n");
// RBTREE_PRINT(target);
}
void rbtree_insert(rbtree t, void* key, void* value, compare_func compare) {
node inserted_node = new_node(key, value, RED, NULL, NULL);
if (t->root == NULL) {
t->root = inserted_node;
} else {
node n = t->root;
while (1) {
int comp_result = compare(key, n->key);
if (comp_result == 0) {
n->value = value;
/* inserted_node isn't going to be used, don't leak it */
free (inserted_node);
return;
} else if (comp_result < 0) {
if (n->left == NULL) {
n->left = inserted_node;
break;
} else {
n = n->left;
}
} else {
assert (comp_result > 0);
if (n->right == NULL) {
n->right = inserted_node;
break;
} else {
n = n->right;
}
}
}
inserted_node->parent = n;
}
insert_case1(t, inserted_node);
verify_properties(t);
}
rb_node* rb_insert(uint32_t key, rb_tree* tree) {
rb_node* n = calloc(1,sizeof(rb_node));
n->key = key;
n->color = RED;
n->left = tree->nil;
n->right = tree->nil;
#ifdef DEBUG
is_correct(tree);
#endif
if(tree->root)
tree_insert(n, tree->root, tree);
else
tree->root = n;
#ifdef DEBUG
is_correct(tree);
#endif
insert_case1(n, tree);
#ifdef DEBUG
is_correct(tree);
#endif
tree->n++;
return n;
}
void bbst_insert(bbst tree, void* key, void* value, compare_func compare){
node inserted_node = new_node(key, value, RED, NULL, NULL);
if(tree->root == NULL){
tree->root = inserted_node;
} else {
node n = tree->root;
while(1==1){
int compare_result = compare(key, n->key);
if(compare_result == 0){
free(inserted_node);
return;
} else if (compare_result < 0) {
if(n->left == NULL){
n->left = inserted_node;
break;
} else
n = n->left;
} else {
if(n->right == NULL){
n->right = inserted_node;
break;
} else
n = n->right;
}
}
inserted_node->parent = n;
}
insert_case1(tree, inserted_node);
}
/*
* === FUNCTION ======================================================================
* Name: insert_node
* Description:
* =====================================================================================
*/
void insert_node
(
set * root,
set * node,
int (*compare)(void *, void *)
)
{
set * set_ptr = root;
set * set_ptr_parent;
/***************************************
* Insert the actual data *
***************************************/
/* If there's no data in the root just add the data there */
if(root->data == NULL)
{
root->data = node->data;
}
else
{
/* Remember: only unique values are allowed */
while(set_ptr != NULL)
{
if(compare(node->data, set_ptr->data) == 0)
{
/* Return since we're trying to insert an item already in the set */
return;
}
else if(compare(node->data, set_ptr->data) < 0)
{
set_ptr_parent = set_ptr;
set_ptr = set_ptr->left;
}
else
{
set_ptr_parent = set_ptr;
set_ptr = set_ptr->right;
}
}
/* Decide if the node should be left or right child */
if(compare(node->data, set_ptr_parent->data) < 0)
{
set_ptr_parent->left = node;
}
else
{
set_ptr_parent->right = node;
}
}
node->color = RED;
/***************************************
* Insertion bookkeeping *
***************************************/
insert_case1(node);
} /* ----- end of function insert_node ----- */
static void insert_case3(L_RBTREE *t, node *n) {
if (node_color(uncle(n)) == L_RED_NODE) {
n->parent->color = L_BLACK_NODE;
uncle(n)->color = L_BLACK_NODE;
grandparent(n)->color = L_RED_NODE;
insert_case1(t, grandparent(n));
} else {
insert_case4(t, n);
}
}
void insert_case3(rbtree t, node n) {
if (node_color(uncle(n)) == RED) {
n->parent->color = BLACK;
uncle(n)->color = BLACK;
grandparent(n)->color = RED;
insert_case1(t, grandparent(n));
} else {
insert_case4(t, n);
}
}
void insert_case3(rb_node* n, rb_tree* tree) {
rb_node* u = uncle(n), *g;
if ((u != NULL) && (u->color == RED)) {
n->parent->color = BLACK;
u->color = BLACK;
g = grandparent(n);
g->color = RED;
insert_case1(g, tree);
}
else {
insert_case4(n, tree);
}
}
/*
* l_rbtreeInsert()
*
* Input: t (rbtree, including root node)
* key (insert a node with this key, if the key does not already
* exist in the tree)
* value (typically an int, used for an index)
* Return: void
*
* Notes:
* (1) If a node with the key already exists, this just updates the value.
*/
void
l_rbtreeInsert(L_RBTREE *t,
RB_TYPE key,
RB_TYPE value)
{
node *n, *inserted_node;
PROCNAME("l_rbtreeInsert");
if (!t) {
L_ERROR("tree is null\n", procName);
return;
}
inserted_node = new_node(key, value, L_RED_NODE, NULL, NULL);
if (t->root == NULL) {
t->root = inserted_node;
} else {
n = t->root;
while (1) {
int comp_result = l_compareKeys(t->keytype, key, n->key);
if (comp_result == 0) {
n->value = value;
LEPT_FREE(inserted_node);
return;
} else if (comp_result < 0) {
if (n->left == NULL) {
n->left = inserted_node;
break;
} else {
n = n->left;
}
} else { /* comp_result > 0 */
if (n->right == NULL) {
n->right = inserted_node;
break;
} else {
n = n->right;
}
}
}
inserted_node->parent = n;
}
insert_case1(t, inserted_node);
verify_properties(t);
}
static void
insert_case3(struct RBTREE_TYPENAME* target, struct RBTREE_NODE* node)
{
struct RBTREE_NODE* U = uncle(node);
struct RBTREE_NODE* G;
DEBUG_RBTREE("insert_case3\n");
if (U != NULL && U->color == RED)
{
node->parent->color = BLACK;
U->color = BLACK;
G = grandparent(node);
G->color = RED;
insert_case1(target, G);
}
else
{
insert_case4(target, node);
}
}
/*
* === FUNCTION ======================================================================
* Name: insert_case3
* Description: Covers the case that the parent and uncle are both RED
* =====================================================================================
*/
static void insert_case3
(
set * n
)
{
set * u = uncle(n);
set * g;
if((u != NULL )
&& (u->color == RED))
{
n->parent->color = BLACK;
u->color = BLACK;
g = grandparent(n);
g->color = RED;
insert_case1(g);
}
else
{
insert_case4(n);
}
} /* ----- end of static function insert_case3 ----- */
void rbtree_insert(struct rbtree* t, struct rbtree_node *inserted_node)
{
inserted_node->color = RED;
inserted_node->left = NULL;
inserted_node->right = NULL;
inserted_node->parent = NULL;
if (t->root == NULL) {
t->root = inserted_node;
} else {
struct rbtree_node* n = t->root;
while (1) {
int comp_result = t->compare(inserted_node->key, n->key);
if (comp_result == 0) {
/* duplicate */
n->data = inserted_node->data;
return;
} else if (comp_result < 0) {
if (n->left == NULL) {
n->left = inserted_node;
break;
} else {
n = n->left;
}
} else {
assert (comp_result > 0);
if (n->right == NULL) {
n->right = inserted_node;
break;
} else {
n = n->right;
}
}
}
inserted_node->parent = n;
}
t->size++;
insert_case1(t, inserted_node);
}
void rbtree_insert(GtkWidget *darea, rbtree t, int key) {
int x = WIDTH / 2, y = 22, r = (WIDTH - 20) / 2;
char *s = (char*) malloc(3 * sizeof(char));
sprintf(s, "%d", key);
node inserted_node = new_node(key, RED, NULL, NULL);
if (t->root == NULL) {
inserted_node->x = x;
inserted_node->y = y;
inserted_node->r = r;
t->root = inserted_node;
}
else {
node n = t->root;
while (1) {
int comp = compare(key, n->key);
if (comp == 0) {
if (path)
print_circle(darea, s, RED, x - 20, y, 10, 12);
free (inserted_node);
return;
}
else if (comp < 0) {
if (path)
print_circle(darea, s, RED, x - 20, y, 10, 12);
if (n->left == NULL) {
inserted_node->x = x - r / 2;
inserted_node->y = y + 30;
inserted_node->r = r / 2;
n->left = inserted_node;
print_circle(darea, s, RED, inserted_node->x, inserted_node->y, 15, 16);
break;
}
else {
x -= r / 2;
y += 30;
r /= 2;
n = n->left;
}
}
else {
if (path)
print_circle(darea, s, RED, x - 20, y, 10, 12);
if (n->right == NULL) {
inserted_node->x = x + r / 2;
inserted_node->y = y + 30;
inserted_node->r = r / 2;
n->right = inserted_node;
print_circle(darea, s, RED, inserted_node->x, inserted_node->y, 15, 16);
break;
}
else {
x += r / 2;
y += 30;
r /= 2;
n = n->right;
}
}
}
inserted_node->parent = n;
}
insert_case1(darea, t, inserted_node);
}
