Tree

Problem 
Implement an algorithm to get the level of a node in a Binary Tree assuming root node to be at level 1.
For e.g, for the tree shown below, level of node 24 is 3 .

level of node in a tree

Solution  
We will recursively traverse the left and right subtrees till we find the given node. While traversing, we maintain the level information and return the level when we encounter the input node. The root node is at level 1 and then level for recursive calls to subtrees is incremented by 1.
See the implementation below.

#include<iostream>
using namespace std;

typedef struct node {
   int value;
   struct node *left, *right;
}node;

// create a new node
node *getNewNode(int value) {
   node *new_node = new node;
   new_node->value = value;
   new_node->left = NULL;
   new_node->right = NULL;
   return new_node;
}

// get the level of the node 
// root node is assumed to be at level 1
int getLevel(node *ptr,int val,int level) {
   if (ptr == NULL)
      return 0;
   if (ptr->value == val)
      return level;
   return getLevel(ptr->left, val, level+1) | getLevel(ptr->right, val, level+1);
}

// create the tree
node *createTree() {
   node *root = getNewNode(31);
   root->left = getNewNode(16);
   root->right = getNewNode(52);
   root->left->left = getNewNode(7);
   root->left->right = getNewNode(24);
   root->left->right->left = getNewNode(19);
   root->left->right->right = getNewNode(29);
   return root;
}

// main
int main() {
   node *root = createTree();
   int val = 24;
   int level = getLevel(root,val,1);
   cout<<"\nLevel of "<<val<<" is "<<level<<endl;
   return 0;
}

Back | Next

All problems on Trees
* Implement the inorder , preorder and postorder traversal mechanisms of a tree
* Implement an algorithm to insert a node in a Binary Search Tree ( BST )
* Implement an algorithm to find the height of a Binary Tree
* Implement an algorithm to get the level of a node in a Binary Tree assuming root node to be at level 1
* Get the root to leaf path in a Binary Tree such that the sum of the node values in that path is minimum among all possible root to leaf paths
* Print all the ancestors of a given node in a Binary Tree
* Replace all the node values with the sum of the node values of ancestral nodes in a Binary Tree
* Check if the given tree is a sum tree i.e value at each node is equal to the value of all elements in its left subtree and right subtree
* Given a Binary Tree, create another tree which is a mirror image of the given tree
* Construct a tree, given its inorder and preorder traversals
* Find the Least Common Ancestor ( LCA ) of two nodes in a Binary Search Tree
* Find the Least Common Ancestor ( LCA ) of two nodes in a Binary Tree
* Compute the Diameter of a given Binary Tree
* Check if a given tree is a Binary Search Tree ( BST )
About    Contact    Sitemap    Terms    Privacy