Introduction

LeetCode 104 – Maximum Depth of Binary Tree is one of the most important beginner tree problems in Data Structures and Algorithms.

This problem teaches:

1. Binary Tree Traversal
2. Depth First Search (DFS)
3. Recursion
4. Tree Height Calculation
5. Divide and Conquer

It is one of the most frequently asked tree questions in coding interviews because it builds the foundation for:

1. Tree recursion
2. Height problems
3. Balanced tree problems
4. Diameter problems
5. DFS traversal

If you are starting binary trees, this is one of the best problems to master first.

Problem Link

🔗 https://leetcode.com/problems/maximum-depth-of-binary-tree/

Problem Statement

Given the root of a binary tree:

Return:

Maximum depth means:

Number of nodes along the longest path from root to the farthest leaf node.

Example 1

Input

Tree:

Output

Explanation:

Longest path:

contains:

Example 2

Input

Tree:

Output:

Understanding Maximum Depth

Depth means:

For example:

Levels:

Maximum depth:

Key Observation

The depth of a tree depends on:

So:

This is the core recursive formula.

Recursive Intuition

At every node:

1. Find depth of left subtree
2. Find depth of right subtree
3. Take maximum
4. Add current node

This naturally becomes a recursive DFS problem.

Java Recursive Solution

Why This Works

At every node:

1. Recursively calculate left depth
2. Recursively calculate right depth
3. Choose bigger depth
4. Add:

for current node.

This continues until leaf nodes.

Dry Run

Input

Step 1

Start from root:

Step 2

Left subtree:

Depth:

Step 3

Right subtree:

Its children:

Depth becomes:

Step 4

At root:

Result:

Recursive Call Flow

Then values return upward.

Alternative BFS Approach

We can also solve this using:

using a queue.

Every level increases depth by:

BFS Java Solution

DFS vs BFS

Time Complexity Analysis

Recursive DFS Solution

Time Complexity

because every node is visited once.

Space Complexity

where:

Worst case:

for skewed tree.

BFS Solution

Time Complexity

Space Complexity

queue may contain full level.

Interview Explanation

In interviews, explain:

The depth of a node depends on the maximum depth between its left and right subtree. This naturally forms a recursive divide-and-conquer problem.

This demonstrates:

1. Tree recursion understanding
2. DFS traversal knowledge
3. Divide and conquer thinking

Common Mistakes

1. Forgetting Base Case

Always handle:

2. Using Min Instead of Max

We need:

not shortest.

3. Incorrect Depth Counting

Remember to add:

for current node.

FAQs

Q1. What is maximum depth?

It is the number of nodes in the longest root-to-leaf path.

Q2. Why is recursion preferred?

Tree problems naturally fit recursive structures.

Q3. Can this be solved iteratively?

Yes.

Using BFS with queue.

Q4. Is this problem important for interviews?

Very important.

It is one of the most fundamental tree recursion problems.

Related Problems

After mastering this problem, practice:

1. Minimum Depth of Binary Tree
2. Balanced Binary Tree
3. Diameter of Binary Tree
4. Binary Tree Level Order Traversal
5. Path Sum

Conclusion

LeetCode 104 is one of the most important beginner binary tree problems.

It teaches:

1. Recursive DFS
2. Tree height calculation
3. Divide and conquer
4. Binary tree traversal

The key insight is:

Maximum depth equals 1 + maximum depth of left and right subtree.

Once this recursive pattern becomes clear, many advanced tree problems become easier to solve.