Minimum Depth of Binary Tree

Minimum Depth of Binary Tree - Problem

Given a binary tree, find its minimum depth.

The minimum depth is the number of nodes along the shortest path from the root node down to the nearest leaf node.

Note: A leaf is a node with no children.

Input & Output

Example 1 — Basic Tree

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

› Output: 2

💡 Note: The shortest path is from root 3 to leaf 9, which has depth 2 (3 → 9). The other leaves are at depth 3.

Example 2 — Single Node

$ Input: root = [2]

› Output: 1

💡 Note: The root is also a leaf node, so the minimum depth is 1.

Example 3 — Skewed Tree

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

› Output: 5

💡 Note: This is a right-skewed tree where the only leaf is at depth 5: 2 → 3 → 4 → 5 → 6.

Constraints

The number of nodes in the tree is in the range [0, 10⁵].
-1000 ≤ Node.val ≤ 1000

Visualization

Tap to expand

Asked in

G Google 35 a Amazon 28 M Microsoft 22 Apple 18

The key insight is that BFS finds the minimum depth by exploring level by level, returning immediately when the first leaf is found. The optimal approach uses Breadth-First Search for early termination. Time: O(n), Space: O(w) where w is the maximum width of the tree.

Common Approaches

✓ Breadth-First Search (BFS)

⏱️ Time: O(n) Space: O(w)

Use BFS to traverse the tree level by level. The first leaf node encountered will be at the minimum depth, allowing early termination.

Brute Force DFS

⏱️ Time: O(n) Space: O(h)

Use depth-first search to explore every path from root to leaf, keeping track of the minimum depth found so far. This explores all nodes even after finding shallow leaves.

Breadth-First Search (BFS) — Algorithm Steps

Start with root in queue
Process nodes level by level
Return depth when first leaf is found

Visualization

Tap to expand

Step-by-Step Walkthrough

Level 1

Process root node, add children to queue

Level 2

Process level 2 nodes, find first leaf

Early Return

Return depth as soon as first leaf is found

Code -

solution.c — C

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

struct TreeNode {
    int val;
    struct TreeNode* left;
    struct TreeNode* right;
};

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

static struct TreeNode* nodes[100000];
static int nodeCount = 0;

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

struct TreeNode* buildTree(int* arr, int* isNull, int size) {
    if (size == 0 || isNull[0]) return NULL;
    
    struct TreeNode* root = createNode(arr[0]);
    struct TreeNode* queue[100000];
    int front = 0, rear = 0;
    queue[rear++] = root;
    int i = 1;
    
    while (front < rear && i < size) {
        struct TreeNode* node = queue[front++];
        
        if (i < size && !isNull[i]) {
            node->left = createNode(arr[i]);
            queue[rear++] = node->left;
        }
        i++;
        
        if (i < size && !isNull[i]) {
            node->right = createNode(arr[i]);
            queue[rear++] = node->right;
        }
        i++;
    }
    
    return root;
}

int solution(struct TreeNode* root) {
    if (!root) return 0;
    
    struct QueueNode queue[100000];
    int front = 0, rear = 0;
    
    queue[rear].treeNode = root;
    queue[rear].depth = 1;
    rear++;
    
    while (front < rear) {
        struct QueueNode current = queue[front++];
        struct TreeNode* node = current.treeNode;
        int depth = current.depth;
        
        // If it's a leaf node, return the depth
        if (!node->left && !node->right) {
            return depth;
        }
        
        // Add children to queue with incremented depth
        if (node->left) {
            queue[rear].treeNode = node->left;
            queue[rear].depth = depth + 1;
            rear++;
        }
        if (node->right) {
            queue[rear].treeNode = node->right;
            queue[rear].depth = depth + 1;
            rear++;
        }
    }
    
    return 0;
}

int parseArray(char* line, int* arr, int* isNull) {
    int size = 0;
    char* ptr = line;
    
    // Skip opening bracket
    while (*ptr && *ptr != '[') ptr++;
    if (*ptr) ptr++;
    
    while (*ptr && *ptr != ']') {
        // Skip whitespace and commas
        while (*ptr && (*ptr == ' ' || *ptr == ',' || *ptr == '\t')) ptr++;
        
        if (*ptr == ']') break;
        
        if (strncmp(ptr, "null", 4) == 0) {
            isNull[size] = 1;
            arr[size] = 0;
            ptr += 4;
        } else {
            isNull[size] = 0;
            arr[size] = (int)strtol(ptr, &ptr, 10);
        }
        size++;
        
        // Skip to next element or end
        while (*ptr && *ptr != ',' && *ptr != ']') ptr++;
    }
    
    return size;
}

int main() {
    char line[1000000];
    static int arr[100000];
    static int isNull[100000];
    
    if (fgets(line, sizeof(line), stdin) == NULL) {
        printf("0\n");
        return 0;
    }
    
    int size = parseArray(line, arr, isNull);
    struct TreeNode* root = buildTree(arr, isNull, size);
    printf("%d\n", solution(root));
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

In worst case visits all nodes, but often terminates early

✓ Linear Growth

Space Complexity

O(w)

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

✓ Linear Space

89.2K Views

Medium Frequency

~15 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

Constraints

Visualization

Related Problems

Common Approaches

Breadth-First Search (BFS) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler