← Back to problems Solve on LeetCode → ◆ Tree Patterns See #111 Min Depth →

Maximum Depth of Binary Tree

BFS — Level-by-Level Depth Counting

LeetCode 104 • Easy • Trees

Input: root = [3, 9, 20, null, null, 15, 7] → Output: 3
The maximum depth is the number of nodes along the longest path from root to the farthest leaf.

Time O(n) visit each node once

Space O(n) queue holds widest level

Visited: 0/5 Queue: 0 Depth: 0

Processing

In Queue

Processed

Edge highlight

Queue

empty

Depth

Speed:

Ready

Press Play to watch BFS count depth level-by-level, or Step to advance one operation at a time.
Each time we fully process a level, depth += 1.

✎ Whiteboard

Size: 3

⌨ Type It — Build Muscle Memory

Practice until you don't need to look. Use the guide comments below as scaffolding. Type the full implementation in the editor. The green highlights are the nuances to burn into memory.

# ─── MAXIMUM DEPTH (LeetCode 104) ───

# Pattern: BFS + level counting

# Time: O(n) Space: O(n)

# 1. Import: from collections import deque

# 2. Define: maxDepth(self, root)

# Base case: if not root: return 0

# 3. Init data structures:

# queue = deque([root]) ← BFS queue starts with root

# depth = 0 ← counts levels processed

# 4. BFS loop: while queue:

# Snapshot level size: level_size = len(queue)

# KEY LINE: depth += 1 ← increment BEFORE processing

# 5. Process each node in level:

# for i in range(level_size):

# node = queue.popleft() ← O(1) dequeue

# if node.left: queue.append(node.left)

# if node.right: queue.append(node.right)

# 6. Return: return depth

# No result array needed — just count levels!

# Vars: queue (deque), depth (int), node

# vs DFS: BFS counts levels naturally; DFS uses max(left, right) + 1

▼ your implementation ▼

Verify your solution:

⌨ Type It — Recursive DFS

Practice until you don't need to look. The green highlights are the nuances to burn into memory.

═══ MAX DEPTH — RECURSIVE DFS ═══

PATTERN ▸ Post-order DFS O(n) · O(h)

① BASE CASE

if not root: return 0

② RECURSE BOTH SUBTREES

left = self.maxDepth(root.left)

right = self.maxDepth(root.right)

③ COMBINE

return 1 + max(left, right)

▼ your implementation ▼

Verify your solution: