int
btree_depth(const btree tree)
{
int left_depth, right_depth;
int max_depth;
if (!tree) {
return 0;
}
/* traverse left subtree */
if (tree->left) {
left_depth = btree_depth(tree->left);
} else {
left_depth = 0;
}
/* traverse right subtree */
if (tree->right) {
right_depth = btree_depth(tree->right);
} else {
right_depth = 0;
}
/* colon three-meta expression shoulde be careful */
max_depth = left_depth > right_depth ? left_depth + 1: right_depth + 1;
return max_depth;
}
//二元树的深度。
//调用之前，设置parent_depth=-1
int btree_depth(btree_node<int> *p_node, int parent_depth)
{
if (p_node == NULL)
return parent_depth;
if (p_node->mp_left == NULL && p_node->mp_right == NULL)
return parent_depth + 1;
int left_child_depth = p_node->mp_left? btree_depth(p_node->mp_left, parent_depth+1): -1;
int right_child_depth = p_node->mp_right? btree_depth(p_node->mp_right, parent_depth+1): -1;
return std::max<int>(left_child_depth, right_child_depth);
}
int test_insert() {
BTree *tree;
BTree *find;
int depth;
tree = NULL;
printf("The numbers should be in ascending order.\n");
btree_insert(&tree, "5");
btree_insert(&tree, "1");
btree_insert(&tree, "6");
btree_insert(&tree, "9");
btree_insert(&tree, "0");
btree_insert(&tree, "4");
btree_insert(&tree, "3");
btree_insert(&tree, "8");
btree_insert(&tree, "2");
btree_insert(&tree, "7");
btree_insert(&tree, "4");
/*print_preorder(tree);*/
printLevelOrder(tree,5);
depth = btree_depth(tree);
printf("d_single:%d\n", depth);
find = btree_find(tree, "Z");
/*print_preorder(find);*/
if(find == NULL){
printf("Not found.\n");
}else{
printLevelOrder(find,5);
}
btree_free(tree);
return 0;
}
int main() {
BTree *tree;
BTree *find;
int depth;
char *array[11];
array[0] = "5";
array[1] = "1";
array[2] = "6";
array[3] = "9";
array[4] = "0";
array[5] = "4";
array[6] = "3";
array[7] = "8";
array[8] = "2";
array[9] = "7";
array[10] = "4";
tree = array_to_btree(array);
/*print_preorder(tree);*/
printLevelOrder(tree,5);
depth = btree_depth(tree);
printf("d_array:%d\n", depth);
find = btree_find(tree, "A");
/*print_preorder(find);*/
if(find == NULL){
printf("Not found.\n");
}else{
printLevelOrder(find,5);
}
btree_free(tree);
test_insert();
return 0;
}
static int btree_depth(BTREE_NODE *x)
{
int l, r;
if (x == NULL) {
return (0);
}
l = btree_depth(x->left);
r = btree_depth(x->right);
if (l > r) {
return (l + 1);
} else {
return (r + 1);
}
}
static int
btree_depth(btree_node_t *x)
{
int l, r;
if (x == NULL) {
return 0;
}
l = btree_depth(x->left);
r = btree_depth(x->right);
if (l > r) {
return l + 1;
} else {
return r + 1;
}
}
/**
* btree_depth - Calculates the depth
* of a given binary tree
* @*tree: contains the structure address
*/
int btree_depth(BTree *tree)
{
int right_node;
int left_node;
/*Checking if the tree is empty*/
if (tree == NULL)
{
return (0);
}
/*using recursion to count the depth on each brach*/
right_node = btree_depth(tree->right);
left_node = btree_depth(tree->left);
/*returning only the highest number of nodes*/
if (right_node > left_node)
{
return (right_node + 1);
}
return (left_node + 1);
}
/**
* btree_depth - Calculates the depth of a binary tree
*
* @tree: Pointer to root leaf of a binary tree
*
* Description: Receives pointer to root node of a binary tree. If pointer
* points to NULL, the tree is empty. Otherwise call the function recursively
* and add 1 for the current leag
*/
int btree_depth(BTree *tree)
{
int ldepth;
int rdepth;
if (tree == NULL)
{
return 0;
}
else
{
ldepth = btree_depth(tree->left);
rdepth = btree_depth(tree->right);
}
if (ldepth > rdepth)
{
return (ldepth + 1);
}
else
{
return (rdepth + 1);
}
return 0;
}
int
main()
{
btree_t *b;
uint32_t i, *x;
uint32_t v[] = {15, 5, 16, 3, 12, 20, 10, 13, 18, 23, 6, 7};
uint32_t nv = sizeof(v) / sizeof(v[0]);
btree_create(&b);
for(i = 0; i < nv; i++) {
x = (uint32_t*)xmalloc(sizeof(uint32_t));
*x = (uint32_t)random();
if (btree_add(b, v[i], (void*)x) != TRUE) {
printf("Fail Add %lu %lu\n", v[i], *x);
}
}
printf("depth %d\n", btree_depth(b->root));
btree_dump(b);
sleep(3);
btree_remove(b, 5, (void*)&x);
btree_dump(b);
sleep(3);
btree_remove(b, 16, (void*)&x);
btree_dump(b);
sleep(3);
btree_remove(b, 13, (void*)&x);
btree_dump(b);
while (btree_get_root_key(b, &i)) {
if (btree_remove(b, i, (void*)&x) == FALSE) {
fprintf(stderr, "Failed to remove %lu\n", i);
}
btree_dump(b);
sleep(1);
}
if (btree_destroy(&b) == FALSE) {
printf("Failed to destroy \n");
}
return 0;
}
int main(int argc, char **argv)
{
printf("-------------------------------------------------\n");
printf("starts to have a test of binary tree.\n");
printf("-------------------------------------------------\n");
btree tree = btree_create();
btree_node *dataone = btree_node_make("hello");
btree_insert_child_tree(tree, PRE_ORDER, dataone);
btree_node *datatwo = btree_node_make("World");
btree_insert_child_tree(dataone, PRE_ORDER, datatwo);
btree_traverse(tree, IN_ORDER, btree_node_print);
printf("now length of tree is %d\n", btree_depth(tree));
printf("-------------------------------------------------\n");
printf("test is over, everything is gone be alright.\n");
printf("-------------------------------------------------\n");
printf("\n");
return EXIT_SUCCESS;
}
btree_dtable::page_stack::page_stack(int fd, size_t key_count)
: fd(fd), next_file_page(1), filled(false), flushed(false)
{
depth = btree_depth(key_count);
assert(depth > 0);
pages = new page[depth];
next_depth = depth - 1;
header.magic = BTREE_DTABLE_MAGIC;
header.version = BTREE_DTABLE_VERSION;
header.page_size = BTREE_PAGE_SIZE;
header.pageno_size = BTREE_PAGENO_SIZE;
header.key_size = BTREE_KEY_SIZE;
header.index_size = BTREE_INDEX_SIZE;
header.key_type = 1; /* 1 -> uint32 */
header.key_count = key_count;
header.depth = depth;
/* to be filled in later */
header.root_page = 0;
header.last_full = 0;
}
int acl_btree_depth(ACL_BTREE *tree)
{
return (btree_depth(tree->root));
}
