Maximum Depth of Binary Tree - Practice Coding Problems

Maximum Depth of Binary Tree - Problem

Given the root of a binary tree, return its maximum depth.

A binary tree's maximum depth is the number of nodes along the longest path from the root node down to the farthest leaf node. Think of it as measuring how "tall" your tree is - counting every level from top to bottom.

Example: If you have a tree that goes Root → Child → Grandchild, that's a depth of 3 nodes.

Note: An empty tree has a depth of 0, and a single node has a depth of 1.

Input & Output

example_1.py — Standard Binary Tree

$ Input: root = [3,9,20,null,null,15,7]

› Output: 3

💡 Note: The tree has 3 levels: root(3) → level 2(9,20) → level 3(15,7). The maximum depth is 3.

example_2.py — Single Path Tree

$ Input: root = [1,null,2]

› Output: 2

💡 Note: The tree has only a right path: 1 → 2. The maximum depth is 2 nodes along this path.

example_3.py — Single Node

$ Input: root = [5]

› Output: 1

💡 Note: A tree with just one node (the root) has a depth of 1.

Visualization

Tap to expand

Understanding the Visualization

Start at leaf level

Childless nodes (leaves) represent generation 1 - they have depth 1

Build upward

Each parent's generation depth = 1 + max(children's depths)

Propagate to root

This calculation bubbles up to the root, giving total tree depth

Handle edge cases

Empty tree has depth 0, single node has depth 1

Key Takeaway

🎯 Key Insight: Each node only needs to know its children's maximum depth and add 1 - the recursive structure naturally solves the problem!

Time & Space Complexity

Time Complexity

⏱️

O(n)

We visit each node exactly once in the tree

✓ Linear Growth

Space Complexity

O(h)

Recursion stack depth equals tree height h. O(log n) for balanced tree, O(n) for skewed tree

✓ Linear Space

Constraints

The number of nodes in the tree is in the range [0, 10⁴]
-100 ≤ Node.val ≤ 100
Tree depth will not exceed typical recursion stack limits

Asked in

G Google 65 a Amazon 58 ⊞ Microsoft 42 f Meta 38

The optimal recursive solution leverages the key insight that a tree's depth equals 1 + maximum depth of its subtrees. This elegant approach runs in O(n) time visiting each node once, with O(h) space for recursion stack. Alternative BFS iterative solution avoids recursion using level-by-level traversal with the same time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Level-by-Level BFS (Iterative)	O(n)	O(w)	Use queue to traverse level by level, counting levels until no more nodes remain
Recursive DFS (Optimal)	O(n)	O(h)	Use recursion with the insight that depth = 1 + max(left_depth, right_depth)
Brute Force (All Path Enumeration)	O(n²)	O(n²)	Generate all root-to-leaf paths and find the longest one

Level-by-Level BFS (Iterative) — Algorithm Steps

Initialize queue with root node
While queue is not empty, process current level
Count nodes in current level and process them
Add children of current level nodes to queue
Increment depth counter for each level processed

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with root

Add root to queue, depth = 0

Process level 1

Process root, add its children, depth = 1

Process level 2

Process nodes 9 and 20, add their children, depth = 2

Process level 3

Process nodes 15 and 7, no more children, depth = 3

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

// Definition for a binary tree node.
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
};

struct TreeNode* createNode(int val) {
    struct TreeNode* node = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    node->val = val;
    node->left = NULL;
    node->right = NULL;
    return node;
}

// Simple queue implementation
struct Queue {
    struct TreeNode* nodes[10000];
    int front, rear;
};

void initQueue(struct Queue* q) {
    q->front = 0;
    q->rear = 0;
}

void enqueue(struct Queue* q, struct TreeNode* node) {
    q->nodes[q->rear++] = node;
}

struct TreeNode* dequeue(struct Queue* q) {
    return q->nodes[q->front++];
}

int isEmpty(struct Queue* q) {
    return q->front == q->rear;
}

int size(struct Queue* q) {
    return q->rear - q->front;
}

int maxDepth(struct TreeNode* root) {
    if (!root) return 0;
    
    struct Queue queue;
    initQueue(&queue);
    enqueue(&queue, root);
    int depth = 0;
    
    while (!isEmpty(&queue)) {
        depth++;
        int levelSize = size(&queue);
        
        // Process all nodes at current level
        for (int i = 0; i < levelSize; i++) {
            struct TreeNode* node = dequeue(&queue);
            
            // Add children for next level
            if (node->left) enqueue(&queue, node->left);
            if (node->right) enqueue(&queue, node->right);
        }
    }
    
    return depth;
}

int main() {
    struct TreeNode* root = createNode(3);
    root->left = createNode(9);
    root->right = createNode(20);
    root->right->left = createNode(15);
    root->right->right = createNode(7);
    
    printf("%d\n", maxDepth(root)); // Output: 3
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We visit each node exactly once during the BFS traversal

✓ Linear Growth

Space Complexity

O(w)

Queue space equals maximum width w of tree, which is O(n) in worst case (completely unbalanced tree)

✓ Linear Space

Constraints

The number of nodes in the tree is in the range [0, 10⁴]
-100 ≤ Node.val ≤ 100
Tree depth will not exceed typical recursion stack limits

89.4K Views

Very High Frequency

~8 min Avg. Time

2.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Level-by-Level BFS (Iterative) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler