Minimum Depth of Binary Tree - Practice Coding Problems

Minimum Depth of Binary Tree - Problem

Given a binary tree, find its minimum depth - the shortest path from root to any leaf node. Think of it as finding the shallowest leaf in the tree!

The minimum depth is the number of nodes along the shortest path from the root node down to the nearest leaf node. Remember: a leaf is a node with no children (both left and right are null).

Key insight: Unlike maximum depth where we always go deep, here we stop as soon as we find the first leaf node. This makes BFS (level-order traversal) particularly elegant for this problem!

Example: In a tree with root having only a left child, which has two children, the minimum depth is 3 (not 2), because we must reach a true leaf.

Input & Output

example_1.py — Basic Binary Tree

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

› Output: 2

💡 Note: The minimum depth is 2, following the path: root → 9 (which is a leaf). Even though there are deeper nodes (15, 7), we only care about the shortest path to ANY leaf.

example_2.py — Skewed Tree

$ Input: root = [2,null,3,null,4,null,5,null,6]

› Output: 5

💡 Note: This is a right-skewed tree where each node only has a right child. The only leaf is node 6, so we must traverse the entire path: 2→3→4→5→6, giving us depth 5.

example_3.py — Single Node

$ Input: root = [1]

› Output: 1

💡 Note: A single node is both the root and a leaf. The minimum depth is 1.

Visualization

Tap to expand

Understanding the Visualization

Start at Peak

Begin at the mountain peak (root node)

Explore Distance 1

Check all locations 1 step away from peak

Explore Distance 2

Check all locations 2 steps away - find first valley!

Stop Early

No need to explore further distances

Key Takeaway

🎯 Key Insight: BFS naturally finds the shortest path first because it explores nodes level by level. The moment we find any leaf node, we know it's at the minimum depth - no need to explore deeper levels!

Time & Space Complexity

Time Complexity

⏱️

O(n)

In worst case, might visit all nodes, but often much better

✓ Linear Growth

Space Complexity

O(w)

Queue stores at most w nodes, where w is maximum width of tree

✓ Linear Space

Constraints

The number of nodes in the tree is in the range [0, 10⁵]
-1000 ≤ Node.val ≤ 1000
Tree can be empty (null root)

Asked in

G Google 42 a Amazon 38 ⊞ Microsoft 31 f Meta 24

The optimal approach uses BFS (Breadth-First Search) to explore the tree level by level. Since BFS naturally finds the shortest path first, we can return immediately when we encounter the first leaf node. This gives us O(n) time complexity in the worst case but often performs much better than DFS since we stop early. The key insight is that the first leaf we find in level-order traversal is guaranteed to be at minimum depth.

Common Approaches

Approach	Time	Space	Notes
✓ BFS Level-Order Traversal (Optimal)	O(n)	O(w)	Use BFS to find the first leaf node encountered, which guarantees minimum depth
Recursive DFS (Brute Force)	O(n)	O(h)	Recursively explore all paths and return the minimum depth found

BFS Level-Order Traversal (Optimal) — Algorithm Steps

Handle edge case: empty tree returns 0
Initialize queue with root and depth 1
While queue is not empty, process current level
For each node, check if it's a leaf (no children)
If leaf found, return current depth immediately
Otherwise, add children to queue for next level
Increment depth for next level

Visualization

Tap to expand

Step-by-Step Walkthrough

Level 1

Start with root at depth 1

Level 2

Process all nodes at depth 2, found leaf!

Early Stop

Return immediately when first leaf found

Code -

solution.c — C

#include <stdlib.h>

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

struct QueueNode {
    struct TreeNode* node;
    int depth;
};

int minDepth(struct TreeNode* root) {
    if (!root) return 0;
    
    struct QueueNode* queue = (struct QueueNode*)malloc(10000 * sizeof(struct QueueNode));
    int front = 0, rear = 0;
    
    queue[rear++] = (struct QueueNode){root, 1};
    
    while (front < rear) {
        struct QueueNode current = queue[front++];
        struct TreeNode* node = current.node;
        int depth = current.depth;
        
        // Check if it's a leaf node
        if (!node->left && !node->right) {
            free(queue);
            return depth;
        }
        
        // Add children to queue
        if (node->left) {
            queue[rear++] = (struct QueueNode){node->left, depth + 1};
        }
        if (node->right) {
            queue[rear++] = (struct QueueNode){node->right, depth + 1};
        }
    }
    
    free(queue);
    return 0; // Should never reach here
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

In worst case, might visit all nodes, but often much better

✓ Linear Growth

Space Complexity

O(w)

Queue stores at most w nodes, where w is maximum width of tree

✓ Linear Space

Constraints

The number of nodes in the tree is in the range [0, 10⁵]
-1000 ≤ Node.val ≤ 1000
Tree can be empty (null root)

52.0K Views

High Frequency

~15 min Avg. Time

1.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

BFS Level-Order Traversal (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler