static void test_remove_node (void) { GtkRBTree *tree; tree = create_rbtree (3, 16, g_test_thorough ()); while (tree->root->count > 1) { GtkRBTree *find_tree; GtkRBNode *find_node; guint i; i = g_test_rand_int_range (0, tree->root->total_count); if (!_gtk_rbtree_find_index (tree, i, &find_tree, &find_node)) { /* We search an available index, so we mustn't fail. */ g_assert_not_reached (); } _gtk_rbtree_test (find_tree); if (find_tree->root->count == 1) { _gtk_rbtree_remove (find_tree); } else _gtk_rbtree_remove_node (find_tree, find_node); _gtk_rbtree_test (tree); } _gtk_rbtree_free (tree); }
static void test_create (void) { GtkRBTree *tree; tree = create_rbtree (5, 5, TRUE); _gtk_rbtree_free (tree); }
RBTREE copy_rbtree ( const RBTREE tree, void * (*copyvalue)(const void *) ){ assert(NULL!=tree); RBTREE newtree = create_rbtree(tree->compfun,tree->copykey,tree->freekey); if (NULL!=tree->root){ newtree->root = copy_rbnode_sub(tree->root,tree->copykey,copyvalue); newtree->root->parent = NULL; } return newtree; }
int main ( int argc, char * argv[]) { unsigned int seed,nelt,keylen; if ( argc!=4){ printf ("Usage: rbtree seed nelt keylen\n"); return EXIT_FAILURE; } sscanf(argv[1],"%u",&seed); srandom(seed); sscanf(argv[2],"%u",&nelt); sscanf(argv[3],"%u",&keylen); RBTREE tree = create_rbtree(lexo,strcopykey,strfreekey); char ** keys = random_keys(nelt,keylen); printf ("Inserting elements\n"); for ( int i=0 ; i<nelt ; i++){ printf ("\tinserting %s\n",keys[i]); insertelt_rbtree(tree,keys[i],"a"); check_rbtree(tree); } unsigned int ntree_elt = nmemb_rbtree(tree); printf ("Tree contains %u elements in total\n",ntree_elt); assert(ntree_elt<=nelt); printf ("Copying tree\n"); RBTREE tree2 = copy_rbtree(tree,strcopykey); check_rbtree(tree2); printf("Freeing copied tree\n"); free_rbtree(tree2,free); printf("Printing tree\n"); unsafemap_rbtree (tree,print_node); printf("Iterating through tree\n"); unsigned int iter_count = 0; for ( RBITER iter = iter_rbtree(tree) ; next_rbtree(iter) ; ){ const char * key = (const char *) iterkey_rbtree(iter); printf("\tfound %s\n",key); iter_count++; } assert(iter_count==ntree_elt); printf ("Removing elements\n"); unsigned int * rperm = random_permutation(nelt); fputs("Permutation: ",stdout); print_rperm(rperm,nelt); for ( int i=0 ; i<nelt ; i++){ printf("\tremoving %s\n",keys[rperm[i]]); removeelt_rbtree(tree,keys[rperm[i]]); check_rbtree(tree); } assert(nmemb_rbtree(tree)==0); free_rbtree(tree,free); }
//---------------rbtree debug------------------------------------// int rbtree_test(void) { int i, j, len, slice, ret; struct timeval tv; struct rbnode node, *pn = NULL; struct ttlnode *tn = NULL; struct rbtree *rbt = NULL; rbt = create_rbtree(rbt_comp_ttl_gt, NULL); if (rbt == NULL) dns_error(0, "create rbtree"); node = rbt->nil; //nil slice = 8000000; //for(i = 0;i < n;i ++) //{ for (j = 0; j < slice; j++) { len = random() % 30; tn = malloc(sizeof(struct ttlnode) + len); if (tn == NULL) printf("oom\n"); tn->exp = j; for (i = 0; i < len; i++) tn->data[i] = 'a' + i; node.key = tn; ret = insert_node(rbt, &node); if (ret != 0) printf("insert error\n"); } printf("insert all\n"); sleep(2); for (j = 0; j < slice; j++) { pn = min_node(rbt); if (pn != NULL) { tn = delete_node(rbt, pn); free(tn); } else printf("error\n"); } printf("delete all\n"); sleep(5); //} if (free_rbtree(rbt) != 0) dns_error(0, "free"); //get_time_usage(&tv,0); return 0; }
void create_tree (TREE * tree) { const char *tmp; int old_sp; assert(NULL==tree->tree); tmp = tree->tstring; old_sp = tree->n_sp; tree->n_sp = 0; tree->leaves = create_rbtree(lexo,strcopykey,strfreekey); // Bifurcating tree is upper bound on number of branches tree->branches = calloc(2*old_sp-3,sizeof(NODE *)); tree->tree = create_tree_sub (&tmp, NULL, tree); tree->tree->bnumber = tree->n_br; assert(old_sp == tree->n_sp); CheckIsTree (tree); }
static struct server * server_init(void) { struct server *s = malloc(sizeof(struct server)); if (s == NULL) dns_error(0, "out of memory in server_init"); s->nfetcher = FETCHER_NUM; s->nquizzer = QUIZZER_NUM; s->authors = NULL; s->fetchers = NULL; s->pkg = 0; pthread_spin_init(&s->eventlist.lock, 0); //pthread_mutex_init(&s->lock,NULL); s->eventlist.head = NULL; if ((s->ludp = create_listen_ports(SERVER_PORT, UDP, (uchar *)SRV_ADDR)) < 0) dns_error(0, "can not open udp"); set_sock_buff(s->ludp, 10); if ((s->ltcp = create_listen_ports(SERVER_PORT, TCP, (uchar *)SRV_ADDR)) < 0) dns_error(0, "can not open tcp"); s->datasets = htable_create(NULL, dict_comp_str_equ, HASH_TABLE_SIZE, MULTI_HASH); if (s->datasets == NULL) dns_error(0, "htable create"); s->forward = htable_create(NULL, dict_comp_str_equ, 1024, 1); if (s->forward == NULL) dns_error(0, "create forward"); s->qlist = htable_create(NULL, dict_comp_str_equ, QLIST_TABLE_SIZE, 1); if (s->qlist == NULL) dns_error(0, "create qlist"); s->ttlexp = create_rbtree(rbt_comp_ttl_gt, NULL); if (s->ttlexp == NULL) dns_error(0, "create ttl tree"); s->recordsindb = 0; s->refreshflag = 0; s->lastrefresh = global_now; s->is_forward = 0; return s; }
TREE *CloneTree (TREE * tree) { TREE *tree_new; CheckIsTree (tree); tree_new = calloc (1, sizeof (TREE)); if (NULL == tree_new) return NULL; tree_new->n_sp = tree->n_sp; tree_new->n_br = tree->n_br; tree_new->tstring = malloc ((1 + strlen (tree->tstring)) * sizeof (char)); strcpy (tree_new->tstring, tree->tstring); tree_new->leaves = create_rbtree(lexo,strcopykey,strfreekey); tree_new->branches = calloc(tree->n_br,sizeof(NODE *)); tree_new->tree = CloneTree_sub (tree->tree, NULL, tree, tree_new); CheckIsTree (tree_new); return tree_new; }
int main() { mmnode ns[10]; int i = 0; for( ; i < 10; ++i) { ns[i].key = i+1; ns[i].base.key = &ns[i].key; } rbtree_t rb = create_rbtree(_comp); for(i = 0; i < 10; ++i) rbtree_insert(rb,(rbnode*)&ns[i]); { mmnode *n = (mmnode*)rbtree_first(rb); while(n) { printf("%d\n",n->key); n = (mmnode*)rbnode_next((rbnode*)n); } } rbtree_check_vaild(rb); mmnode *succ = (mmnode*)rbtree_remove(rb,(void*)&ns[3].key); printf("%d\n",succ->key); rbtree_check_vaild(rb); { mmnode *n = (mmnode*)rbtree_first(rb); while(n) { printf("%d\n",n->key); n = (mmnode*)rbnode_next((rbnode*)n); } } { mmnode *n = (mmnode*)rbtree_last(rb); while(n) { printf("%d\n",n->key); n = (mmnode*)rbnode_pre((rbnode*)n); } } /* map_t m = MAP_CREATE(int,int,_comp,NULL); MAP_INSERT(int,int,m,1,1); MAP_INSERT(int,int,m,2,2); MAP_INSERT(int,int,m,3,3); MAP_INSERT(int,int,m,4,4); MAP_INSERT(int,int,m,5,5); MAP_INSERT(int,int,m,6,6); MAP_INSERT(int,int,m,7,7); MAP_INSERT(int,int,m,8,8); MAP_INSERT(int,int,m,9,9); MAP_INSERT(int,int,m,10,10); printf("------test iter------\n"); map_iter it = map_begin(m); map_iter end = map_end(m); for( ; !IT_EQ(it,end); IT_NEXT(it)) printf("%d\n",IT_GET_VAL(int,it)); printf("------test remove 4------\n"); MAP_REMOVE(int,m,4); it = map_begin(m); end = map_end(m); for( ; !IT_EQ(it,end); IT_NEXT(it)) printf("%d\n",IT_GET_VAL(int,it)); */ return 0; }