int AvlNode::tree_height(AvlIndex tree) { if (tree) return 0; int lh = tree_height(AVLNODE(tree)->left); int rh = tree_height(AVLNODE(tree)->right); return 1 + MAX(lh, rh); }
int tree_height(tree *btree) { int left, right; if(!btree) return 0; left = tree_height(btree->left); right = tree_height(btree->right); if(left > right) return left+1; else return right+1; }
int tree_height (struct Node * tree) { if (tree == NULL) return 0; else { int ret1 = 1, ret2 = 1; if (tree->left != NULL) ret1 += tree_height(tree->left); if (tree->right != NULL) ret2 += tree_height(tree->right); return (ret1 > ret2)?ret1:ret2; } };
size_t tree_height(struct tree_root *root) { size_t hl, hr; if (root == NIL) return 0; hl = tree_height(root->left); hr = tree_height(root->right); if (hl > hr) return hl + 1; return hr + 1; }
void main() { int a[30]; int count = 0; struct tree_node *root = NULL; root = tree_add_node(1); root->left = tree_add_node(2); root->right = tree_add_node(3); root->left->left = tree_add_node(4); root->left->left->right = tree_add_node(10); root->left->right = tree_add_node(5); root->left->right->right = tree_add_node(50); root->right->left = tree_add_node(6); root->right->right = tree_add_node(7); struct tree_node *root2 = NULL; root2 = tree_add_node(1); root2->left = tree_add_node(2); root2->right = tree_add_node(3); root2->left->left = tree_add_node(4); root2->left->left->right = tree_add_node(10); root2->left->right = tree_add_node(5); root2->right->left = tree_add_node(6); root2->right->right = tree_add_node(7); //tree_preorder_print(root); tree_postorder_iterative_print(root); printf("Tree size(9) = %d\n", tree_size(root)); printf("Height is %d\n", tree_height(root)); printf("Check identical for same tree = %d\n", tree_check_identical(root, root2)); tree_mirror(root); tree_postorder_iterative_print(root); tree_r2l_path(root, a, count); }
void map_dump(map m) { int height = tree_height(m->root); int width = (2 << (height-1)) - 1; /* width = 2^height - 1*/ // printf("tree height: %d\n", height); // printf("tree width: %d\n", width); int array[height][width]; int i, j; // reset array for(j = 0 ; j < height ; j++) for(i = 0 ; i < width ; i++) array[j][i] = -1; // traverse tree and mark nodes if(m->root != NULL) tree_traverse_and_mark(m,m->root,height,(int*)array,0,0); // dump array for(j = 0 ; j < height ; j++) { printf("|"); for(i = 0 ; i < width ; i++) { if(array[j][i] < 0) printf(" "); else printf("%.2d",array[j][i]); } printf("|\n"); } }
int tree_height(nwk_node* n_node) { int i, max = 0; if (n_node) { if (tg_size(n_node->children)) { for (i = 0; i < (tg_size(n_node->children)); i++) { if (tree_height(n_node->children[i]) > max) { max = tree_height(n_node->children[i]); } } } else { return n_node->height; } return max; } return 0; }
int main() { MemoryPool *pool = memory_pool_init(sizeof(int)*100); int values[] = {1, 2, 3, 4, 5, 6, 7}; BinarySearchTree *tree = construct_minimal_height_tree( values, sizeof(values)/sizeof(int), pool); assert(3 == tree_height(tree)); memory_pool_free(pool); return 0; }
int tree_balanced (struct Node * tree) { if (tree == NULL) return 1; else if (tree_balanced(tree->left) && tree_balanced(tree->right) && ((tree_height(tree->left) - tree_height(tree->right)) <= 1) && ((tree_height(tree->left) - tree_height(tree->right)) >= -1)) return 1; else return 0; }
void print_binary_tree(const Node *const pt_to_node) { if (!pt_to_node) { putchar('\n'); return; } const int height = tree_height(pt_to_node); if (height == 0) print_value(pt_to_node->value), putchar('\n'); else print_subtree(pt_to_node, height, 0); }
int tree_height(BINNODE root) { int left_height=0,right_height=0; if(root!=NULL) { if(root->left==NULL&&root->right==NULL) return 0; else { left_height=tree_height(root->left); right_height=tree_height(root->right); //Finding the maximum height of subtrees return 1 + (left_height>right_height?left_height:right_height); } } else return 0; }
//트리 높이 구하는 함수 //트리노드를 인자로 받음 int tree_height(TreeNode *root) { //트리 전체의 높이 int height=0; //루트노드의 좌, 우 서브트리의 높이 int l, r; //루트노드가 없으면 0 반환 if(root==NULL) return 0; //루트노드의 좌측 서브트리 높이 저장 l=tree_height(root->left); //루트노드의 우측 서브트리 높이 저장 r=tree_height(root->right); //루트노드의 좌/우 서브트리 중에서 높이가 높은 값 추출 후 루트 자신의 높이인 1을 더함 height=(l>r?l:r)+1; //총 높이를 반환 return height; }
int main (int argc, char **argv) { flux_t h; uint32_t rank, n; int k; if (!(h = flux_open (NULL, 0))) err_exit ("flux_open"); if (flux_get_rank (h, &rank) < 0) err_exit ("flux_get_rank"); if (flux_get_size (h, &n) < 0) err_exit ("flux_get_size"); if (flux_get_arity (h, &k) < 0) err_exit ("flux_get_arity"); printf ("height of %d-ary tree of size %" PRIu32 ": %d\n", k, n, tree_height (n, k)); printf ("height of %d-ary at rank %" PRIu32 ": %d\n", k, rank, tree_height (rank + 1, k)); flux_close (h); return (0); }
int main() { char msg[] = " deadbeef"; binary_tree_t t = create_tree(msg, 8); printf("%d", tree_height(t)); sep; preorder_traversal(t, print_node); sep; postorder_traversal(t, print_node); sep; inorder_traversal(t, print_node); return 0; }
std::size_t BST<Item,Key>::height() const{ return tree_height(root); }
/* * Tests: add and remove */ static void run_tests(rba_buffer_t *b) { uint32_t i, h, n; check_tree(b); init_tests(); // add all power products n = NUM_TESTS; for (i=0; i<n; i++) { test_add(b, test[i]); } printf("\nAfter %"PRIu32" additions\n", n); printf(" num_nodes = %"PRIu32"\n", b->num_nodes); printf(" num_terms = %"PRIu32"\n", b->nterms); printf(" root node = %"PRIu32"\n", b->root); if (is_balanced(b, b->root, &h)) { printf(" b-height = %"PRIu32"\n", h); printf(" full height = %"PRIu32"\n", tree_height(b)); } else { printf(" not balanced\n"); } printf("\n"); // remove half n = NUM_TESTS/2; for (i=0; i<n; i++) { test_remove(b, test[i]); } printf("\nAfter %"PRIu32" removals\n", n); printf(" num_nodes = %"PRIu32"\n", b->num_nodes); printf(" num_terms = %"PRIu32"\n", b->nterms); printf(" root node = %"PRIu32"\n", b->root); if (is_balanced(b, b->root, &h)) { printf(" b-height = %"PRIu32"\n", h); printf(" full height = %"PRIu32"\n", tree_height(b)); } else { printf(" not balanced\n"); } // add them back for (i=0; i<n; i++) { test_add(b, test[i]); } printf("\nAfter %"PRIu32" additions\n", n); printf(" num_nodes = %"PRIu32"\n", b->num_nodes); printf(" num_terms = %"PRIu32"\n", b->nterms); printf(" root node = %"PRIu32"\n", b->root); if (is_balanced(b, b->root, &h)) { printf(" b-height = %"PRIu32"\n", h); printf(" full height = %"PRIu32"\n", tree_height(b)); } else { printf(" not balanced\n"); } printf("\n"); // Try again after reset reset_rba_buffer(b); n = NUM_TESTS/2; i = n; while (i > 0) { i --; test_add(b, test[i]); } printf("\nAfter %"PRIu32" additions\n", n); printf(" num_nodes = %"PRIu32"\n", b->num_nodes); printf(" num_terms = %"PRIu32"\n", b->nterms); printf(" root node = %"PRIu32"\n", b->root); if (is_balanced(b, b->root, &h)) { printf(" b-height = %"PRIu32"\n", h); printf(" full height = %"PRIu32"\n", tree_height(b)); } else { printf(" not balanced\n"); } printf("\n"); i = n; while (i > 0) { i --; test_remove(b, test[i]); } printf("\nAfter %"PRIu32" removals\n", n); printf(" num_nodes = %"PRIu32"\n", b->num_nodes); printf(" num_terms = %"PRIu32"\n", b->nterms); printf(" root node = %"PRIu32"\n", b->root); if (is_balanced(b, b->root, &h)) { printf(" b-height = %"PRIu32"\n", h); printf(" full height = %"PRIu32"\n", tree_height(b)); } else { printf(" not balanced\n"); } fflush(stdout); }
node* root=(node*)malloc(sizeof(node)); *root=new; insert(root, new1); insert(root, new2); insert(root, new3); insert(root, new4); printf("\nKsiazka telefoniczna:\n"); in_order(root); printf("\n\nMinimum:"); print_node(find_min(root)); printf("\n\nMaksimum:"); print_node(find_max(root)); printf("\n\nLiczba wezlow: %d", nodes(root)); printf("\n\nSzukam osoby o nazwisku Nowak:"); print_node(find_key(root, "Nowak")); printf("\n\nSzukam osoby o nazwisku Jan:"); print_node(find_key(root, "Jan")); printf("\n\nWysokosc drzewa: %d\n", tree_height(root)); return 0; delete_tree(root); }
int tree_height(tree node) { if(node == NULL) return 0; /* the height of a void tree is 0. */ return 1 + max(tree_height(node->left),tree_height(node->right)); }
int main(void) { //트리를 구성할 루트노드 TreeNode *root=NULL; //트리에 넣을 값들을 받을 정수형 배열 int val[100]; //반복 구문을 수행할 정수형 변수 int i, j; //트리에 구성할 값들을 입력 받기 //설명문 출력 printf("트리를 구성할 값을 입력하세요.\n(정수 범위: 1~100 / 최대 100개 입력 가능 / 종료는 101)\n"); //트리에 넣을 값을 배열에 저장(최대 100번 반복) for(i=0;i<100;i++) { //트리에 넣을 값 입력 scanf("%d", &val[i]); //101를 입력받으면 반복 종료 if(val[i]==101) break; //입력 범위를 초과하면 else if(val[i]>101) //오류 메세지 출력 error("값을 초과하였습니다."); } //입력 값 출력 및 입력 값 트리에 삽입 printf("\n입력 값 \n"); //입력 한 값들의 갯수만큼 반복 for(j=0;j<i;j++) { //입력 값 확인을 위한 출력 printf("%d ", val[j]); //입력 값 트리에 삽입 tree_insert_node(&root, val[j]); } //출력 구분을 위한 개행 printf("\n-------------------------------------------------------\n"); //전위 순회 함수를 통해 전위 순회 출력 printf("전위 순회 출력 결과\n"); tree_preorder(root); //중위 순회 함수를 통해 전위 순회 출력 printf("\n중위 순회 출력 결과\n"); tree_inorder(root); //후위 순회 함수를 통해 전위 순회 출력 printf("\n후위 순회 출력 결과\n"); tree_postorder(root); printf("\n"); //입력 받은 값 트리에서 삭제하기 //설명문 출력 printf("\n트리에서 삭제할 값을 순서대로 입력하세요!(종료는 101) \n"); //트리에서 삭제할 값 배열에 저장(최대 100번 반복) for(i=0;i<100;i++) { //삭제할 값 입력 scanf("%d", &val[i]); //101을 입력받으면 반복 종료 if(val[i]==101) break; //입력 범위를 초과하면 else if(val[i]>101) //오류 메세지 출력 error("값을 초과하였습니다."); } //입력 값 출력 및 입력 값 트리에서 삭제 printf("\n입력 값 \n"); //입력 한 값들의 갯수만큼 반복 for(j=0;j<i;j++) { //삭제 값 확인을 위한 출력 printf("%d ", val[j]); //트리에서 해당되는 노드 삭제 tree_delete_node(&root, val[j]); } //출력 구분을 위한 개행 printf("\n-------------------------------------------------------\n"); //트리 노드 개수 구하는 함수를 통한 개수 출력 printf("삭제 후 트리의 노드 개수 : %d\n", tree_get_node_count(root)); //트리 높이 구하는 함수를 통한 높이 출력 printf("삭제 후 트리의 높이 : %d\n", tree_height(root)); //레벨 순회 함수를 통한 레벨 순회 출력 printf("삭제 후 트리의 레벨 순회 \n"); tree_level_order(root); printf("\n"); system("pause"); return 0; }
int BinarySearchTree::tree_height() { return tree_height(root); }
void menu() { int c=0,data; BINNODE temp; while(c!=9) { printf("\t\t\t\tMenu for AVL tree build and Traversal\n"); printf("\t\t\t1.Insert into AVL tree\n"); printf("\t\t\t2.Search in AVL tree\n"); printf("\t\t\t3.Height of the tree\n"); printf("\t\t\t4.Number of nodes in the tree\n"); printf("\t\t\t5.Inorder Traversal\n"); printf("\t\t\t9.Exit\n"); printf("\t\t\t\tEnter your choice:"); scanf("%d",&c); switch(c) { case 1: printf("Enter the data to be inserted:"); scanf("%d",&data); if(root==NULL) { if((temp=(BINNODE)malloc(sizeof(struct binnode)))\ ==NULL) printf("Error 1:\ Memory Allocation Problem.\n"); else { temp->data=data; temp->left=NULL; temp->right=NULL; temp->balance_factor=0; root=temp; } } else insert_node(data); break; case 2: printf("Enter the data to serach:"); scanf("%d",&data); if((temp=search_node(root,data))==NULL) printf("Node does not exist.\n"); else printf("Node found,with balance factor:%d\n" ,temp->balance_factor); break; case 3: printf("Height of the tree:%d\n"\ ,tree_height(root)); break; case 4: printf("Number of nodes in the tree:%d\n"\ ,count_node(root)); break; case 5: print_inorder(root); printf("\n"); break; case 9: deallocate(root); printf("Exiting...\n"); break; } }
void printtolog(FILE *fp, RBtree *tree) { fprintf(fp, "%d\n", tree_height(tree->root)); }
int tree_height(Node node){ if(!node) return 0; return 1 + max(tree_height(node->left), tree_height(node->right)); }
std::size_t BST<Item, Key>::tree_height(const Node* root) const{ if (root == NULL) return 0; return 1 + std::max(tree_height(root->left), tree_height(root->right)); }