Find The Depth of a Binary Tree – Tech Interview Dot Org

How will you find the depth of a binary tree?

💡Strategies for Solving This Problem

Easier Than It Sounds

This is usually a warm-up question. I've seen it at Google, Microsoft, and smaller companies. Don't overthink it.

What They're Testing

Can you think recursively? That's it. Binary tree problems are all about recursion or level-order traversal.

Approach 1: Recursive (The Standard Answer)

The depth of a tree is: 1 + max(depth of left, depth of right). This screams recursion.

Base case: empty tree has depth 0. Recursive case: 1 + deeper subtree.

This is what 90% of people use and what interviewers expect.

Approach 2: Iterative (BFS)

Use a queue and do level-order traversal. Count how many levels you process. More code, same result.

Only use this if:

Interviewer specifically asks for iterative
You're worried about stack overflow (very deep trees)
You want to show you know BFS

Don't Do This

I once saw someone try to solve this iteratively with a stack (DFS). It works but requires tracking depths manually. Way more complex than needed.

Time Complexity

Both approaches: O(n) where n is number of nodes. You have to visit every node to know the max depth.

Quick tip: If interviewer says "find depth," start coding the recursive solution immediately. It's 5 lines.

✅Solution

Solution: Recursive (Clean and Simple)

function maxDepth(root) {
    // Base case: empty tree
    if (root === null) {
        return 0;
    }

    // Recursive case
    let leftDepth = maxDepth(root.left);
    let rightDepth = maxDepth(root.right);

    return 1 + Math.max(leftDepth, rightDepth);
}

// Even more concise version
function maxDepthConcise(root) {
    if (!root) return 0;
    return 1 + Math.max(maxDepth(root.left), maxDepth(root.right));
}

// Test tree:
//       1
//      / 
//     2   3
//    /
//   4

let tree = {
    val: 1,
    left: {
        val: 2,
        left: { val: 4, left: null, right: null },
        right: null
    },
    right: { val: 3, left: null, right: null }
};

console.log(maxDepth(tree));  // 3

How It Works

Start at root
Recursively find depth of left subtree
Recursively find depth of right subtree
Current depth = 1 (current node) + deeper subtree

The recursion naturally handles the tree structure. You don't need to track anything.

Iterative Solution (BFS)

function maxDepthIterative(root) {
    if (!root) return 0;

    let queue = [root];
    let depth = 0;

    while (queue.length > 0) {
        let levelSize = queue.length;
        depth++;

        // Process all nodes at current level
        for (let i = 0; i < levelSize; i++) {
            let node = queue.shift();

            if (node.left) queue.push(node.left);
            if (node.right) queue.push(node.right);
        }
    }

    return depth;
}

This processes the tree level by level, counting how many levels exist.

When I Use Each Approach

Recursive: Default choice. Clean, easy to explain, what interviewers expect.

Iterative: Only when:

Interviewer asks for it specifically
Tree might be extremely deep (risk of stack overflow)
You need to show you understand BFS

Complexity

Time: O(n) - Must visit every node
Space:
- Recursive: O(h) where h is height (call stack)
- Iterative: O(w) where w is max width of tree (queue)

For balanced tree: height ≈ log(n), so recursive is O(log n) space.
For skewed tree: height = n, so recursive is O(n) space.

Common Mistake

I've seen people overthink this. They try to use a global variable or pass depth as a parameter. Don't. The recursive solution is simpler.

Also: Make sure you return 0 for null, not -1. Some definitions vary but most interviews expect 0.