/* Returns non-zero on error. */
static int
reset_dircache(status_t *stats)
{
tree_free(stats->dirsize_cache);
stats->dirsize_cache = tree_create(0, 0);
return stats->dirsize_cache == NULL_TREE;
}
int main() {
TREE t1, t2, tree;
srand((unsigned int) time(NULL));
int i;
tree = tree_create(0, NULL, NULL);
tree_print_list(tree);
printf("\nTree depth : %d\n", tree_depth(tree));
printf("Tree is balanced : %d\n", tree_is_balanced(tree));
tree_add(tree, 1);
tree_print_list(tree);
printf("\nTree depth : %d\n", tree_depth(tree));
printf("Tree is balanced : %d\n", tree_is_balanced(tree));
tree_add(tree, 2);
tree_print_list(tree);
printf("\nTree depth : %d\n", tree_depth(tree));
printf("Tree is balanced : %d\n", tree_is_balanced(tree));
tree_add(tree, -2);
tree_print_list(tree);
printf("\nTree depth : %d\n", tree_depth(tree));
printf("Tree is balanced : %d\n", tree_is_balanced(tree));
tree_add(tree, -1);
tree_print_list(tree);
printf("\nTree depth : %d\n", tree_depth(tree));
printf("Tree is balanced : %d\n", tree_is_balanced(tree));
return 0;
}
/*
* Get elog status in the form of a TABLE
*/
TABLE elog_getstatus()
{
TABLE tab;
TREE *row;
int i;
char *purl;
/* create row */
row = tree_create();
tree_add(row, "severity", NULL);
tree_add(row, "route", NULL);
tree_add(row, "format", NULL);
/* create table and add rows to it, made from the severity table */
tab = table_create_a(elog_colnames);
for (i=0; i<ELOG_NSEVERITIES; i++) {
tree_find(row, "severity");
tree_put(row, elog_sevstring[i]);
tree_find(row, "route");
purl = xnstrdup( route_getpurl(elog_opendest[i].route) );
tree_put(row, purl);
table_freeondestroy(tab, purl);
tree_find(row, "format");
if (elog_opendest[i].format)
tree_put(row, elog_opendest[i].format);
else
tree_put(row, ELOG_DEFFORMAT);
table_addrow_alloc(tab, row);
}
tree_destroy(row);
return tab;
}
int
main(void)
{
struct Node *restrict root;
struct Node *restrict node;
const int exit_status = tree_create(&root,
20u);
if (exit_status == 0u) {
tree_print(root);
PRINT_IS_SORTED();
tree_invert(root);
tree_print(root);
PRINT_IS_SORTED();
printf("tree_length: %u\n", tree_length(root));
PRINT_NTH(0);
PRINT_NTH(-1);
PRINT_NTH(10);
PRINT_NTH(19);
PRINT_NTH(20);
tree_free(root);
} else {
puts("tree_create failed");
}
return exit_status;
}
void tasking_install(void) {
IRQ_OFF();
/* Install the pit callback, which is acting as a callback service: */
MOD_IOCTL("pit_driver", 1, (uintptr_t)"pit_switch_task", (uintptr_t)pit_switch_task);
/* Initialize the very first task, which is the main thread that was already running: */
current_task = main_task =
task_create((char*)"rootproc", 0, Kernel::CPU::read_reg(Kernel::CPU::eflags), (uint32_t)Kernel::Memory::Man::curr_dir->table_entries);
/* Initialize task list and tree: */
tasklist = list_create();
tasktree = tree_create();
tree_set_root(tasktree, main_task);
list_insert(tasklist, main_task);
tasking_enable(1); /* Allow tasking to work */
is_tasking_initialized = 1;
IRQ_RES(); /* Kickstart tasking */
/* Test tasking: */
task_t * t1 = task_create_and_run((char*)"task1", task1, current_task->regs->eflags, current_task->regs->cr3);
task_t * t2 = task_create_and_run((char*)"task2", task2, current_task->regs->eflags, current_task->regs->cr3);
task_set_ttl_mode(t1->pid, 0);
task_set_ttl_mode(t2->pid, 1);
task_set_ttl_fscale(t1, 1000);
task_set_ttl(t1, 80);
task_set_ttl(t2, 10);
}
int main()
{
struct BSTree* t;
printf("testing tree create...");
if ((t = tree_create()) == NULL)
goto fail;
printf("[ok]\n");
printf("testing insert...");
add(t,4);
add(t,2);
add(t,6);
add(t,1);
add(t,3);
add(t,5);
add(t,7);
printf("[ok]\n");
printf("testing search...");
if (!search(t,1) || !search(t,2) || !search(t,3) ||
!search(t,4) || !search(t,5) || !search(t,6) || !search(t,7))
goto fail;
if (search(t,8) || search(t,9))
goto fail;
printf("[ok]\n");
return 0;
fail:
printf("[failed]\n");
return -1;
}
struct nsgtk_treeview *nsgtk_treeview_create(unsigned int flags,
GtkWindow *window, GtkScrolledWindow *scrolled,
GtkDrawingArea *drawing_area)
{
struct nsgtk_treeview *tv;
assert(drawing_area != NULL);
tv = malloc(sizeof(struct nsgtk_treeview));
if (tv == NULL) {
LOG(("malloc failed"));
warn_user("NoMemory", 0);
return NULL;
}
tv->window = window;
tv->scrolled = scrolled;
tv->drawing_area = drawing_area;
tv->input_method = gtk_im_multicontext_new();
tv->tree = tree_create(flags, &nsgtk_tree_callbacks, tv);
tv->mouse_state = 0;
tv->mouse_pressed = false;
nsgtk_widget_override_background_color(GTK_WIDGET(drawing_area),
GTK_STATE_NORMAL,
0, 0xffff, 0xffff, 0xffff);
nsgtk_connect_draw_event(GTK_WIDGET(drawing_area), G_CALLBACK(nsgtk_tree_window_draw_event), tv->tree);
#define CONNECT(obj, sig, callback, ptr) \
g_signal_connect(G_OBJECT(obj), (sig), G_CALLBACK(callback), (ptr))
CONNECT(drawing_area, "button-press-event",
nsgtk_tree_window_button_press_event,
tv);
CONNECT(drawing_area, "button-release-event",
nsgtk_tree_window_button_release_event,
tv);
CONNECT(drawing_area, "motion-notify-event",
nsgtk_tree_window_motion_notify_event,
tv);
CONNECT(drawing_area, "key-press-event",
nsgtk_tree_window_keypress_event,
tv);
CONNECT(drawing_area, "key-release-event",
nsgtk_tree_window_keyrelease_event,
tv);
/* input method */
gtk_im_context_set_client_window(tv->input_method,
nsgtk_widget_get_window(GTK_WIDGET(tv->window)));
gtk_im_context_set_use_preedit(tv->input_method, FALSE);
/* input method signals */
CONNECT(tv->input_method, "commit",
nsgtk_tree_window_input_method_commit,
tv);
return tv;
}
static void
ensure_dirs_tree_exists(void)
{
if(dirs == NULL_TREE)
{
dirs = tree_create(1, 1);
}
}
ro_treeview *ro_treeview_create(wimp_w window, struct toolbar *toolbar,
struct ro_treeview_callbacks *callbacks, unsigned int flags)
{
ro_treeview *tv;
/* Claim memory for the treeview block, and create a tree. */
tv = malloc(sizeof(ro_treeview));
if (tv == NULL)
return NULL;
tv->w = window;
tv->tb = toolbar;
/* Set the tree redraw origin at a default 0,0 RO units. */
tv->origin.x = 0;
tv->origin.y = 0;
/* Set the tree size as 0,0 to indicate that we don't know. */
tv->size.x = 0;
tv->size.y = 0;
/* Set the tree window extent to 0,0, to indicate that we
* don't know. */
tv->extent.x = 0;
tv->extent.y = 0;
/* Set that there is no drag opperation at the moment */
tv->drag = TREE_NO_DRAG;
tv->tree = tree_create(flags, &ro_tree_callbacks, tv);
if (tv->tree == NULL) {
free(tv);
return NULL;
}
/* Record the callback info. */
tv->callbacks = callbacks;
/* Register wimp events to handle the supplied window. */
ro_gui_wimp_event_register_redraw_window(tv->w, ro_treeview_redraw);
ro_gui_wimp_event_register_scroll_window(tv->w, ro_treeview_scroll);
ro_gui_wimp_event_register_pointer_entering_window(tv->w,
ro_treeview_pointer_entering);
ro_gui_wimp_event_register_open_window(tv->w, ro_treeview_open);
ro_gui_wimp_event_register_mouse_click(tv->w, ro_treeview_mouse_click);
ro_gui_wimp_event_register_keypress(tv->w, ro_treeview_keypress);
ro_gui_wimp_event_set_user_data(tv->w, tv);
return tv;
}
void
load_color_scheme_colors(void)
{
if(dirs == NULL)
dirs = tree_create(1, 1);
load_color_pairs(DCOLOR_BASE, &cfg.cs);
load_color_pairs(LCOLOR_BASE, &lwin.cs);
load_color_pairs(RCOLOR_BASE, &rwin.cs);
}
int main()
{
ltree root, x, y;
printf("请输入根节点，0表示NULL:\n");
root = tree_create();
root->parent = NULL;
/*printf("最大的结点是：%d\n", tree_maximum(root)->data);
printf("最小的结点是：%d\n", tree_minimum(root)->data);
x = tree_search(root, 9);
printf("结点9的前驱结点是：%d\n", tree_predecessor(x)->data);
printf("结点9的后继结点是：%d\n", tree_successor(x)->data);
*/
/*y = (ltree)malloc(sizeof(tree));
y->data = 13;
y->lchild = y->rchild = y->parent = NULL;
tree_insert(root, y);
x = tree_search(root, 15);
printf("\n\n插入结点13后\n\n");
printf("结点15的前驱结点是：%d\n", tree_predecessor(x)->data);
printf("结点15的后继结点是：%d\n", tree_successor(x)->data);
x = tree_search(root, 13);
tree_delete(root, x);
x = tree_search(root, 15);
printf("\n\n删除结点13后\n\n");
printf("结点15的前驱结点是：%d\n", tree_predecessor(x)->data);
printf("结点15的后继结点是：%d\n", tree_successor(x)->data);
x = tree_search(root, 17);
tree_delete(root, x);
x = tree_search(root, 15);
printf("\n\n删除结点17后\n\n");
printf("结点15的前驱结点是：%d\n", tree_predecessor(x)->data);
printf("结点15的后继结点是：%d\n", tree_successor(x)->data);
x = tree_search(root, 18);
tree_delete(root, x);
x = tree_search(root, 15);
printf("\n\n删除结点18后\n\n");
printf("结点15的前驱结点是：%d\n", tree_predecessor(x)->data);
printf("结点15的后继结点是：%d\n", tree_successor(x)->data);
*/
system("pause");
exit(0);
}
struct _map * x8664_functions (uint64_t address, struct _map * memory)
{
struct _map * functions = map_create();
struct _tree * disassembled = tree_create();
x8664_functions_r(functions, disassembled, address, memory);
object_delete(disassembled);
return functions;
}
int tree_create(Node * node, const char * const _str)
{
static int inited = 0;
if (!inited) {
// se executa doar la primul apel
inited = 1;
str = _str;
}
/* intotdeauna `*str` trebuie sa arate
catre valoarea unui nod (litera sau $)
si nu catre o virgula sau paranteza,
de asemenea trebuie sa-si pastreze pozitia */
if (*str == '$') {
*node = NULL;
++str; // ca sa fim pe virgula sau
return 0; // paranteza inchisa
}
// avem litera
int rc = node_create(node, *str);
if (rc) // nu a putut fi creat
return rc;
// acum vedem ce se afla dupa
++str;
if (*str != '(')
// nu avem fii
return 0;
// deci avem fii
++str;
rc = tree_create(&(*node)->left, _str);
if (rc)
return rc;
// acum suntem pe virgula
++str;
rc = tree_create(&(*node)->right, _str);
if (rc)
return rc;
// acum suntem pe paranteza inchisa
++str; // acum nu mai suntem :]
return 0;
}
void create_tree(tree_t *tree, slab_t *slab, size_t entry_size,
int (*compare)(const int a, const int b))
{
slab->unit_size = entry_size;
slab->block_size = PAGE_SIZE;
slab->min_block = 1;
slab->max_block = tree_max_block(65536, PAGE_SIZE, entry_size);
slab->palloc = palloc;
slab->pfree = pfree;
slab_create(slab);
tree_create(tree, compare);
}
struct channel_connection *
i_silc_channel_connection_init(
struct gateway_connection *gwconn,
struct channel *channel,
struct event *event)
{
struct i_silc_channel_connection *silc_chconn =
i_new(struct i_silc_channel_connection, 1);
silc_chconn->name = i_strdup(channel->name);
silc_chconn->chconn.presences =
tree_create(default_pool, (tree_cmp_callback_t *)strcasecmp);
return &silc_chconn->chconn;
}
ltree tree_create(void)
{
ltree T;
int a;
scanf("%d", &a);
if (a == 0){
T = NULL;
}else{
T = (ltree)malloc(sizeof(tree));
T->data = a;
printf("\n请输入结点%d的左子结点:\n", T->data);
T->lchild = tree_create();
if (T->lchild != NULL)
T->lchild->parent = T;
printf("\n请输入结点%d的右子结点:\n", T->data);
T->rchild = tree_create();
if (T->rchild != NULL)
T->rchild->parent = T;
}
return T;
}
void tree_insert(Node tree, int key, void* value, int elementSize)
{
assert(tree);
Node current = tree;
if (key == current->key)
{
set_value(current, value, elementSize);
set_elementSize(current, elementSize);
return;
}
else if (key < current->key)
{
if (current->left)
{
tree_insert(current->left, key, value, elementSize);
}
else
{
set_left(current, tree_create(key, value, elementSize, NULL, NULL));
return;
}
}
else if (key > current->key)
{
if (current->right)
{
tree_insert(current->right, key, value, elementSize);
}
else
{
set_right(current, tree_create(key, value, elementSize, NULL, NULL));
return;
}
}
}
void partition_setup( workspace *w, int hp) {
int i, j;
for( i = 0; i < w->ntris; i++) {
//create tree from tri and add root
tree *node = tree_create( w, i, NULL, NULL, NULL, hp);
workspace_add_root( w, node);
//add leaf
workspace_add_leaf( w, w->roots[i]);
//set edge matrix
for( j = 0; j < 3; j++) {
edge_set( w->edges, w->tris[i]->p[j], w->tris[i]->p[(j+1)%3], w->roots[i]);
}
}
}
void init_testcase_random_data(void)
{
unsigned int seed = time(NULL);
int i;
tree = tree_create(cmp_int);
srandom(seed);
for( i = 0 ; i < RANDOM_ARRAY_SIZE ; i++ ) {
// Make sure the new element is unique.
do {
random_array[i] = random();
}
while( tree_find(tree, &random_array[i]) );
tree_insert(tree, &random_array[i], &random_array[i]);
}
}
int main()
{
struct BSTree* t;
printf("testing tree create...");
if ((t = tree_create()) == NULL)
goto fail;
printf("[ok]\n");
int arr[10], count, ref[10] = { 4, 2, 1, 3, 6, 5 };
int i;
printf("testing add/search...");
add(t,4);
add(t,2);
add(t,6);
add(t,1);
add(t,3);
add(t,5);
if (!search(t,1) || !search(t,2) || !search(t,3) ||
!search(t,4) || !search(t,5) || !search(t,6) )
goto fail;
if (search(t,8) || search(t,9))
goto fail;
printf("[ok]\n");
printf("testing get_preorder...");
get_preorder(t, arr, &count);
if (count != 6)
goto fail;
for (i = 0; i < 6; i++) {
if (arr[i] != ref[i])
goto fail;
}
printf("[ok]\n");
printf("testing count_non_leaf_nodes...");
if (count_non_leaf_nodes(t) != 3)
goto fail;
printf("[ok]\n");
return 0;
fail:
printf("[failed]\n");
return -1;
}
void
assoc_dir(const char *name, const char *dir)
{
union
{
char *s;
unsigned long long l;
}u = {
.s = strdup(name),
};
if(dirs == NULL)
dirs = tree_create(1, 1);
if(tree_set_data(dirs, dir, u.l) != 0)
free(u.s);
}
/*
* Initialises the elog class.
* Sets a default route for all severities (stderr) until it is
* configured otherwise.
* If cf is set, an attempt is made to configure elog using the cf_*
* routines and that tree.
* Relies on the route class, which must be initialised before calling.
* Note, that error raising functions can be used with out initialising
* elog, but they are all send to stderr. However, no configuration can
* take place with out initialising properly.
* Returns 1 for success, 0 for failure.
*/
int elog_init(int debug, /* debug flag */
char *binname, /* binary name, argv[0] */
CF_VALS cf /* configuration structure */)
{
int i;
if (elog_isinit)
return 1; /* already initialised */
elog_errors = route_open("stderr:", "default error", NULL, 0);
elog_debug = debug;
elog_origin = xnstrdup("");
elog_pid = getpid();
elog_pname = binname;
/* initialise to NULL */
for (i=0; i < ELOG_NSEVERITIES; i++) {
elog_opendest[i].purl = NULL;
elog_opendest[i].route = NULL;
elog_opendest[i].format = NULL;
}
elog_isinit++;
/* set a base default, which is to log everything */
if ( ! elog_setallroutes(elog_errors)) {
if (debug)
route_printf(elog_errors,
"elog_init() unable to set all routes to default");
return 0;
}
if ((elog_override = tree_create()) == NULL) {
if (debug)
elog_printf(ERROR, "elog_init() unable to create override tree");
return 0;
}
/* if supplied, configure from the cf tree */
if (cf)
elog_configure(cf);
return 1;
}
int main()
{
int array[] = {4,1,5,3,7,8,2,9,10,11};
/*
4
1 5
3 7 8 2
9 10 11
9 3 10 1 7 11 4 8 5 2
*/
int len = 10;
tree_t* tree_array = tree_create(array,len);//creat a tree.
link_t* root = DFS2LINK(tree_array);
print_link(root);
return 0;
}
CompileProject *compile_project_create (const char *path)
{
CompileProject *project = NULL;
if (!file_path_is_valid (path)) {
compile_print ("The path is not valid: %s\n", path);
error_code (FunctionCall, 1);
return NULL;
}
if (!(project = memory_create (sizeof (CompileProject)))) {
error_code (FunctionCall, 2);
return NULL;
}
if (!(project->topological = topological_create ())) {
compile_project_destroy (project);
error_code (FunctionCall, 3);
return NULL;
}
if (!(project->nodes = list_create ())) {
compile_project_destroy (project);
error_code (FunctionCall, 4);
return NULL;
}
if (!(project->directory_to_compile = tree_create ())) {
compile_project_destroy (project);
error_code (FunctionCall, 5);
return NULL;
}
if (!(project->directory = directory_open (path))) {
compile_print ("Failed to open the directory: %s\n", path);
compile_project_destroy (project);
error_code (FunctionCall, 6);
return NULL;
}
if (!string_begins_with (project->directory->name, "project.")) {
compile_print ("The directory name must begin with 'project.'.\n");
compile_project_destroy (project);
error_code (FunctionCall, 7);
return NULL;
}
project->sorted = NULL;
return project;
}
/*
* Callback for creating a new tree node.
*/
void* pdb_create_tree_node_cb(char* id, struct pdb_node_t* parent,
char** tok_arr) {
struct pdb_node_t* nptr;
struct binaryTree* tptr;
nptr = pdb_standard_create_node(id, parent, TREE_NODE_TYPE);
if (!nptr)
return NULL;
tptr = tree_create();
if (!tptr) {
ERROR("Unable to allocate memory for node data structure [tree].");
free(nptr);
return NULL;
}
nptr->data = (void*)tptr;
return nptr;
}
void run_tests(void)
{
Tree_node * tree = tree_create(42);
Tree_node * node = tree_insert_balanced(tree, 50);
my_assert(tree_find(tree, 50) == node);
Tree_node * node2 = tree_insert_balanced(tree, 30);
my_assert(tree_get_height(tree) == 2);
tree_insert_raw(node2, 5, LEFT);
my_assert(tree->left->left->data == 5);
tree_insert_balanced(tree, 30);
my_assert(tree->left->left->data == 5);
tree_delete_node(tree, LEFT);
my_assert(tree->left == NULL);
my_assert(tree_get_height(tree) == 2);
my_assert_conclude();
}
static bool recursively_flatten_libraries (CompileProject *project, Compile *compile)
{
TreeIterator *iterator;
Tree *append;
if (!(append = tree_create ())) {
compile_debug_allocate_memory ();
return false;
}
if (!(iterator = tree_iterator_create (compile->libraries))) {
compile_debug_allocate_memory ();
return false;
}
while (tree_iterator_next (iterator)) {
if (!recursively_flatten_libraries_inner (project,
compile,
(Directory *)iterator->key,
append)) {
tree_iterator_destroy (iterator);
tree_destroy (append);
return false;
}
}
tree_iterator_destroy (iterator);
if (!(iterator = tree_iterator_create (append))) {
compile_debug_allocate_memory ();
return false;
}
while (tree_iterator_next (iterator)) {
if (!tree_insert (compile->libraries, iterator->key, iterator->key)) {
tree_iterator_destroy (iterator);
tree_destroy (append);
compile_debug_operation_failed ();
return false;
}
}
tree_iterator_destroy (iterator);
tree_destroy (append);
return true;
}
/*
* Linux specific routines
*/
void plinnames_collect(TABLE tab) {
char *basename;
plinnames_sysfiles = tree_create();
plinnames_readalldir("/proc/sys", plinnames_sysfiles);
tree_traverse(plinnames_sysfiles) {
table_addemptyrow(tab);
table_replacecurrentcell(tab, "value",
tree_get(plinnames_sysfiles));
table_replacecurrentcell(tab, "name",
tree_getkey(plinnames_sysfiles));
basename = strrchr(tree_getkey(plinnames_sysfiles), '/');
if (basename)
basename++;
else
basename = tree_getkey(plinnames_sysfiles);
table_replacecurrentcell(tab, "vname", basename);
table_freeondestroy(tab, tree_getkey(plinnames_sysfiles));
table_freeondestroy(tab, tree_get(plinnames_sysfiles));
}
tree_destroy(plinnames_sysfiles);
}
/* use all but nocols, text version. tab and space used as delimiter */
void tableset_excludet(TABSET tset /* tableset instance */,
char *nocols /* whitespace separated string */)
{
char *mycols, *thiscol;
TREE *listcols;
mycols = xnstrdup(nocols);
tableset_freeondestroy(tset, mycols);
thiscol = strtok(mycols, " \t");
if (thiscol)
listcols = tree_create();
else
return; /* no cols to index */
while (thiscol) {
tree_add(listcols, thiscol, NULL);
thiscol = strtok(NULL, " \t");
}
tableset_exclude(tset, listcols);
tree_destroy(listcols);
return;
}
void testBSTree() {
printf("\nNow is Create Binary tree with node size %d >>>>>>>>>>\n", ARRAY_SIZE);
randomize_in_place(A, ARRAY_SIZE);
// randomize_maxnum(A, ARRAY_SIZE, ARRAY_SIZE);
print_array(A, ARRAY_SIZE);
startProfileTime();
tree_t * tree = tree_create(A, ARRAY_SIZE);
endProfileTime("Create Binary search tree ");
#if 0
printf("\nPre order traverse:\n");
tree_preorder_traverse(tree->root, my_treenode_key_traverse);
printf("\nPost order traverse:\n");
tree_postorder_traverse(tree->root, my_treenode_key_traverse);
printf("\nIn order traverse:\n");
tree_inorder_traverse(tree->root, my_treenode_key_traverse);
#endif
int key = 50;
startProfileTime();
treenode_t * search_result = tree_search(tree->root, key);
endProfileTime("Binary tree search");
if (search_result != get_nil_node()) {
printf("Found key:%d\n", key);
} else {
printf(" Not found key:%d\n", key);
}
tree_left_rotate(tree, search_result);
tree_right_rotate(tree, search_result);
traverse_no_recurise(tree->root, my_treenode_key_traverse);
treenode_t * max, * min;
max = tree_max(tree->root);
min = tree_min(tree->root);
printf("\nmax = %ld\n min = %ld\n", max->key, min->key);
treenode_t * bigger = tree_successor(search_result);
printf("successor = %ld\n", (bigger!=NULL) ? bigger->key : -1);
treenode_t * smaller = tree_predecessor(search_result);
printf("perdecessor = %ld\n", (smaller!=NULL) ? smaller->key : -1);
//Test delete:
treenode_t * deleted_node = RBTree_delete(tree, search_result);
// treenode_t * deleted_node = tree_delete(tree, search_result);
if (deleted_node)
printf("del %p, key=%ld from tree.\n", deleted_node, deleted_node->key);
tree_inorder_traverse(tree->root, my_treenode_key_traverse);
// traverse_no_recurise(tree->root, my_treenode_key_traverse);
int height = get_tree_height(tree->root);
printf("\nget tree h = %d\n", height);
tree_destroy(tree, NULL);
}
