int main(){
Rbt_tree_link a = rbt_create();
Rbtlink it;
srand(time(NULL));
puts("Inserting...");
for(i=0;i<N;i++) {
num[i] = rand() % N;
rbt_insert(a,num[i]);
}
printf("rbt_size: %d\n",rbt_size(a));
printf("min value:%d max value:%d\n",rbt_item(rbt_minimum(a)),rbt_item(rbt_maximum(a)));
puts("Doing assert...");
rbt_assert(a);
puts("Traversing (inorder)...");
rbt_inorder(a,func);
for(i=0; i < N; i++)
rbt_search(a, i);
puts("Traversing (from max to min)...");
it = rbt_maximum(a);
for(i = rbt_size(a)-1; i >= 0; i--) {
assert(n[i] == rbt_item(it));
it = rbt_predecessor(it);
}
printf("rbt_size: %d\n",rbt_size(a));
puts("Deleting all values...");
int i = 0;
for (i = 0; i < N; ++i) {
printf("%d deleted\r", num[i]);
rbt_delete(a, num[i]);
}
puts("\nDestroying rbt..");
rbt_destroy(a);
puts("OK!");
return 0;
}
/************************************************************************
Merge the node from dst into src. Return the number of nodes merged.
Delete the nodes from src after copying node to dst. As a side effect
the duplicates will be left untouched in the src.
@return no. of recs merged */
UNIV_INTERN
ulint
rbt_merge_uniq_destructive(
/*=======================*/
ib_rbt_t* dst, /*!< in: dst rb tree */
ib_rbt_t* src) /*!< in: src rb tree */
{
ib_rbt_bound_t parent;
ib_rbt_node_t* src_node;
ulint old_size = rbt_size(dst);
if (rbt_empty(src) || dst == src) {
return(0);
}
for (src_node = (ib_rbt_node_t*) rbt_first(src); src_node; /* */) {
ib_rbt_node_t* prev = src_node;
src_node = (ib_rbt_node_t*)rbt_next(src, prev);
/* Skip duplicates. */
if (rbt_search(dst, &parent, prev->value) != 0) {
/* Remove and reset the node but preserve
the node (data) value. */
rbt_remove_node_and_rebalance(src, prev);
/* The nil should be taken from the dst tree. */
prev->parent = prev->left = prev->right = dst->nil;
rbt_tree_add_child(dst, &parent, prev);
rbt_balance_tree(dst, prev);
++dst->n_nodes;
}
}
#if defined(IB_RBT_TESTING)
ut_a(rbt_validate(dst));
ut_a(rbt_validate(src));
#endif
return(rbt_size(dst) - old_size);
}
/**************************************************************************
*
* Debugging Support & Misc "cold" functions
*
**************************************************************************
*/
const lm_status_t*
lm_get_status(void) {
if (!alloc_info)
return NULL;
lm_status_t* s = (lm_status_t *)MYMALLOC(sizeof(lm_status_t));
s->first_page = alloc_info->first_page;
s->page_num = alloc_info->page_num;
s->idx_to_id = alloc_info->idx_2_id_adj;
s->alloc_blk_num = 0;
s->free_blk_num = 0;
s->free_blk_info = NULL;
s->alloc_blk_info = NULL;
rb_tree_t* rbt = &alloc_info->alloc_blks;
int alloc_blk_num = rbt_size(rbt);
/* Populate allocated block info */
if (alloc_blk_num) {
block_info_t* ai;
ai = (block_info_t*)MYMALLOC(sizeof(block_info_t) * alloc_blk_num);
rb_iter_t iter, iter_e;
int idx = 0;
for (iter = rbt_iter_begin(rbt), iter_e = rbt_iter_end(rbt);
iter != iter_e;
iter = rbt_iter_inc(rbt, iter)) {
rb_node_t* blk = rbt_iter_deref(iter);
ai[idx].page_idx = blk->key;
ai[idx].size = blk->value;
ai[idx].order = alloc_info->page_info[blk->key].order;
idx++;
}
s->alloc_blk_info = ai;
s->alloc_blk_num = idx;
}
/* Populate free block info */
int free_blk_num = 0;
int i, e;
for (i = 0, e = alloc_info->max_order; i <= e; i++) {
free_blk_num += rbt_size(alloc_info->free_blks + i);
}
if (free_blk_num) {
block_info_t* fi;
fi = (block_info_t*)MYMALLOC(sizeof(block_info_t) * free_blk_num);
int idx = 0;
int page_size_log2 = alloc_info->page_size_log2;
for (i = 0, e = alloc_info->max_order; i <= e; i++) {
rb_tree_t* rbt = alloc_info->free_blks + i;
rb_iter_t iter, iter_e;
for (iter = rbt_iter_begin(rbt), iter_e = rbt_iter_end(rbt);
iter != iter_e;
iter = rbt_iter_inc(rbt, iter)) {
rb_node_t* nd = rbt_iter_deref(iter);
fi[idx].page_idx = nd->key;
fi[idx].order = alloc_info->page_info[nd->key].order;
fi[idx].size = (1 << fi[idx].order) << page_size_log2;
idx++;
}
}
ASSERT(idx == free_blk_num);
s->free_blk_info = fi;
s->free_blk_num = idx;
}
return s;
}
