Maximum Depth of Binary Tree
Last Updated :
03 Apr, 2025
Given a binary tree, the task is to find the maximum depth of the tree. The maximum depth or height of the tree is the number of edges in the tree from the root to the deepest node.
Examples:
Input:
Output: 2
Explanation: The longest path from the root (node 12) goes through node 8 to node 5, which has 2 edges.
Input:
Output: 3
Explanation: The longest path from the root (node 1) to a leaf node 6 with 3 edge.
[Approach 1] Using Recursion - O(n) Time and O(h) Space
The idea is to recursively calculate the height of the left and the right subtrees of a node and then find height to the node as max of the heights of two children plus 1.
Algorithm:
- If the tree is empty, return -1.
- Otherwise, do the following:
- Get the height of the left subtree recursively, i.e., call height(node->left).
- Get the height of the right subtree recursively, i.e., call height(node->right).
- Compute the maximum of the heights of the left and right subtrees and add 1 to it for the current node.
- height = max(height of left subtree, height of right subtree) + 1.
- Return the height.
C++
#include <iostream>
using namespace std;
class Node {
public:
int data;
Node *left;
Node *right;
Node(int val) {
data = val;
left = nullptr;
right = nullptr;
}
};
// Returns height which is the number of edges
// along the longest path from the root node down
// to the farthest leaf node.
int height(Node *root) {
if (root == nullptr)
return -1;
// compute the height of left and right subtrees
int lHeight = height(root->left);
int rHeight = height(root->right);
return max(lHeight, rHeight) + 1;
}
int main() {
// Representation of the input tree:
// 12
// / \
// 8 18
// / \
// 5 11
Node *root = new Node(12);
root->left = new Node(8);
root->right = new Node(18);
root->left->left = new Node(5);
root->left->right = new Node(11);
cout << height(root);
return 0;
}
#include <stdio.h>
#include <stdlib.h>
struct Node {
int data;
struct Node* left;
struct Node* right;
};
// Returns "height" which is the number of edges
// along the longest path from the root node down
// to the farthest leaf node.
int height(struct Node* root) {
if (root == NULL)
return -1;
// compute the height of left and right subtrees
int lHeight = height(root->left);
int rHeight = height(root->right);
return (lHeight > rHeight ? lHeight : rHeight) + 1;
}
struct Node* createNode(int val) {
struct Node* node
= (struct Node*)malloc(sizeof(struct Node));
node->data = val;
node->left = NULL;
node->right = NULL;
return node;
}
int main() {
// Representation of the input tree:
// 12
// / \
// 8 18
// / \
// 5 11
struct Node* root = createNode(12);
root->left = createNode(8);
root->right = createNode(18);
root->left->left = createNode(5);
root->left->right = createNode(11);
printf("%d\n", height(root));
return 0;
}
class Node {
int data;
Node left, right;
Node(int val) {
data = val;
left = null;
right = null;
}
}
class GfG {
// Returns height which is the number of edges
// along the longest path from the root node down
// to the farthest leaf node.
static int height(Node root) {
if (root == null)
return -1;
// compute the height of left and right subtrees
int lHeight = height(root.left);
int rHeight = height(root.right);
return Math.max(lHeight, rHeight) + 1;
}
public static void main(String[] args) {
// Representation of the input tree:
// 12
// / \
// 8 18
// / \
// 5 11
Node root = new Node(12);
root.left = new Node(8);
root.right = new Node(18);
root.left.left = new Node(5);
root.left.right = new Node(11);
System.out.println(height(root));
}
}
class Node:
def __init__(self, val):
self.data = val
self.left = None
self.right = None
# Returns height which is the number of edges
# along the longest path from the root node down
# to the farthest leaf node.
def height(root):
if root is None:
return -1
# compute the height of left and right subtrees
lHeight = height(root.left)
rHeight = height(root.right)
return max(lHeight, rHeight) + 1
if __name__ == "__main__":
# Representation of the input tree:
# 12
# / \
# 8 18
# / \
# 5 11
root = Node(12)
root.left = Node(8)
root.right = Node(18)
root.left.left = Node(5)
root.left.right = Node(11)
print(height(root))
using System;
class Node {
public int data;
public Node left, right;
public Node(int val) {
data = val;
left = null;
right = null;
}
}
class GfG {
// Returns height which is the number of edges
// along the longest path from the root node down
// to the farthest leaf node.
static int height(Node root) {
if (root == null)
return -1;
// compute the height of left and right subtrees
int lHeight = height(root.left);
int rHeight = height(root.right);
return Math.Max(lHeight, rHeight) + 1;
}
static void Main(string[] args) {
// Representation of the input tree:
// 12
// / \
// 8 18
// / \
// 5 11
Node root = new Node(12);
root.left = new Node(8);
root.right = new Node(18);
root.left.left = new Node(5);
root.left.right = new Node(11);
Console.WriteLine(height(root));
}
}
class Node {
constructor(val) {
this.data = val;
this.left = null;
this.right = null;
}
}
// Returns height which is the number of edges
// along the longest path from the root node down
// to the farthest leaf node.
function height(root) {
if (root === null) {
return -1;
}
// compute the height of left and right subtrees
let lHeight = height(root.left);
let rHeight = height(root.right);
return Math.max(lHeight, rHeight) + 1;
}
// Driver Code
// Representation of the input tree:
// 12
// / \
// 8 18
// / \
// 5 11
let root = new Node(12);
root.left = new Node(8);
root.right = new Node(18);
root.left.left = new Node(5);
root.left.right = new Node(11);
console.log(height(root));
Below is the illustration of above approach:
Example: Consider the following tree -
height(’12’) = max(height(‘8′), height(’18’)) + 1 = 1 + 1 = 2
because recursively:
height(‘8’) = max(height(‘5′), height(’11’)) + 1 = 0 + 1 = 1
height(’18’) = max(height(NULL), height(‘NULL’)) + 1 = (-1) + 1 = 0
height(“5”) = max(height(NULL), height(‘NULL’)) + 1 = (-1) + 1 = 0
height(“11”) = max(height(NULL), height(‘NULL’)) + 1 = (-1) + 1 = 0
[Approach 2] Level Order Traversal - O(n) Time and O(n) Space
If we take a closer look at the breadth first traversal, we can notice that after we process the last node of the current level, the queue contains all the nodes of next level. This is true from the root (or first level) So we get the size of the queue in a loop to count the nodes of every level.
Algorithm:
- Initialize an empty queue
q to store nodes of the tree and a variable depth to keep track of the number of levels. - Push the root node into the queue
q. - While the queue is not empty:
- Store the number of nodes at the current level as
levelSize (the size of the queue). - For each node in the current level (loop from 0 to
levelSize):- Dequeue the front element from the queue (i.e., process the node).
- If the node has a left child, enqueue it.
- If the node has a right child, enqueue it.
- After processing all nodes at the current level, increment the
depth.
- Return
depth - 1 as the number of edges encountered will be one less than number of nodes.
C++
#include <iostream>
#include <queue>
using namespace std;
class Node {
public:
int data;
Node *left, *right;
Node(int val) {
data = val;
left = nullptr;
right = nullptr;
}
};
int height(Node* root) {
if (!root) return 0;
// Initializing a queue to traverse
// the tree level by level
queue<Node*> q;
q.push(root);
int depth = 0;
// Loop until the queue is empty
while (!q.empty()) {
int levelSize = q.size();
// Traverse all nodes at the current level
for (int i = 0; i < levelSize; i++) {
Node* curr = q.front();
q.pop();
if (curr->left) q.push(curr->left);
if (curr->right) q.push(curr->right);
}
// Increment depth after traversing each level
depth++;
}
return depth - 1;
}
int main() {
// Representation of the input tree:
// 12
// / \
// 8 18
// / \
// 5 11
Node *root = new Node(12);
root->left = new Node(8);
root->right = new Node(18);
root->left->left = new Node(5);
root->left->right = new Node(11);
cout << height(root);
return 0;
}
import java.util.LinkedList;
import java.util.Queue;
class Node {
int data;
Node left, right;
Node(int val) {
data = val;
left = null;
right = null;
}
}
class GfG {
static int height(Node root) {
if (root == null) return 0;
// Initializing a queue to traverse
// the tree level by level
Queue<Node> q = new LinkedList<>();
q.add(root);
int depth = 0;
// Loop until the queue is empty
while (!q.isEmpty()) {
int levelSize = q.size();
// Traverse all nodes at the current level
for (int i = 0; i < levelSize; i++) {
Node curr = q.poll();
if (curr.left != null) q.add(curr.left);
if (curr.right != null) q.add(curr.right);
}
// Increment height after traversing each level
depth++;
}
return depth - 1;
}
public static void main(String[] args) {
// Representation of the input tree:
// 12
// / \
// 8 18
// / \
// 5 11
Node root = new Node(12);
root.left = new Node(8);
root.right = new Node(18);
root.left.left = new Node(5);
root.left.right = new Node(11);
System.out.println(height(root));
}
}
from collections import deque
class Node:
def __init__(self, data):
self.data = data
self.left = None
self.right = None
# Function to find the height of the tree
def height(root):
if root is None:
return 0
# Initializing a queue to traverse
# the tree level by level
q = deque([root])
depth = 0
# Loop until the queue is empty
while q:
levelSize = len(q)
# Traverse all nodes at the current level
for _ in range(levelSize):
curr = q.popleft()
if curr.left:
q.append(curr.left)
if curr.right:
q.append(curr.right)
# Increment depth after traversing each level
depth += 1
return depth - 1
if __name__ == "__main__":
# Representation of the input tree:
# 12
# / \
# 8 18
# / \
# 5 11
root = Node(12)
root.left = Node(8)
root.right = Node(18)
root.left.left = Node(5)
root.left.right = Node(11)
print(height(root))
using System;
using System.Collections.Generic;
class Node {
public int data;
public Node left, right;
public Node(int x) {
data = x;
left = null;
right = null;
}
}
class GfG {
static int height(Node root) {
if (root == null) {
return 0;
}
// Initializing a queue to traverse
// the tree level by level
Queue<Node> q = new Queue<Node>();
q.Enqueue(root);
int depth = 0;
// Loop until the queue is empty
while (q.Count > 0) {
int levelSize = q.Count;
// Traverse all nodes at the current level
for (int i = 0; i < levelSize; i++) {
Node curr = q.Dequeue();
if (curr.left != null) {
q.Enqueue(curr.left);
}
if (curr.right != null) {
q.Enqueue(curr.right);
}
}
// Increment depth after traversing
// a level
depth++;
}
return depth - 1;
}
static void Main(string[] args) {
// Representation of the input tree:
// 12
// / \
// 8 18
// / \
// 5 11
Node root = new Node(12);
root.left = new Node(8);
root.right = new Node(18);
root.left.left = new Node(5);
root.left.right = new Node(11);
Console.WriteLine(height(root));
}
}
class Node {
constructor(data) {
this.data = data;
this.left = null;
this.right = null;
}
}
// Function to find the height of the tree
function height(root) {
if (root === null) {
return 0;
}
// Initializing a queue to traverse
// the tree level by level
let queue = [root];
let depth = 0;
// Loop until the queue is empty
while (queue.length > 0) {
let levelSize = queue.length;
// Traverse all nodes at the current level
for (let i = 0; i < levelSize; i++) {
let curr = queue.shift();
if (curr.left) {
queue.push(curr.left);
}
if (curr.right) {
queue.push(curr.right);
}
}
// Increment depth after traversing a level
depth++;
}
return depth - 1;
}
// Representation of the input tree:
// 12
// / \
// 8 18
// / \
// 5 11
let root = new Node(12);
root.left = new Node(8);
root.right = new Node(18);
root.left.left = new Node(5);
root.left.right = new Node(11);
console.log(height(root));
Similar Reads
Binary Tree Data Structure A Binary Tree Data Structure is a hierarchical data structure in which each node has at most two children, referred to as the left child and the right child. It is commonly used in computer science for efficient storage and retrieval of data, with various operations such as insertion, deletion, and
3 min read
Introduction to Binary Tree Binary Tree is a non-linear and hierarchical data structure where each node has at most two children referred to as the left child and the right child. The topmost node in a binary tree is called the root, and the bottom-most nodes are called leaves. Introduction to Binary TreeRepresentation of Bina
15+ min read
Properties of Binary Tree This post explores the fundamental properties of a binary tree, covering its structure, characteristics, and key relationships between nodes, edges, height, and levelsBinary tree representationNote: Height of root node is considered as 0. Properties of Binary Trees1. Maximum Nodes at Level 'l'A bina
4 min read
Applications, Advantages and Disadvantages of Binary Tree A binary tree is a tree that has at most two children for any of its nodes. There are several types of binary trees. To learn more about them please refer to the article on "Types of binary tree" Applications:General ApplicationsDOM in HTML: Binary trees help manage the hierarchical structure of web
2 min read
Binary Tree (Array implementation) Given an array that represents a tree in such a way that array indexes are values in tree nodes and array values give the parent node of that particular index (or node). The value of the root node index would always be -1 as there is no parent for root. Construct the standard linked representation o
6 min read
Maximum Depth of Binary Tree Given a binary tree, the task is to find the maximum depth of the tree. The maximum depth or height of the tree is the number of edges in the tree from the root to the deepest node.Examples:Input: Output: 2Explanation: The longest path from the root (node 12) goes through node 8 to node 5, which has
11 min read
Insertion in a Binary Tree in level order Given a binary tree and a key, the task is to insert the key into the binary tree at the first position available in level order manner.Examples:Input: key = 12 Output: Explanation: Node with value 12 is inserted into the binary tree at the first position available in level order manner.Approach:The
8 min read
Deletion in a Binary Tree Given a binary tree, the task is to delete a given node from it by making sure that the tree shrinks from the bottom (i.e. the deleted node is replaced by the bottom-most and rightmost node). This is different from BST deletion. Here we do not have any order among elements, so we replace them with t
12 min read
Enumeration of Binary Trees A Binary Tree is labeled if every node is assigned a label and a Binary Tree is unlabelled if nodes are not assigned any label. Below two are considered same unlabelled trees o o / \ / \ o o o o Below two are considered different labelled trees A C / \ / \ B C A B How many different Unlabelled Binar
3 min read
Types of Binary Tree