How do you approach Minimum Depth of Binary Tree?

The mirror of maxDepth is WRONG here: a node with one child must not report depth 1 for its missing side.

What is the time complexity of Minimum Depth of Binary Tree?

Time complexity: O(n) worst case; BFS often exits far earlier.. Space complexity: O(w) for the BFS frontier..

What are common mistakes on Minimum Depth of Binary Tree?

Handling the null node deep in the recursion instead of as the first base case. Returning early from a subtree when the answer needs both sides explored. Confusing height with depth. One counts up from the node, the other down from the root, and the off-by-one is silent.

gitGood.dev

← Back to problems

Minimum Depth of Binary Tree

EasyData Structures

Description

Given a binary tree, return its **minimum depth**: the number of nodes along the shortest path from the root down to the nearest **leaf**. A leaf is a node with no children. The tree is given as a **level-order array with explicit nulls**, where the children of index `i` sit at `2i + 1` and `2i + 2`. An empty array is an empty tree.

Example 1

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

Output: 2

Example 2

Input: root = [2,null,3,null,null,null,4]

Output: 3

Example 3

Input: root = []

Output: 0

Constraints

- 0 <= number of nodes <= 10^5 - An empty tree has minimum depth 0. - A node with exactly one child is NOT a leaf.

Minimum Depth of Binary Tree: approach, complexity and pitfalls

An easy trees problem, graded against 6 test cases (3 of them hidden).

The pattern: Trees

Recursive traversal of binary trees and BSTs - depth, validation, and path problems.

Reach for it when you see: A TreeNode input, or anything about depth, ancestry, or in-order ordering.

More Treesproblems →

If you are stuck

Show the 3-step hint ladder

The mirror of maxDepth is WRONG here: a node with one child must not report depth 1 for its missing side.
Only a node with no children at all counts as a leaf and terminates the path.
BFS is the natural fit - the first leaf you reach level by level is the shallowest, so you can return immediately without exploring the rest.

The optimal approach

Show the approach: Not the mirror image of maximum depth

The instinct is to copy `maxDepth` and swap `max` for `min`. That is wrong, and the failing case is a node with exactly one child: the missing side returns 0, `min` picks it, and the node reports depth 1 as though it were a leaf. A right-leaning chain would report 1 instead of its true depth.

The fix is to respect the definition - only a node with no children terminates a path. When exactly one child exists, you must descend into that child and ignore the empty side.

BFS avoids the special case more elegantly and is faster in the common case. Traversing level by level, the first node encountered with no children is by construction at the minimum depth, so you can return immediately - no need to explore a deep subtree that cannot contain a shallower leaf. On a tree with a shallow leaf near the root and a huge subtree elsewhere, that is the difference between reading a handful of nodes and reading all of them.

Time: O(n) worst case; BFS often exits far earlier.
Space: O(w) for the BFS frontier.

The full reference solution in every supported language stays in the editor above - reveal it there once you have had a real attempt.

What the tests check

Read off this problem's own test suite, so these are the cases a submission actually has to survive.

Empty input. At least one case passes an empty collection. Make sure your loop bounds and any "first element" read survive a length of zero.
Single element. A one-element case is included. Two-pointer and window solutions frequently return the wrong thing when the two indices start out equal.
Duplicate values. Repeated values appear in the input, so any logic that assumes distinct elements - or that skips over equal neighbours - is exercised.
Null values. A null appears in the input. Guard your dereferences rather than relying on the shape of the sample case.

Common Trees mistakes

These apply to the pattern as a whole, not just this problem.

Handling the null node deep in the recursion instead of as the first base case.
Returning early from a subtree when the answer needs both sides explored.
Confusing height with depth. One counts up from the node, the other down from the root, and the off-by-one is silent.