Height and Depth of a node in a Binary Tree

Last Updated : 23 Jul, 2025

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.

Note:

  • 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 maximum number of edges from that node to a leaf node in its subtree.

Examples:

Input: k = 25, 

tree

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,

tree

Output: Depth of node 10 = 1
Height of node 10 = 2
Explanation: The number of edges in the path from root node to the node 10 is 1.
The number of edges in the longest path connecting the node 10 to any leaf node is 2.

Table of Content

[Approach 1] Using Recursion - O(n) time and O(h) space

 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) = Maximum number of edges from that node to a leaf node in its subtree.

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.
C++ 
#include <bits/stdc++.h>
using namespace std;

// Structure of a Binary Tree Node
struct Node {
    int data;
    Node *left, *right;
    Node(int item) {
        data = item;
        left = right = nullptr;
    }
};

int findDepth(Node* root, int x)
{
    // Base case
    if (root == nullptr)
        return -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;
}

int findHeightUtil(Node* root, int x,
                   int& height)
{
    if (root == nullptr) {
        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;
}

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;
}

int main()
{
    Node* 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);

    int k = 25;

    cout << "Depth: "
         << findDepth(root, k) << "\n";

    cout << "Height: " << findHeight(root, k);

    return 0;
}
Java 
// Structure of a Binary Tree Node
class Node {
    int data;
    Node left, right;
    Node(int item) {
        data = item;
        left = right = null;
    }
}

public class GfG{

    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)
            || (dist = findDepth(root.left, x)) >= 0
            || (dist = findDepth(root.right, x)) >= 0)
            // Return depth of the node
            return dist + 1;

        return dist;
    }

    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 = Math.max(leftHeight, rightHeight) + 1;

        // If current node is the required node
        if (root.data == x)
            height[0] = ans;

        return ans;
    }

    int findHeight(Node root, int x) {
        // Store the height of the given node
        int[] h = {-1};

        // Stores height of the Tree
        findHeightUtil(root, x, h);

        // Return the height
        return h[0];
    }

    public static void main(String[] args) {
        Node 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);

        int k = 25;

        GfG tree = new GfG();
        System.out.println("Depth: " + tree.findDepth(root, k));
        System.out.println("Height: " + tree.findHeight(root, k));
    }
}
Python 
class Node:
    def __init__(self, data):
        self.data = data
        self.left = None
        self.right = None

# Function to find depth of a given node
def find_depth(root, x):
    if root is None:
        return -1
    
    dist = -1
    
    # Check if x is the current node or
    # if it exists in the left or right subtree
    if (root.data == x or
        (dist := find_depth(root.left, x)) >= 0 or
        (dist := find_depth(root.right, x)) >= 0):
        return dist + 1
    
    return dist

# Utility function to find height of a given node
def find_height_util(root, x, height):
    if root is None:
        return -1
    
    # Store the maximum height of left and right subtree
    left_height = find_height_util(root.left, x, height)
    right_height = find_height_util(root.right, x, height)
    
    # Update height of the current node
    ans = max(left_height, right_height) + 1
    
    # If current node is the required node, update height
    if root.data == x:
        height[0] = ans
    
    return ans

# Function to find height of a given node
def find_height(root, x):
    height = [-1]  # Using a list to 
                   # store height by reference
    find_height_util(root, x, height)
    return height[0]

if __name__ == "__main__":
    # Construct the tree
    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
    
    # Print depth and height of the given node
    print("Depth:", find_depth(root, k))
    print("Height:", find_height(root, k))
C# 
using System;
using System.Collections.Generic;

// Structure of a Binary Tree Node
class Node {
    public int data;
    public Node left, right;

    public Node(int item) {
        data = item;
        left = right = null;
    }
}

class GfG{
    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)
            || (dist = FindDepth(root.left, x)) >= 0
            || (dist = FindDepth(root.right, x)) >= 0)
            
            // Return depth of the node
            return dist + 1;

        return dist;
    }

    int FindHeightUtil(Node root, int x, ref 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, ref height);
        int rightHeight = FindHeightUtil(root.right, x, ref height);

        // 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;
    }

    int FindHeight(Node root, int x) {
        // Store the height of the given node
        int h = -1;

        // Stores height of the Tree
        FindHeightUtil(root, x, ref h);

        // Return the height
        return h;
    }

    public static void Main(string[] args) {
        Node 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);

        int k = 25;

        GfG tree = new GfG();
        Console.WriteLine("Depth: " + tree.FindDepth(root, k));
        Console.WriteLine("Height: " + tree.FindHeight(root, k));
    }
}
JavaScript 
class Node {
    constructor(data) {
        this.data = data;
        this.left = null;
        this.right = null;
    }
}

// Function to find depth of a given node
function findDepth(root, x) {
    if (!root) return -1;
    
    let dist = -1;
    
    // Check if x is the current node or
    // if it exists in the left or right subtree
    if (root.data === x ||
        (dist = findDepth(root.left, x)) >= 0 ||
        (dist = findDepth(root.right, x)) >= 0) {
        return dist + 1;
    }
    
    return dist;
}

// Utility function to find height of a given node
function findHeightUtil(root, x, height) {
    if (!root) return -1;
    
    // Store the maximum height of left and right subtree
    let leftHeight = findHeightUtil(root.left, x, height);
    let rightHeight = findHeightUtil(root.right, x, height);
    
    // Update height of the current node
    let ans = Math.max(leftHeight, rightHeight) + 1;
    
    // If current node is the required node, update height
    if (root.data === x) height.value = ans;
    
    return ans;
}

// Function to find height of a given node
function findHeight(root, x) {
    let height = { value: -1 }; // Using an object 
                            // to store height by reference
    findHeightUtil(root, x, height);
    return height.value;
}

// Construct the tree
let 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);

let k = 25;

// Print depth and height of the given node
console.log("Depth:", findDepth(root, k));
console.log("Height:", findHeight(root, k));

Output
Depth: 2
Height: 1

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

[Approach 2] Using Level Order Traversal - O(n) time and O(n) space

We can calculate the depth of each node using level order traversal by storing the current level as its depth.
To calculate the height of a node k, we find the maximum depth of any leaf node in its subtree.
Then:
Height of node k = (Max depth of leaf in subtree) − (Depth of node k) − 1

Algorithm:

  • Initialize height and depth variable with -1;
  • Initialize a queue and a level variable with 0 and push the root in the queue.
  • When the value of frontNode is equal to the target k, we stop processing the nodes at that level and clear the queue to only focus on the children of the node k. This ensures that we find the furthest leaf node in the subtree of k.
  • So the value of depth will be equal to current level.
  • After completion we can calculate the value of height using height = level - depth - 1;
  • Print the value of height and depth variable.
C++ 
#include <bits/stdc++.h>
using namespace std;

struct Node
{
    int data;
    Node *left;
    Node *right;
    Node(int item)
    {
        data = item;
        left = right = nullptr;
    }
};

void findDepthAndHeight(Node *root, int k)
{
    if (root == nullptr)
        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;
                
                // Clear the queue after finding the node
                while (!q.empty())
                {
                    q.pop();
                }
            }

            // Push left and right children of 
            // the current node to the queue
            if (frontNode->left)
                q.push(frontNode->left);
            if (frontNode->right)
                q.push(frontNode->right);

            if (frontNode->data == k) 
            {
                break;
            }
        }
        // Increment the level after processing
        // all nodes at the current level
        level++;
    }

    height = level - depth - 1;
    cout << "Depth : " << depth << endl;
    cout << "Height : " << height << endl;
}

int main()
{
    Node *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);

    int k = 10;

    findDepthAndHeight(root, k);
    return 0;
}
Java 
import java.util.LinkedList;
import java.util.Queue;

class Node {
    int data;
    Node left, right;

    Node(int item) {
        data = item;
        left = right = null;
    }
}

public class GfG{
    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;
                    // Clear the queue after finding the node
                    q.clear();
                }

                // Push left and right children of the current node to the queue
                if (frontNode.left != null) q.add(frontNode.left);
                if (frontNode.right != null) q.add(frontNode.right);

                if (frontNode.data == k) {
                    break;
                }
            }
            // Increment the level after processing all nodes at the current level
            level++;
        }

        height = level - depth - 1;
        System.out.println("Depth : " + depth);
        System.out.println("Height : " + height);
    }

    public static void main(String[] args) {
        Node 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);

        int k = 10;

        findDepthAndHeight(root, k);
    }
}
Python 
class Node:
    def __init__(self, item):
        self.data = item
        self.left = None
        self.right = None

def find_depth_and_height(root, k):
    if root is None:
        return
    depth = -1
    height = -1
    q = [root]
    level = 0

    while q:
        n = len(q)
        for i in range(n):
            front_node = q.pop(0)

            if front_node.data == k:
                depth = level
                # Clear the queue after finding the node
                q.clear()

            # Push left and right children of the current node to the queue
            if front_node.left:
                q.append(front_node.left)
            if front_node.right:
                q.append(front_node.right)

            if front_node.data == k:
                break
            
        # Increment the level after processing all nodes at the current level
        level += 1

    height = level - depth - 1
    print(f'Depth : {depth}')
    print(f'Height : {height}')


def main():
    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 = 10

    find_depth_and_height(root, k)


if __name__ == '__main__':
    main()
C# 
using System;
using System.Collections.Generic;

class Node {
    public int data;
    public Node left, right;

    public Node(int item) {
        data = item;
        left = right = null;
    }
}

class GfG{
    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;
                    // Clear the queue after finding the node
                    q.Clear();
                }

                // Push left and right children of the current node to the queue
                if (frontNode.left != null) q.Enqueue(frontNode.left);
                if (frontNode.right != null) q.Enqueue(frontNode.right);

                if (frontNode.data == k) {
                    break;
                }
            }
            // Increment the level after processing all nodes at the current level
            level++;
        }

        height = level - depth - 1;
        Console.WriteLine("Depth : " + depth);
        Console.WriteLine("Height : " + height);
    }

    static void Main() {
        Node 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);

        int k = 10;

        FindDepthAndHeight(root, k);
    }
}
JavaScript 
// Node structure
class Node {
    constructor(item) {
        this.data = item;
        this.left = null;
        this.right = null;
    }
}

function findDepthAndHeight(root, k) {
    if (root === null) return;
    let depth = -1;
    let height = -1;
    let queue = [];
    queue.push(root);
    let level = 0;

    while (queue.length > 0) {
        let n = queue.length;
        for (let i = 0; i < n; i++) {
            let frontNode = queue.shift();

            if (frontNode.data === k) {
                depth = level;
                // Clear the queue after finding the node
                queue = [];
            }

            // Push left and right children of the current node to the queue
            if (frontNode.left) queue.push(frontNode.left);
            if (frontNode.right) queue.push(frontNode.right);

            if (frontNode.data === k) {
                break;
            }
        }
        // Increment the level after processing all nodes at the current level
        level++;
    }

    height = level - depth - 1;
    console.log("Depth : " + depth);
    console.log("Height : " + height);
}

let 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);

let k = 10;

findDepthAndHeight(root, k);

Output
Depth : 2
Height : 1

Time Complexity: O(n)
Auxiliary Space: O(n)due to queue data structure.

Comment

Explore