void c_test_ins_tree_height(void) {
int sizeOfElement = sizeof(struct complexThing);
Tree tree = new_tree(sizeOfElement, navigateComplex, copyComplex, destroyComplex, NULL);
CU_ASSERT_TRUE(get_tree_height(tree) == 0);
Complex *c = malloc(sizeof(struct complexThing));
c->int_regular = 10;
c->int_pointer = malloc(sizeof(int));
*c->int_pointer = 15;
tree_insert(&tree, c, NULL);
CU_ASSERT_TRUE(get_tree_height(tree) == 1);
if (tree != NULL) {
destroy_tree(&tree);
}
if (c != NULL) {
if (c->int_pointer != NULL) {
free(c->int_pointer);
}
free(c);
}
}
void set_node_height(AVL* node) {
int lheight,rheight;
if (node == NULL)
return;
lheight = get_tree_height(node->lchild);
rheight = get_tree_height(node->rchild);
node->height = lheight - rheight;
}
int get_tree_height(AVL* node) {
int lheight,rheight,height;
if (node == NULL)
return -1;
lheight = get_tree_height(node->lchild);
rheight = get_tree_height(node->rchild);
height = lheight > rheight ? lheight : rheight;
return height + 1;
}
int get_tree_height(treenode_t *tree_root) {
if (tree_root == gNil || tree_root == NULL)
return -1;
int left_height = get_tree_height(tree_root->left_child);
int right_height = get_tree_height(tree_root->right_child);
if (left_height > right_height) {
return left_height + 1;
} else {
return right_height + 1;
}
// return MAX(get_tree_height(tree_root->left_child), get_tree_height(tree_root->right_child)) + 1;
}
void s_test_ins_tree_height(void) {
int sizeOfElement = sizeof(int);
Tree tree = new_tree(sizeOfElement, navigateItem, NULL, NULL, NULL);
CU_ASSERT_TRUE(get_tree_height(tree) == 0);
int obj = 10;
tree_insert(&tree, &obj, NULL);
CU_ASSERT_TRUE(get_tree_height(tree) == 1);
if (tree != NULL) {
destroy_tree(&tree);
}
}
void c_test_tree_delete(void) {
int items = 2;
int sizeOfElement = sizeof(struct complexThing);
Tree tree = new_tree(sizeOfElement, navigateComplex, copyComplex, destroyComplex, NULL);
for (int i = 1; i < items; i++) {
Complex *c = malloc(sizeof(struct complexThing));
c->int_regular = i;
c->int_pointer = malloc(sizeof(int));
*c->int_pointer = i+i;
tree_insert(&tree, c, NULL);
if (c != NULL) {
if (c->int_pointer != NULL) {
free(c->int_pointer);
}
free(c);
}
}
for (int d = items - 1; d >= 0; d--) {
tree_delete(&tree, &d, navigateSearchComplex);
}
CU_ASSERT_EQUAL(get_tree_height(tree), 0);
if (tree != NULL) {
destroy_tree(&tree);
}
}
void s_test_tree_balance(void) {
int items = 500;
int sizeOfElement = sizeof(int);
Tree tree = new_tree(sizeOfElement, navigateItem, NULL, NULL, NULL);
int b = 0;
double d = 1.44;
double f = 0.328;
double g = log2(items+2);
double res = (d*g) - f;
for (int i = 0; i < items; i++) {
b = i;
tree_insert(&tree, &b, NULL);
CU_ASSERT_TRUE(get_tree_height(tree) <= res);
}
//An AVL tree height should be strictly lower than 1.44log2(n+2)-0.328 where n = the number of items.
//printTest(&tree, printInt);
if (tree != NULL) {
destroy_tree(&tree);
}
}
void c_test_tree_balance(void) {
int items = 100;
int sizeOfElement = sizeof(struct complexThing);
Tree tree = new_tree(sizeOfElement, navigateComplex, copyComplex, destroyComplex, NULL);
double d = 1.44;
double f = 0.328;
double g = log2(items+2);
double res = (d*g) - f;
for (int i = 1; i < items; i++) {
Complex *c = malloc(sizeof(struct complexThing));
c->int_regular = i;
c->int_pointer = malloc(sizeof(int));
*c->int_pointer = i+i;
tree_insert(&tree, c, NULL);
//An AVL tree height should be strictly lower than 1.44log2(n+2)-0.328 where n = the number of items.
CU_ASSERT_TRUE(get_tree_height(tree) <= res);
if (c != NULL) {
if (c->int_pointer != NULL) {
free(c->int_pointer);
}
free(c);
}
}
if (tree != NULL) {
destroy_tree(&tree);
}
}
void s_test_tree_delete(void) {
int items = 500;
int sizeOfElement = sizeof(int);
Tree tree = new_tree(sizeOfElement, navigateItem, NULL, NULL, NULL);
//tree_insert(&tree, &find, NULL);
for (int i = 1; i < items; i++) {
int o = i;
tree_insert(&tree, &o, NULL);
}
for (int d = items - 1; d >= 0; d--) {
tree_delete(&tree, &d, NULL);
}
CU_ASSERT_EQUAL(get_tree_height(tree), 0);
if (tree != NULL) {
destroy_tree(&tree);
}
}
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);
}
int compute_tree_bf(AVLTree tree)
{
return get_tree_height(tree->left) - get_tree_height(tree->right);
}
int compute_tree_height(AVLTree tree)
{
return get_max(get_tree_height(tree->left),
get_tree_height(tree->right)) + 1;
}
int mainTree(){
int i;
BinTree * tree = initBinTree();
if(tree->size == 0){
/*
insertAsRoot(tree,16);
insertAsLC(10,root(tree));
insertAsRC(25,root(tree));
insertAsLC(19,root(tree)->rc);
insertAsRC(28,root(tree)->rc);
insertAsLC(5,root(tree)->lc);
insertAsRC(11,root(tree)->lc);
//insertNode(tree,3);
*/
/*insertNode(tree,16);
insertNode(tree,10);
insertNode(tree,25);
insertNode(tree,19);
insertNode(tree,28);
insertNode(tree,5);
insertNode(tree,11);
insertNode(tree,4);
insertNode(tree,33);
insertNodeAVL(36,tree);
insertNodeAVL(38,tree);
insertNodeAVL(39,tree);
insertNodeAVL(40,tree);
insertNodeAVL(41,tree);
*/
/*
insertNodeAVL(3,tree);
insertNodeAVL(5,tree);
insertNodeAVL(11,tree);
insertNodeAVL(16,tree);
insertNodeAVL(19,tree);
insertNodeAVL(25,tree);
insertNodeAVL(28,tree);
insertNodeAVL(33,tree);
insertNodeAVL(36,tree);
insertNodeAVL(39,tree);
insertNodeAVL(41,tree);
insertNodeAVL(43,tree);
deleteBinNode(tree,28);
deleteBinNode(tree,5);
deleteBinNode(tree,25);
deleteBinNode(tree,3);
deleteBinNode(tree,33); */
for(i = 1 ; i < 10 ; i++){
insertNodeAVL(i,tree);
}
}
if(tree->size!=0){
printf("根节点：%d \n" , root(tree)->data);
printf("高度： %d\n",get_tree_height(root(tree)));
printf("\n中序遍历---------------\n");
travIn_R(root(tree));
//printf("\n %d ",searchIn(root(tree),11)->data);
//printf("\n %d ", getMax(root(tree))->data);
//printf("\n %d ", getMin(root(tree))->data);
printf("\n");
}
for(i = 1 ;i < 8 ; i++)
deleteBinNode(tree,i);
//deleteNodeAVL(tree , i);
if(tree->size!=0){
printf("根节点：%d \n" , root(tree)->data);
printf("高度： %d\n",get_tree_height(root(tree)));
printf("\n中序遍历---------------\n");
travIn_R(root(tree));
}
/*
if(tree->size == 0){
insertAsRoot(tree,'A');
insertAsLC('B',root(tree));
insertAsRC('E',root(tree));
insertAsRC('G',root(tree)->rc);
insertAsLC('F',root(tree)->rc);
insertAsLC('C',root(tree)->lc);
insertAsRC('D',root(tree)->lc);
}
if(tree->size!=0){
printf("高度： %d\n",getTreeHeight(tree));
printf("高度： %d\n",get_tree_height(root(tree)));
printf("节点数目：%d\n",getBinNodeSize(root(tree)));
printf("前序遍历---------------\n");
travPre(root(tree));
printf("\n");
travPre_I1(root(tree));
printf("\n");
travPre_I2(root(tree));
printf("\n中序遍历---------------\n");
travIn_R(root(tree));
printf("\n");
travIn_I1(root(tree));
printf("\n层次遍历---------------\n");
traveLevel(root(tree));
printf("\n叶子节点数目 %d \n ",getLeafNum(root(tree)));
//printf("\n%c",search(root(tree),'C')->data);
} */
return 0;
}
