Open In App

Height and Depth of a node in a Binary Tree

Improve
Improve
Improve
Like Article
Like
Save Article
Save
Share
Report issue
Report

Given a Binary Tree consisting of N nodes and a integer K, the task is to find the depth and height of the node with value K in the Binary Tree

The depth of a node is the number of edges present in path from the root node of a tree to that node.
The height of a node is the number of edges present in the longest path connecting that node to a leaf node.

Examples:

Input: K = 25, 
          5
      /      \
   10       15
  /   \      /   \
20   25  30   35
         \
         45
Output:
Depth of node 25 = 2
Height of node 25 = 1
Explanation:
The number of edges in the path from root node to the node 25 is 2. Therefore, depth of the node 25 is 2.
The number of edges in the longest path connecting the node 25 to any leaf node is 1. Therefore, height of the node 25 is 1.

Input: K = 10, 
          5
      /      \
   10       15
  /   \      /   \
20   25  30   35
         \
         45
Output: 
Depth of node 10 = 1
Height of node 10 = 2

Approach: The problem can be solved based on the following observations:

 Depth of a node K (of a Binary Tree) = Number of edges in the path connecting the root to the node K = Number of ancestors of K (excluding K itself). 

Follow the steps below to find the depth of the given node:

  • If the tree is empty, print -1.
  • Otherwise, perform the following steps:
    • Initialize a variable, say dist as -1.
    • Check if the node K is equal to the given node.
    • Otherwise, check if it is present in either of the subtrees, by recursively checking for the left and right subtrees respectively.
    • If found to be true, print the value of dist + 1.
    • Otherwise, print dist.

Height of a node K (of a Binary Tree) = Number of edges in the longest path connecting K to any leaf node. 

Follow the steps below to find the height of the given node:

  • If the tree is empty, print -1.
  • Otherwise, perform the following steps:
    • Calculate the height of the left subtree recursively.
    • Calculate the height of the right subtree recursively.
    • Update height of the current node by adding 1 to the maximum of the two heights obtained in the previous step. Store the height in a variable, say ans.
    • If the current node is equal to the given node K, print the value of ans as the required answer.

Below is the implementation of the above approach:

C++




// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Structure of a Binary Tree Node
struct Node {
    int data;
    Node *left, *right;
};
 
// Utility function to create
// a new Binary Tree Node
Node* newNode(int item)
{
    Node* temp = new Node;
    temp->data = item;
    temp->left = temp->right = NULL;
    return temp;
}
 
// Function to find the depth of
// a given node in a Binary Tree
int findDepth(Node* root, int x)
{
    // Base case
    if (root == NULL)
        return -1;
 
    // Initialize distance as -1
    int dist = -1;
 
    // Check if x is current node=
    if ((root->data == x)
 
        // Otherwise, check if x is
        // present in the left subtree
        || (dist = findDepth(root->left, x)) >= 0
 
        // Otherwise, check if x is
        // present in the right subtree
        || (dist = findDepth(root->right, x)) >= 0)
 
        // Return depth of the node
        return dist + 1;
 
    return dist;
}
 
// Helper function to find the height
// of a given node in the binary tree
int findHeightUtil(Node* root, int x,
                   int& height)
{
    // Base Case
    if (root == NULL) {
        return -1;
    }
 
    // Store the maximum height of
    // the left and right subtree
    int leftHeight = findHeightUtil(
        root->left, x, height);
 
    int rightHeight
        = findHeightUtil(
            root->right, x, height);
 
    // Update height of the current node
    int ans = max(leftHeight, rightHeight) + 1;
 
    // If current node is the required node
    if (root->data == x)
        height = ans;
 
    return ans;
}
 
// Function to find the height of
// a given node in a Binary Tree
int findHeight(Node* root, int x)
{
    // Store the height of
    // the given node
    int h = -1;
 
    // Stores height of the Tree
    int maxHeight = findHeightUtil(root, x, h);
 
    // Return the height
    return h;
}
 
// Driver Code
int main()
{
    // Binary Tree Formation
    Node* root = newNode(5);
    root->left = newNode(10);
    root->right = newNode(15);
    root->left->left = newNode(20);
    root->left->right = newNode(25);
    root->left->right->right = newNode(45);
    root->right->left = newNode(30);
    root->right->right = newNode(35);
 
    int k = 25;
 
    // Function call to find the
    // depth of a given node
    cout << "Depth: "
         << findDepth(root, k) << "\n";
 
    // Function call to find the
    // height of a given node
    cout << "Height: " << findHeight(root, k);
 
    return 0;
}


Java




// Java program for the above approach
import java.util.*;
class GFG
{
 
static int height = -1;
 
// Structure of a Binary Tree Node
static class Node
{
    int data;
    Node left;
    Node right;
};
 
// Utility function to create
// a new Binary Tree Node
static Node newNode(int item)
{
    Node temp = new Node();
    temp.data = item;
    temp.left = temp.right = null;
    return temp;
}
 
// Function to find the depth of
// a given node in a Binary Tree
static int findDepth(Node root, int x)
{
     
    // Base case
    if (root == null)
        return -1;
 
    // Initialize distance as -1
    int dist = -1;
 
    // Check if x is current node=
    if ((root.data == x)||
     
        // Otherwise, check if x is
        // present in the left subtree
        (dist = findDepth(root.left, x)) >= 0 ||
         
        // Otherwise, check if x is
        // present in the right subtree
        (dist = findDepth(root.right, x)) >= 0)
 
        // Return depth of the node
        return dist + 1;
         
    return dist;
}
 
// Helper function to find the height
// of a given node in the binary tree
static int findHeightUtil(Node root, int x)
{
     
    // Base Case
    if (root == null)
    {
        return -1;
    }
 
    // Store the maximum height of
    // the left and right subtree
    int leftHeight = findHeightUtil(root.left, x);
 
    int rightHeight = findHeightUtil(root.right, x);
 
    // Update height of the current node
    int ans = Math.max(leftHeight, rightHeight) + 1;
 
    // If current node is the required node
    if (root.data == x)
        height = ans;
 
    return ans;
}
 
// Function to find the height of
// a given node in a Binary Tree
static int findHeight(Node root, int x)
{
     
    // Stores height of the Tree
    findHeightUtil(root, x);
 
    // Return the height
    return height;
}
 
// Driver Code
public static void main(String []args)
{
     
    // Binary Tree Formation
    Node root = newNode(5);
    root.left = newNode(10);
    root.right = newNode(15);
    root.left.left = newNode(20);
    root.left.right = newNode(25);
    root.left.right.right = newNode(45);
    root.right.left = newNode(30);
    root.right.right = newNode(35);
 
    int k = 25;
 
    // Function call to find the
    // depth of a given node
    System.out.println("Depth: " + findDepth(root, k));
 
    // Function call to find the
    // height of a given node
    System.out.println("Height: " + findHeight(root, k));
}
}
 
// This code is contributed by SURENDRA_GANGWAR


Python3




# Python3 program for the above approach
 
# Structure of a Binary Tree Node
class Node:
    def __init__(self, x):
        self.data = x
        self.left = None
        self.right = None
         
# Function to find the depth of
# a given node in a Binary Tree
def findDepth(root, x):
   
    # Base case
    if (root == None):
        return -1
 
    # Initialize distance as -1
    dist = -1
 
    # Check if x is current node=
    if (root.data == x):
        return dist + 1
 
    dist = findDepth(root.left, x)
    if dist >= 0:
        return dist + 1
    dist = findDepth(root.right, x)
    if dist >= 0:
        return dist + 1
    return dist
 
# Helper function to find the height
# of a given node in the binary tree
def findHeightUtil(root, x):
    global height
 
    # Base Case
    if (root == None):
        return -1
 
    # Store the maximum height of
    # the left and right subtree
    leftHeight = findHeightUtil(root.left, x)
 
    rightHeight = findHeightUtil(root.right, x)
 
    # Update height of the current node
    ans = max(leftHeight, rightHeight) + 1
 
    # If current node is the required node
    if (root.data == x):
        height = ans
 
    return ans
 
# Function to find the height of
# a given node in a Binary Tree
def findHeight(root, x):
    global height
 
    # Stores height of the Tree
    maxHeight = findHeightUtil(root, x)
 
    # Return the height
    return height
 
# Driver Code
if __name__ == '__main__':
   
    # Binary Tree Formation
    height = -1
    root = Node(5)
    root.left = Node(10)
    root.right = Node(15)
    root.left.left = Node(20)
    root.left.right = Node(25)
    root.left.right.right = Node(45)
    root.right.left = Node(30)
    root.right.right = Node(35)
 
    k = 25
 
    # Function call to find the
    # depth of a given node
    print("Depth: ",findDepth(root, k))
 
    # Function call to find the
    # height of a given node
    print("Height: ",findHeight(root, k))
 
    # This code is contributed by mohit kumar 29.


C#




// C# program for the above approach
using System;
using System.Collections.Generic;
 
class GFG{
 
static int height = -1;
 
// Structure of a Binary Tree Node
class Node
{
    public int data;
    public Node left;
    public Node right;
};
 
// Utility function to create
// a new Binary Tree Node
static Node newNode(int item)
{
    Node temp = new Node();
    temp.data = item;
    temp.left = temp.right = null;
    return temp;
}
 
// Function to find the depth of
// a given node in a Binary Tree
static int findDepth(Node root, int x)
{
     
    // Base case
    if (root == null)
        return -1;
 
    // Initialize distance as -1
    int dist = -1;
 
    // Check if x is current node=
    if ((root.data == x)||
     
        // Otherwise, check if x is
        // present in the left subtree
        (dist = findDepth(root.left, x)) >= 0 ||
         
        // Otherwise, check if x is
        // present in the right subtree
        (dist = findDepth(root.right, x)) >= 0)
 
        // Return depth of the node
        return dist + 1;
         
    return dist;
}
 
// Helper function to find the height
// of a given node in the binary tree
static int findHeightUtil(Node root, int x)
{
     
    // Base Case
    if (root == null)
    {
        return -1;
    }
 
    // Store the maximum height of
    // the left and right subtree
    int leftHeight = findHeightUtil(root.left, x);
 
    int rightHeight = findHeightUtil(root.right, x);
 
    // Update height of the current node
    int ans = Math.Max(leftHeight, rightHeight) + 1;
 
    // If current node is the required node
    if (root.data == x)
        height = ans;
 
    return ans;
}
 
// Function to find the height of
// a given node in a Binary Tree
static int findHeight(Node root, int x)
{
     
    // Stores height of the Tree
    findHeightUtil(root, x);
 
    // Return the height
    return height;
}
 
// Driver Code
public static void Main()
{
     
    // Binary Tree Formation
    Node root = newNode(5);
    root.left = newNode(10);
    root.right = newNode(15);
    root.left.left = newNode(20);
    root.left.right = newNode(25);
    root.left.right.right = newNode(45);
    root.right.left = newNode(30);
    root.right.right = newNode(35);
 
    int k = 25;
 
    // Function call to find the
    // depth of a given node
    Console.WriteLine("Depth: " + findDepth(root, k));
 
    // Function call to find the
    // height of a given node
    Console.WriteLine("Height: " + findHeight(root, k));
}
}
 
// This code is contributed by ipg2016107


Javascript




<script>
 
// JavaScript program for the above approach
 
var height = -1;
 
// Structure of a Binary Tree Node
class Node
{
    constructor()
    {
        this.data = 0;
        this.left = null;
        this.right = null;
    }
};
 
// Utility function to create
// a new Binary Tree Node
function newNode(item)
{
    var temp = new Node();
    temp.data = item;
    temp.left = temp.right = null;
    return temp;
}
 
// Function to find the depth of
// a given node in a Binary Tree
function findDepth(root, x)
{
     
    // Base case
    if (root == null)
        return -1;
 
    // Initialize distance as -1
    var dist = -1;
 
    // Check if x is current node=
    if ((root.data == x)||
     
        // Otherwise, check if x is
        // present in the left subtree
        (dist = findDepth(root.left, x)) >= 0 ||
         
        // Otherwise, check if x is
        // present in the right subtree
        (dist = findDepth(root.right, x)) >= 0)
 
        // Return depth of the node
        return dist + 1;
         
    return dist;
}
 
// Helper function to find the height
// of a given node in the binary tree
function findHeightUtil(root, x)
{
     
    // Base Case
    if (root == null)
    {
        return -1;
    }
 
    // Store the maximum height of
    // the left and right subtree
    var leftHeight = findHeightUtil(root.left, x);
 
    var rightHeight = findHeightUtil(root.right, x);
 
    // Update height of the current node
    var ans = Math.max(leftHeight, rightHeight) + 1;
 
    // If current node is the required node
    if (root.data == x)
        height = ans;
 
    return ans;
}
 
// Function to find the height of
// a given node in a Binary Tree
function findHeight(root, x)
{
     
    // Stores height of the Tree
    findHeightUtil(root, x);
 
    // Return the height
    return height;
}
 
// Driver Code
// Binary Tree Formation
var root = newNode(5);
root.left = newNode(10);
root.right = newNode(15);
root.left.left = newNode(20);
root.left.right = newNode(25);
root.left.right.right = newNode(45);
root.right.left = newNode(30);
root.right.right = newNode(35);
var k = 25;
// Function call to find the
// depth of a given node
document.write("Depth: " + findDepth(root, k)+"<br>");
// Function call to find the
// height of a given node
document.write("Height: " + findHeight(root, k));
 
 
</script>


Output

Depth: 2
Height: 1







Time Complexity: O(N)
Auxiliary Space: O(1)

Another Approach(Using Level Order Traversal): Simple and Easy to understand

Follow the below steps to solve the above problem:

1) Initialize height and depth variable with -1;
2) Initialize a queue and a level variable with 0 and push the root in the queue.
3) Perform level order traversal and if value of frontNode is equal to the target(K) node then value of depth will be equal to the level value and continue traversing.
4) After completion we can calculate the value of height using height = level – depth – 1;
5) Print the value of height and depth variable.

Below is the implementation of above approach:

C++




// C++ Program to solve the above problem
#include<bits/stdc++.h>
using namespace std;
 
struct Node{
    int data;
    Node* left;
    Node* right;
     
    Node(int item){
        data = item;
        left = right = NULL;
    }
};
 
Node* newNode(int value){
    return new Node(value);
}
 
void findDepthAndHeight(Node* root, int k){
    if(root == NULL) return;
    int depth = -1;
    int height = -1;
    queue<Node*> q;
    q.push(root);
    int level = 0;
    while(!q.empty()){
        int n = q.size();
        for(int i = 0; i<n; i++){
            Node* frontNode = q.front();
            q.pop();
            if(frontNode->data == k) depth = level;
            if(frontNode->left) q.push(frontNode->left);
            if(frontNode->right) q.push(frontNode->right);
        }
        level++;
    }
    height = level - depth - 1;
    cout<<"Depth : "<<depth<<endl;
    cout<<"Height : "<<height<<endl;
}
 
int main(){
    // Binary Tree Formation
    Node* root = newNode(5);
    root->left = newNode(10);
    root->right = newNode(15);
    root->left->left = newNode(20);
    root->left->right = newNode(25);
    root->left->right->right = newNode(45);
    root->right->left = newNode(30);
    root->right->right = newNode(35);
   
    int k = 25;
     
    findDepthAndHeight(root, k);
    return 0;
}


Java




// Java program to solve the above problem
import java.util.LinkedList;
import java.util.Queue;
 
class Node {
    int data;
    Node left;
    Node right;
 
    Node(int item) {
        data = item;
        left = right = null;
    }
}
 
public class GFG {
 
    static Node newNode(int value) {
        return new Node(value);
    }
 
    static void findDepthAndHeight(Node root, int k) {
        if (root == null)
            return;
 
        int depth = -1;
        int height = -1;
 
        Queue<Node> q = new LinkedList<>();
        q.add(root);
        int level = 0;
 
        while (!q.isEmpty()) {
            int n = q.size();
            for (int i = 0; i < n; i++) {
                Node frontNode = q.poll();
                if (frontNode.data == k)
                    depth = level;
                if (frontNode.left != null)
                    q.add(frontNode.left);
                if (frontNode.right != null)
                    q.add(frontNode.right);
            }
            level++;
        }
 
        height = level - depth - 1;
        System.out.println("Depth : " + depth);
        System.out.println("Height : " + height);
    }
 
    public static void main(String[] args) {
        // Binary Tree Formation
        Node root = newNode(5);
        root.left = newNode(10);
        root.right = newNode(15);
        root.left.left = newNode(20);
        root.left.right = newNode(25);
        root.left.right.right = newNode(45);
        root.right.left = newNode(30);
        root.right.right = newNode(35);
 
        int k = 25;
 
        findDepthAndHeight(root, k);
    }
}


Python3




class Node:
  def __init__(self, data):
    self.data = data
    self.left = None
    self.right = None
 
def new_node(value):
  return Node(value)
 
def find_depth_and_height(root, k):
  if root is None:
    return
  depth = -1
  height = -1
  queue = []
  queue.append(root)
  level = 0
  while queue:
    n = len(queue)
    for i in range(n):
      front_node = queue.pop(0)
      if front_node.data == k:
        depth = level
      if front_node.left:
        queue.append(front_node.left)
      if front_node.right:
        queue.append(front_node.right)
    level += 1
  height = level - depth - 1
  print("Depth:", depth)
  print("Height:", height)
 
def main():
  # Binary Tree Formation
  root = new_node(5)
  root.left = new_node(10)
  root.right = new_node(15)
  root.left.left = new_node(20)
  root.left.right = new_node(25)
  root.left.right.right = new_node(45)
  root.right.left = new_node(30)
  root.right.right = new_node(35)
 
  k = 25
 
  find_depth_and_height(root, k)
 
if __name__ == "__main__":
  main()


C#




using System;
using System.Collections.Generic;
 
public class Node {
    public int data;
    public Node left;
    public Node right;
 
    public Node(int item) {
        data = item;
        left = right = null;
    }
}
 
public class GFG {
    static Node newNode(int value) {
        return new Node(value);
    }
 
    static void findDepthAndHeight(Node root, int k) {
        if (root == null)
            return;
        int depth = -1;
        int height = -1;
        Queue<Node> q = new Queue<Node>();
        q.Enqueue(root);
        int level = 0;
        while (q.Count != 0) {
            int n = q.Count;
            for (int i = 0; i < n; i++) {
                Node frontNode = q.Dequeue();
                if (frontNode.data == k)
                    depth = level;
                if (frontNode.left != null)
                    q.Enqueue(frontNode.left);
                if (frontNode.right != null)
                    q.Enqueue(frontNode.right);
            }
            level++;
        }
        height = level - depth - 1;
        Console.WriteLine("Depth : " + depth);
        Console.WriteLine("Height : " + height);
    }
 
    public static void Main(string[] args) {
        // Binary Tree Formation
        Node root = newNode(5);
        root.left = newNode(10);
        root.right = newNode(15);
        root.left.left = newNode(20);
        root.left.right = newNode(25);
        root.left.right.right = newNode(45);
        root.right.left = newNode(30);
        root.right.right = newNode(35);
 
        int k = 25;
 
        findDepthAndHeight(root, k);
    }
}


Javascript




class TreeNode {
    constructor(value) {
        this.data = value;
        this.left = null;
        this.right = null;
    }
}
 
function findDepthAndHeight(root, k) {
    if (root === null)
        return;
 
    let depth = -1;
    let height = -1;
 
    const queue = [];
    queue.push(root);
    let level = 0;
 
    while (queue.length > 0) {
        const n = queue.length;
        for (let i = 0; i < n; i++) {
            const frontNode = queue.shift();
            if (frontNode.data === k)
                depth = level;
            if (frontNode.left !== null)
                queue.push(frontNode.left);
            if (frontNode.right !== null)
                queue.push(frontNode.right);
        }
        level++;
    }
 
    height = level - depth - 1;
    console.log("Depth: " + depth);
    console.log("Height: " + height);
}
 
// Binary Tree Formation
const root = new TreeNode(5);
root.left = new TreeNode(10);
root.right = new TreeNode(15);
root.left.left = new TreeNode(20);
root.left.right = new TreeNode(25);
root.left.right.right = new TreeNode(45);
root.right.left = new TreeNode(30);
root.right.right = new TreeNode(35);
 
const k = 25;
 
findDepthAndHeight(root, k);


Output

Depth : 2
Height : 1







Time Complexity: O(N), where N is the number of nodes in a given binary tree.
Auxiliary Space: O(N) due to queue data structure.



Last Updated : 25 Sep, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads