END_TEST
START_TEST(test_binary_tree_insert)
{
struct bin_tree *bin_tree;
int data[4], i;
for (i = 0; i < 4; i++)
data[i] = i;
bin_tree = binary_tree_new();
fail_unless(binary_tree_insert(bin_tree, "foo", &data[1]) == 0,
"Couldn't insert foo");
fail_unless(binary_tree_insert(bin_tree, "bar", &data[2]) == 0,
"Couldn't insert bar");
fail_unless(binary_tree_insert(bin_tree, "baz", &data[3]) == 0,
"Couldn't insert baz");
fail_unless(*((int *)binary_tree_lookup(bin_tree, "foo")) == 1,
"Didn't lookup right value");
fail_unless(*((int *)binary_tree_lookup(bin_tree, "bar")) == 2,
"Didn't lookup right value");
fail_unless(*((int *)binary_tree_lookup(bin_tree, "baz")) == 3,
"Didn't lookup right value");
}
static char * test_binary_tree_insertion_3() {
int aux;
BinaryTreeNode* node;
aux = 0;
node = NULL;
printf("Initial configuration: \n");
node = binary_tree_insert(14, node, &aux);
binary_tree_print(node, 1);
printf("\n ------------------- \n");
node = binary_tree_insert(17, node, &aux);
binary_tree_print(node, 1);
printf("\n ------------------- \n");
node = binary_tree_insert(11, node, &aux);
binary_tree_print(node, 1);
printf("\n ------------------- \n");
node = binary_tree_insert(7, node, &aux);
binary_tree_print(node, 1);
printf("\n ------------------- \n");
node = binary_tree_insert(53, node, &aux);
binary_tree_print(node, 1);
printf("\n ------------------- \n");
node = binary_tree_insert(4, node, &aux);
binary_tree_print(node, 1);
printf("\n ------------------- \n");
node = binary_tree_insert(13, node, &aux);
binary_tree_print(node, 1);
printf("\n ------------------- \n");
node = binary_tree_insert(12, node, &aux);
binary_tree_print(node, 1);
printf("\n ------------------- \n");
node = binary_tree_insert(8, node, &aux);
binary_tree_print(node, 1);
printf("\n ------------------- \n");
node = binary_tree_remove_node(node, 53, &aux);
binary_tree_print(node, 1);
printf("\n ------------------- \n");
node = binary_tree_remove_node(node, 11, &aux);
binary_tree_print(node, 1);
printf("\n ------------------- \n");
node = binary_tree_remove_node(node, 8, &aux);
binary_tree_print(node, 1);
printf("\n ------------------- \n");
mu_assert("test_binary_tree_insertion", 1 == 1);
return 0;
}
END_TEST
START_TEST(test_binary_tree_insert_duplicate)
{
struct bin_tree *bin_tree;
int data = 1;
bin_tree = binary_tree_new();
fail_unless(binary_tree_insert(bin_tree, "foo", &data) == 0,
"Couldn't insert foo");
fail_unless(binary_tree_insert(bin_tree, "foo", &data) != 0,
"Could insert foo, shouldn't be able to");
}
int fasthash_builder_insert(FastHashBuilder *builder, void *keys, void *values,
size_t n) {
size_t i;
int r;
assert(builder);
for (i = 0; i < n; ++i) {
r = binary_tree_insert(builder->tree, keys + i, values + i);
if (r < 0)
return r;
}
return 0;
}
static char * test_binary_tree_insertion() {
/*
* Test case based on http://www.csee.umbc.edu/courses/undergraduate/341/fall98/frey/ClassNotes/Class18/avl.html
*/
int aux;
BinaryTreeNode* node;
aux = 0;
node = NULL;
printf("Initial configuration: \n");
node = binary_tree_insert(10, node, &aux);
binary_tree_print(node, 1);
printf("\n ------------------- \n");
node = binary_tree_insert(20, node, &aux);
binary_tree_print(node, 1);
printf("\n ------------------ \n");
node = binary_tree_insert(30, node, &aux);
binary_tree_print(node, 1);
printf("\n ------------------ \n");
node = binary_tree_insert(40, node, &aux);
binary_tree_print(node, 1);
printf("\n ------------------ \n");
node = binary_tree_insert(50, node, &aux);
binary_tree_print(node, 1);
printf("\n ------------------ \n");
node = binary_tree_insert(0, node, &aux);
binary_tree_print(node, 1);
printf("\n ------------------ \n");
node = binary_tree_insert(70, node, &aux);
binary_tree_print(node, 1);
printf("\n ------------------ \n");
node = binary_tree_insert(60, node, &aux);
binary_tree_print(node, 1);
printf("\n ------------------ \n");
mu_assert("test_binary_tree_insertion", 1 == 1);
return 0;
}
int bus_detatch(struct bus_t *self_p,
struct bus_listener_t *listener_p)
{
ASSERTN(self_p != NULL, EINVAL);
ASSERTN(listener_p != NULL, EINVAL);
int res = 0;
struct bus_listener_t *head_p, *curr_p, *prev_p;
rwlock_writer_take(&self_p->rwlock);
head_p = (struct bus_listener_t *)binary_tree_search(
&self_p->listeners, listener_p->id);
if (head_p == NULL) {
res = -1;
} else if (head_p == listener_p) {
res = binary_tree_delete(&self_p->listeners, listener_p->id);
if (listener_p->next_p != NULL) {
binary_tree_insert(&self_p->listeners,
&listener_p->next_p->base);
}
} else {
curr_p = head_p->next_p;
prev_p = head_p;
res = -1;
while (curr_p != NULL) {
if (curr_p == listener_p) {
prev_p->next_p = listener_p->next_p;
res = 0;
break;
}
prev_p = curr_p;
curr_p = curr_p->next_p;
}
}
rwlock_writer_give(&self_p->rwlock);
return (res);
}
int bus_attach(struct bus_t *self_p,
struct bus_listener_t *listener_p)
{
ASSERTN(self_p != NULL, EINVAL);
ASSERTN(listener_p != NULL, EINVAL);
struct bus_listener_t *head_p;
rwlock_writer_take(&self_p->rwlock);
/* Try to insert the node into the tree. It fails if there already
* is a node with the same key (id).*/
if (binary_tree_insert(&self_p->listeners, &listener_p->base) != 0) {
head_p = (struct bus_listener_t *)binary_tree_search(
&self_p->listeners, listener_p->id);
listener_p->next_p = head_p->next_p;
head_p->next_p = listener_p;
}
rwlock_writer_give(&self_p->rwlock);
return (0);
}
static char * test_binary_tree_insertion_4() {
int aux;
BinaryTreeNode* node;
aux = 0;
node = NULL;
printf("Initial configuration: \n");
node = binary_tree_insert(15, node, &aux);
binary_tree_print(node, 1);
printf("\n ------------------- \n");
node = binary_tree_insert(20, node, &aux);
binary_tree_print(node, 1);
printf("\n ------------------- \n");
node = binary_tree_insert(24, node, &aux);
binary_tree_print(node, 1);
printf("\n ------------------- \n");
node = binary_tree_insert(10, node, &aux);
binary_tree_print(node, 1);
printf("\n ------------------- \n");
node = binary_tree_insert(13, node, &aux);
binary_tree_print(node, 1);
printf("\n ------------------- \n");
node = binary_tree_insert(7, node, &aux);
binary_tree_print(node, 1);
printf("\n ------------------- \n");
node = binary_tree_insert(30, node, &aux);
binary_tree_print(node, 1);
printf("\n ------------------- \n");
node = binary_tree_insert(36, node, &aux);
binary_tree_print(node, 1);
printf("\n ------------------- \n");
node = binary_tree_insert(25, node, &aux);
binary_tree_print(node, 1);
printf("\n ------------------- \n");
node = binary_tree_remove_node(node, 24, &aux);
binary_tree_print(node, 1);
printf("\n ------------------- \n");
node = binary_tree_remove_node(node, 20, &aux);
binary_tree_print(node, 1);
printf("\n ------------------- \n");
// node = binary_tree_insert(8, node, &aux);
// binary_tree_print(node, 1);
// printf("\n ------------------- \n");
//
// node = binary_tree_remove_node(node, 53, &aux);
// binary_tree_print(node, 1);
// printf("\n ------------------- \n");
//
// node = binary_tree_remove_node(node, 11, &aux);
// binary_tree_print(node, 1);
// printf("\n ------------------- \n");
//
// node = binary_tree_remove_node(node, 8, &aux);
// binary_tree_print(node, 1);
// printf("\n ------------------- \n");
mu_assert("test_binary_tree_insertion", 1 == 1);
return 0;
}
static char * test_binary_tree_creation() {
int aux;
BinaryTreeNode* node;
aux = 0;
node = NULL;
printf("Initial configuration: \n");
node = binary_tree_insert(10, node, &aux);
node = binary_tree_insert(20, node, &aux);
node = binary_tree_insert(30, node, &aux);
node = binary_tree_insert(40, node, &aux);
node = binary_tree_insert(50, node, &aux);
node = binary_tree_insert(60, node, &aux);
node = binary_tree_insert(80, node, &aux);
node = binary_tree_insert(90, node, &aux);
node = binary_tree_insert(100, node, &aux);
node = binary_tree_insert(110, node, &aux);
node = binary_tree_insert(120, node, &aux);
binary_tree_print(node, 1);
printf("\n");
printf("\n");
printf("-----------------------------------\n");
printf("\n");
node = binary_tree_remove_node(node, 90, &aux);
printf("Removing Node: %d \n", 90);
binary_tree_print(node, 1);
printf("\n");
printf("-----------------------------------\n");
node = binary_tree_remove_node(node, 100, &aux);
printf("Removing Node: %d \n", 100);
binary_tree_print(node, 1);
printf("\n");
printf("-----------------------------------\n");
node = binary_tree_remove_node(node, 110, &aux);
printf("Removing Node: %d \n", 110);
binary_tree_print(node, 1);
printf("\n");
printf("-----------------------------------\n");
node = binary_tree_remove_node(node, 80, &aux);
printf("Removing Node: %d \n", 80);
binary_tree_print(node, 1);
printf("\n");
printf("-----------------------------------\n");
node = binary_tree_remove_node(node, 120, &aux);
printf("Removing Node: %d \n", 120);
binary_tree_print(node, 1);
printf("\n");
printf("-----------------------------------\n");
mu_assert("erro test_binary_tree_creation", 1 == 1);
return 0;
}
int main(void) {
struct binary_tree* tree = NULL;
struct node* new_node = NULL, ** flat_tree = NULL;
char choise, val;
int key, size, buf[10];
while(1) {
fprintf(stdout, "Binary Tree Demo\n\ta)Insert\n\tb)Remove\n\tc)Search\n\td)Display\n\te)Exit\n\tEnter Choise: ");
fscanf(stdin, " %c", &choise);
switch(choise) {
case 'a':
fprintf(stdout, "\tEnter key(number) and value(character) to Insert: ");
fscanf(stdin, "%d %c", &key, &val);
init_node(&new_node, key, val);
if(!tree)
init_binary_tree(&tree, new_node);
else
binary_tree_insert(tree, new_node);
fprintf(stdout, "\tInserted %d-%c in the tree, new tree size %d\n", key, val, binary_tree_size(tree));
break;
case 'b':
fprintf(stdout, "\tEnter key(number) to Remove: ");
fscanf(stdin, "%d", &key);
binary_tree_remove(tree, key);
fprintf(stdout, "\tRemoved %d from the tree, new tree size %d\n", key, binary_tree_size(tree));
break;
case 'c':
fprintf(stdout, "\tEnter key(number) to Search value(character): ");
fscanf(stdin, "%d", &key);
if(new_node = binary_tree_search(tree, key))
fprintf(stdout,"\tkey = %d, value = %c\n", new_node->key, (char)(new_node->val));
break;
case 'd':
fprintf(stdout, "\tOrder of Display\n\t\ta)depth-first(in-order)\n\t\tb)depth-first(pre-order)\n\t\tc)depth-first(post-order)\n\t\td)breadth-first\n\t\te)back to previous menu\n\t\tEnter choise: ");
fscanf(stdin, " %c", &choise);
if(choise < 'e' && choise >= 'a') {
flat_tree = malloc(binary_tree_size(tree) * sizeof(struct node*));
if(!flat_tree) {
fprintf(stdout, "can't allocate memory for flattened tree\n");
exit(EXIT_FAILURE);
}
switch(choise) {
case 'a':
binary_tree_flatten(tree, IN_ORDER, flat_tree);
break;
case 'b':
binary_tree_flatten(tree, PRE_ORDER, flat_tree);
break;
case 'c':
binary_tree_flatten(tree, POST_ORDER, flat_tree);
break;
case 'd':
binary_tree_flatten(tree, BREADTH_FIRST, flat_tree);
}
fprintf(stdout,"\t");
for(size = 0; size < binary_tree_size(tree); size++) {
fprintf(stdout, "(key = %d, value = %c) ", flat_tree[size]->key, (char)(flat_tree[size]->val));
}
fprintf(stdout, "\n");
free(flat_tree);
}
break;
case 'e':
if(tree) destroy_binary_tree(&tree);
exit(EXIT_SUCCESS);
default:
fprintf(stdout, "Enter a, b, c, d or e in lower-case\n");
}
}
return 0;
}
/**
* e_intervaltree_insert:
* @tree: interval tree
* @start: start of the interval
* @end: end of the interval
* @comp: Component
*
* Since: 2.32
**/
gboolean
e_intervaltree_insert (EIntervalTree *tree,
time_t start,
time_t end,
ECalComponent *comp)
{
EIntervalTreePrivate *priv;
EIntervalNode *y;
EIntervalNode *x;
EIntervalNode *newNode;
const gchar *uid;
gchar *rid;
g_return_val_if_fail (tree != NULL, FALSE);
g_return_val_if_fail (comp != NULL, FALSE);
g_return_val_if_fail (E_IS_CAL_COMPONENT (comp), FALSE);
priv = tree->priv;
g_static_rec_mutex_lock (&priv->mutex);
e_cal_component_get_uid (comp, &uid);
rid = e_cal_component_get_recurid_as_string (comp);
e_intervaltree_remove (tree, uid, rid);
x = g_new (EIntervalNode, 1);
x->min = x->start = start;
x->max = x->end = end;
x->comp = g_object_ref (comp);
binary_tree_insert (tree, x);
newNode = x;
x->red = TRUE;
fixup_min_max_fields (tree, x->parent);
while (x->parent->red)
{ /* use sentinel instead of checking for root */
if (x->parent == x->parent->parent->left)
{
y = x->parent->parent->right;
if (y->red)
{
x->parent->red = FALSE;
y->red = FALSE;
x->parent->parent->red = TRUE;
x = x->parent->parent;
}
else
{
if (x == x->parent->right)
{
x = x ->parent;
left_rotate (tree, x);
}
x->parent->red = FALSE;
x->parent->parent->red = TRUE;
right_rotate (tree, x->parent->parent);
}
}
else
{ /* case for x->parent == x->parent->parent->right */
y = x->parent->parent->left;
if (y->red)
{
x->parent->red = FALSE;
y->red = FALSE;
x->parent->parent->red = TRUE;
x = x->parent->parent;
}
else
{
if (x == x->parent->left)
{
x = x->parent;
right_rotate (tree, x);
}
x->parent->red = FALSE;
x->parent->parent->red = TRUE;
left_rotate (tree, x->parent->parent);
}
}
}
priv->root->left->red = FALSE;
g_hash_table_insert (priv->id_node_hash, component_key (uid, rid), newNode);
g_free (rid);
g_static_rec_mutex_unlock (&priv->mutex);
return TRUE;
}
static struct bin_tree *
setup_balanced_tree(void)
{
struct bin_tree *bin_tree;
static int data[16];
int i;
for (i = 0; i < 16; i++)
data[i] = i;
bin_tree = binary_tree_new();
fail_unless(binary_tree_insert(bin_tree, "h", &data[8]) == 0,
"Couldn't insert");
fail_unless(binary_tree_insert(bin_tree, "d", &data[4]) == 0,
"Couldn't insert");
fail_unless(binary_tree_insert(bin_tree, "l", &data[12]) == 0,
"Couldn't insert");
fail_unless(binary_tree_insert(bin_tree, "b", &data[2]) == 0,
"Couldn't insert");
fail_unless(binary_tree_insert(bin_tree, "f", &data[6]) == 0,
"Couldn't insert");
fail_unless(binary_tree_insert(bin_tree, "j", &data[10]) == 0,
"Couldn't insert");
fail_unless(binary_tree_insert(bin_tree, "n", &data[14]) == 0,
"Couldn't insert");
fail_unless(binary_tree_insert(bin_tree, "a", &data[1]) == 0,
"Couldn't insert");
fail_unless(binary_tree_insert(bin_tree, "c", &data[3]) == 0,
"Couldn't insert");
fail_unless(binary_tree_insert(bin_tree, "e", &data[5]) == 0,
"Couldn't insert");
fail_unless(binary_tree_insert(bin_tree, "g", &data[7]) == 0,
"Couldn't insert");
fail_unless(binary_tree_insert(bin_tree, "i", &data[9]) == 0,
"Couldn't insert");
fail_unless(binary_tree_insert(bin_tree, "k", &data[11]) == 0,
"Couldn't insert");
fail_unless(binary_tree_insert(bin_tree, "m", &data[13]) == 0,
"Couldn't insert");
fail_unless(binary_tree_insert(bin_tree, "o", &data[15]) == 0,
"Couldn't insert");
return bin_tree;
}
int fasthash_builder_add(FastHashBuilder *builder, void *key, void *value) {
assert(builder);
return binary_tree_insert(builder->tree, key, value);
}
qrb_node * _rb_insert_item(QSP_ARG_DECL qrb_tree* tree_p, Item *ip )
{
qrb_node * x_p;
qrb_node * new_node_p;
qrb_node * gp_p; // grandparent
qrb_node * u_p; // uncle
new_node_p = (qrb_node*) getbuf(sizeof(qrb_node));
// new_node_p->key = key;
new_node_p->data = ip;
new_node_p->left = NULL;
new_node_p->right = NULL;
MAKE_RED(new_node_p);
binary_tree_insert(tree_p,new_node_p);
x_p = new_node_p;
while( 1 ){
if( IS_ROOT_NODE(x_p) ){ // wikipedia case 1
MAKE_BLACK(x_p);
return new_node_p;
}
if( IS_BLACK(x_p->parent) ){ // wikipedia case 2
return new_node_p;
}
gp_p = grandparent(x_p);
assert( gp_p != NULL );
u_p = uncle(x_p);
// We know the parent is red
if( IS_RED(u_p) ){ // wikipedia case 3
MAKE_BLACK(x_p->parent);
MAKE_BLACK(u_p);
MAKE_RED(gp_p);
x_p = gp_p; // loop on grandparent
} else {
// uncle is black
if( x_p == x_p->parent->left && x_p->parent == gp_p->left ){
// wikipedia case 5, left child of a left child
rotate_right(tree_p,x_p->parent);
MAKE_BLACK(x_p->parent);
// new uncle is old grandparent
MAKE_RED(gp_p);
return new_node_p;
} else if( x_p == x_p->parent->right && x_p->parent == gp_p->right ){
// wikipedia case 5 mirror image
rotate_left(tree_p,x_p->parent);
MAKE_BLACK(x_p->parent);
// new uncle is old grandparent
MAKE_RED(gp_p);
return new_node_p;
} else {
// wikipedia case 4
if( x_p == x_p->parent->right ){
// right child of left child
rotate_left(tree_p,x_p);
x_p = x_p->left;
} else {
// left child of right child
rotate_right(tree_p,x_p);
x_p = x_p->right;
}
}
}
} // end tail recursion loop
//MAKE_BLACK( RB_TREE_ROOT(tree) );
// NOTREACHED ???
/*
tree_p->node_count ++;
return new_node_p;
*/
} // rb_insert
