void main()
{
int i;
m_tree_t *t;;
printf("starting \n");
t = create_m_tree();
for (i = 0; i < 50; i++)
insert_interval(t, 2 * i, 2 * i + 1);
printf("inserted first 50 intervals, total length is %d, should be 50.\n", query_length(t));
insert_interval(t, 0, 100);
printf("inserted another interval, total length is %d, should be 100.\n", query_length(t));
for (i = 1; i < 50; i++)
insert_interval(t, 199 - (3 * i), 200); /* [52,200] is longest */
printf("inserted further 49 intervals, total length is %d, should be 200.\n", query_length(t));
for (i = 2; i < 50; i++)
delete_interval(t, 2 * i, 2 * i + 1);
delete_interval(t, 0, 100);
printf("deleted some intervals, total length is %d, should be 150.\n", query_length(t));
insert_interval(t, 1, 2);
for (i = 49; i > 0; i--)
delete_interval(t, 199 - (3 * i), 200);
insert_interval(t, 0, 2);
insert_interval(t, 1, 5);
printf("deleted some intervals, total length is %d, should be 5.\n", query_length(t));
insert_interval(t, 0, 100);
printf("inserted another interval, total length is %d, should be 100.\n", query_length(t));
for (i = 0; i <= 3000; i++)
insert_interval(t, 2000 + i, 3000 + i);
printf("inserted 3000 intervals, total length is %d, should be 4100.\n", query_length(t));
for (i = 0; i <= 3000; i++)
delete_interval(t, 2000 + i, 3000 + i);
printf("deleted 3000 intervals, total length is %d, should be 100.\n", query_length(t));
for (i = 0; i <= 100; i++)
insert_interval(t, 10 * i, 10 * i + 100);
printf("inserted another 100 intervals, total length is %d, should be 1100.\n", query_length(t));
delete_interval(t, 1, 2);
delete_interval(t, 0, 2);
delete_interval(t, 2, 3);
delete_interval(t, 0, 1);
delete_interval(t, 1, 5);
printf("deleted some intervals, total length is %d, should be still 1100.\n", query_length(t));
for (i = 0; i <= 100; i++)
delete_interval(t, 10 * i, 10 * i + 100);
delete_interval(t, 0, 100);
printf("deleted last interval, total length is %d, should be 0.\n", query_length(t));
}
struct seg_tree_2d_t * create_seg_tree_2d( struct rect_list_t *rect_list){
struct seg_tree_2d_t *list = rect_list_to_tree_list(rect_list,1);
struct seg_tree_2d_t *seg_tree = make_tree(list);
printf("x seg tree build\n");
struct seg_tree_2d_t *tmp_seg_tree;
struct seg_tree_2d_t *stack[1000];
struct rect_list_t *tmp_rect_list = rect_list;
int j;
for( j = rect_total_number-1; j>= 0; j-- )
{// struct intv *tmp_ob;
// tmp_ob = (struct intv *) malloc( sizeof( struct intv ) );
// tmp_ob->low = intervals[j].low;
// tmp_ob->up = intervals[j].up;
insert_interval( seg_tree, rect_intv[j].x_min, rect_intv[j].x_max, rect_intv[j].y_min, rect_intv[j].y_max);
}
printf("Insert intervals to X tree done\n");
tmp_seg_tree = seg_tree;
int st_p = 0;
stack[st_p++] = tmp_seg_tree;
while (st_p > 0) {
struct seg_tree_2d_t *tmp_node = stack[--st_p];
if (tmp_node->rect_interval_list != NULL) {
//build y tree
list = rect_list_to_tree_list(tmp_node->rect_interval_list, 0);
tmp_node->v_tree = make_tree(list);
//insert y interval, remember x and y switched, so need to change the result;
for( j = rect_total_number_y-1; j>= 0; j-- )
{// struct intv *tmp_ob;
// tmp_ob = (struct intv *) malloc( sizeof( struct intv ) );
// tmp_ob->low = intervals[j].low;
// tmp_ob->up = intervals[j].up;
insert_interval( tmp_node->v_tree, rect_intv_y[j].x_min, rect_intv_y[j].x_max, rect_intv_y[j].y_min, rect_intv_y[j].y_max);
}
printf("Insert intervals to y done\n");
}
if (tmp_node->left != NULL) {
stack[st_p++] = tmp_node->left;
}
if (tmp_node->right != NULL) {
stack[st_p++] = tmp_node->right;
}
}
return seg_tree;
}
struct seg_tree_2d_t * create_seg_tree_2d(struct rect_list_t *list){
struct rect_list_t *tmp_list = list;
//printf("tmp_list\n" , tmp_list->x_min);
tree_node_t * seg_tree_1d;
//helpers
int keys[100000]; int prev_key = 0; int i = 0; int * tmpob = 0;
struct intv intervals[50000];
//temporrary list for creating the tree
tree_node_t * tmp_tree_list; tree_node_t * tmp_tree_helper;
//keys for x-axis
while (tmp_list != NULL){
keys[2*i] = tmp_list->x_min;
keys[2*i+1] = tmp_list->x_max;
intervals[i].x_min = tmp_list->x_min;
intervals[i].x_max = tmp_list->x_max;
intervals[i].y_min = tmp_list->y_min;
intervals[i].y_max = tmp_list->y_max;
tmp_list = tmp_list->next;
i += 1;
}
//sort x-axis keys
qsort(keys, 2*i, sizeof(int), compint);
tmp_tree_list = get_node();
tmp_tree_list->right = NULL;
prev_key = tmp_tree_list->key = keys[2*i-1];
tmpob = (int *) malloc(sizeof(int));
*tmpob = 42;
tmp_tree_list->left = (tree_node_t *) tmpob;
for (int j = 2*i-2; j>=0; j--){
if (keys[j] != prev_key){
tmp_tree_helper = get_node();
prev_key = tmp_tree_helper->key = keys[j];
tmp_tree_helper->right = tmp_tree_list;
tmpob = (int *)malloc(sizeof(int));
*tmpob = 42;
tmp_tree_helper->left = (tree_node_t *)tmpob;
tmp_tree_list = tmp_tree_helper;
}
}
//make the -nfinity
tmp_tree_helper = get_node();
tmp_tree_helper->key = -1000;
tmp_tree_helper->right = tmp_tree_list;
tmpob = (int *) malloc(sizeof(int));
*tmpob = 42;
tmp_tree_helper->left = (tree_node_t *)tmpob;
tmp_tree_list = tmp_tree_helper;
tmp_tree_helper = tmp_tree_list;
//copy the interval list to nodes
while (tmp_tree_helper != NULL){
//printf("*** Key of this node is %d **** \n", tmp_tree_helper->key);
/* for (int j = i - 1; j>=0; j--){
if (tmp_tree_helper->key == intervals[j].x_min || tmp_tree_helper->key == intervals[j].x_max){
//printf("*** Copying interval for key node %d *** \n", tmp_tree_helper->key);
tmp_tree_helper->intv_list = get_list_node();
tmp_tree_helper->intv_list->x_min = intervals[j].x_min;
tmp_tree_helper->intv_list->x_max = intervals[j].x_max;
tmp_tree_helper->intv_list->y_min = intervals[j].y_min;
tmp_tree_helper->intv_list->y_max = intervals[j].y_max;
}
}*/
tmp_tree_helper = tmp_tree_helper->right;
}
tmp_tree_helper = tmp_tree_list;
while (tmp_tree_helper != NULL){
if (tmp_tree_helper->intv_list == NULL){
//printf("\n");
// printf("*** Key is %d *** \n", tmp_tree_helper->key);
}
else{
/* printf("*** Key is %d *** \n", tmp_tree_helper->key);
printf("*** X-MIN is %d *** \n", tmp_tree_helper->intv_list->x_min);
printf("*** X-MAX is %d *** \n", tmp_tree_helper->intv_list->x_max);
printf("*** Y-MIN is %d *** \n", tmp_tree_helper->intv_list->y_min);
printf("*** Y-Max is %d *** \n", tmp_tree_helper->intv_list->y_max);
printf("\n ********************************************************** \n"); */
}
tmp_tree_helper = tmp_tree_helper->right;
}
seg_tree_1d = make_tree(tmp_tree_list);
empty_tree(seg_tree_1d);
//check_tree(seg_tree_1d, 0, -2000, 1000);
//insert intervals for x-axis
for (int p = i -1; p>=0; p--){
struct intv *tmp_ob;
tmp_ob = (struct intv *)malloc(sizeof(struct intv));
tmp_ob->x_min = intervals[p].x_min;
tmp_ob->x_max = intervals[p].x_max;
tmp_ob->y_min = intervals[p].y_min;
tmp_ob->y_max = intervals[p].y_max;
insert_interval(seg_tree_1d, intervals[p].x_min, intervals[p].x_max, tmp_ob);
}
// Create the 2-d tree
int stack_p = 0; tree_node_t * node_stack[100];
tree_node_t * itmp_ptr;
tree_node_t * tmp_inner_tree , * tmp_inner_tree_helper;
struct rect_list_t * tmp_inner_list;
//insert the root into the stack
node_stack[stack_p++] = seg_tree_1d;
while (stack_p > 0){
itmp_ptr = node_stack[--stack_p];
int lolos;
if (itmp_ptr->intv_list == NULL)
//printf("\n*** Interval List is NULL Node key is: %d *** \n", itmp_ptr->key );
lolos = 15;
//printf("*** \n ");
else{
// printf("\n*** Interval List is not NULL Node key is: %d *** \n", itmp_ptr->key );
struct rect_list_t * tmp_sot = itmp_ptr->intv_list;
int keys_y[100000]; int prev_key_y = 0; int l = 0;
tmp_inner_list = itmp_ptr->intv_list;
struct intv intervals_y[50000];
while(tmp_inner_list != NULL){
keys_y[2*l] = tmp_inner_list->y_min;
keys_y[2*l+1] = tmp_inner_list->y_max;
intervals_y[l].x_min = tmp_inner_list->x_min;
intervals_y[l].x_max = tmp_inner_list->x_max;
intervals_y[l].y_min = tmp_inner_list->y_min;
intervals_y[l].y_max = tmp_inner_list->y_max;
tmp_inner_list = tmp_inner_list->next;
l +=1;
}
//sort the keys in y-axis;
qsort(keys_y, 2*l, sizeof(int),compint);
//for( int s = 0; s<2*j; s++ )
// printf("%d, ", keys_y[s] );
// printf("\n");
tmp_inner_tree = get_node();
tmp_inner_tree->right = NULL;
prev_key_y = tmp_inner_tree->key = keys_y[2*l-1];
tmpob = (int *) malloc(sizeof(int));
*tmpob = 42;
tmp_inner_tree->left = (tree_node_t *) tmpob;
for (int m = 2*l - 2; m >=0; m--){
if (keys_y[m] != prev_key_y){
tmp_inner_tree_helper = get_node();
prev_key_y = tmp_inner_tree_helper->key=keys_y[m];
tmp_inner_tree_helper->right = tmp_inner_tree;
tmpob = (int *)malloc(sizeof(int));
*tmpob = 42;
tmp_inner_tree_helper->left = (tree_node_t *)tmpob;
tmp_inner_tree = tmp_inner_tree_helper;
}
}
//make the -nfinity
tmp_inner_tree_helper = get_node();
tmp_inner_tree_helper->key = -1000;
tmp_inner_tree_helper->right = tmp_inner_tree;
tmpob = (int *) malloc(sizeof(int));
*tmpob =42;
tmp_inner_tree_helper->left = (tree_node_t *)tmpob;
tmp_inner_tree = tmp_inner_tree_helper;
tmp_inner_tree_helper = tmp_inner_tree;
itmp_ptr->inner_tree = make_tree(tmp_inner_tree);
empty_tree(itmp_ptr->inner_tree);
//check_tree(itmp_ptr->inner_tree, 0, -2000, 1000);
//insert intervals into the y-axis
for (int s = l - 1 ; s >=0; s--){
//printf("TMP INNER LIST %d \n", k);
//printf("\n Inserting Intervals \n");
struct intv *tmp_ob;
tmp_ob = (struct intv *)malloc(sizeof(struct intv));
tmp_ob->x_min = intervals_y[s].x_min;
tmp_ob->x_max = intervals_y[s].x_max;
tmp_ob->y_min = intervals_y[s].y_min;
tmp_ob->y_max = intervals_y[s].y_max;
// printf("Interval y y_min %d \n", intervals_y[k].y_max);
insert_interval(itmp_ptr->inner_tree, intervals_y[s].y_min, intervals_y[s].y_max, tmp_ob);
}
}
if (itmp_ptr->right != NULL){
node_stack[stack_p++] = itmp_ptr->left;
node_stack[stack_p++] = itmp_ptr->right;
}
}
return seg_tree_1d;
}
