Binary Tree Interview Questions: Patterns and Templates (2026)

Binary tree interview questions test whether you can define a recursive subproblem and combine results correctly. Nearly every one of them, from Maximum Depth to Serialize and Deserialize Binary Tree, is solved by one of five templates: top-down DFS, bottom-up DFS, BFS level order, BST ordering, or divide-and-construct. If you can name the template within the first two minutes, the rest is filling in the blanks.

This guide gives you the vocabulary, the five templates in Python, and a table mapping 30 common tree problems to the template that solves each.

Key Takeaways

• Five templates cover almost all binary tree interview questions. Pick the template first, then write code.
• The core decision is direction: does a node need information from its ancestors (top-down) or from its descendants (bottom-up)?
• Bottom-up problems often track two values: what the function returns to its parent, and a global best that it updates on the side. Diameter and Maximum Path Sum both work this way.
• BST problems are about ordering: inorder traversal yields sorted values, and min/max bounds validate structure.
• Most tree solutions are O(n) time and O(h) space. Say "h is log n if balanced, n if skewed" to show you know the difference.

What Tree Terms and Traversals Do You Need to Know?

A binary tree is a hierarchical structure in which every node has at most two children, called left and right. Interviewers assume you know the vocabulary and will not stop to define it, so get it straight before your first round.

Conventions vary: LeetCode's Maximum Depth counts nodes, so a single node has depth 1. State yours out loud.

A tree traversal is an order for visiting every node exactly once. There are four you must know:

• Preorder (node, left, right): process a node before its children. Used for copying and serializing trees.
• Inorder (left, node, right): on a BST, this visits values in sorted order.
• Postorder (left, right, node): process children before the parent. This is the shape of every bottom-up solution.
• Level order: visit nodes level by level using a queue. This is BFS.

The first three are all depth-first search. The only difference is where the "process node" line sits relative to the two recursive calls:

class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

def traverse(node, out):
    if not node:
        return
    # preorder: out.append(node.val) here
    traverse(node.left, out)
    # inorder: out.append(node.val) here
    traverse(node.right, out)
    # postorder: out.append(node.val) here

For iterative traversal, use the inorder loop in the BST section below. For a broader refresher on recursion itself, see our recursion and backtracking interview guide.

Template 1: Top-Down DFS (Pass State Down)

Top-down DFS is a recursion where each call receives information from its ancestors through parameters and uses it at the current node. Think of it as preorder with extra arguments.

Use it when the answer at a node depends on the path from the root: a running sum, the maximum value seen so far, the current depth, or an allowed value range.

def count_good_nodes(root):
    def dfs(node, max_so_far):
        if not node:
            return 0
        good = 1 if node.val >= max_so_far else 0
        new_max = max(max_so_far, node.val)
        return good + dfs(node.left, new_max) + dfs(node.right, new_max)
    return dfs(root, float("-inf"))

This is Count Good Nodes in Binary Tree (1448). A node is "good" if no ancestor has a larger value, so each call needs to know the largest value on the path above it. That fact can only flow downward.

The same skeleton solves Path Sum (112): pass remaining = target - node.val down, and check remaining == 0 at a leaf. For Path Sum II (113), also pass a path list: append before recursing, pop afterward. That is backtracking.

Common bug: checking the target at a null node instead of at a leaf. A node with one child is not a leaf, and testing at null will count paths that stop halfway down.

Template 2: Bottom-Up DFS (The Recursive Return-Value Pattern)

Bottom-up DFS is a recursion where each call returns a summary of its subtree, and the parent computes its own answer from its children's return values. It is postorder traversal with a return value, and it is the single most important pattern for binary tree interview questions.

Before writing any code, answer one question: "What should this function return about the subtree rooted at node?" Height, sum, is-balanced, or "the target node if found here." Once that is precise, the code nearly writes itself.

def max_depth(root):
    if not root:
        return 0
    return 1 + max(max_depth(root.left), max_depth(root.right))

The return-versus-record split

Harder bottom-up problems separate two things: the value you return to the parent and the answer you record globally. Diameter of Binary Tree (543) is the classic example. The longest path may bend through a node, using both children, but a parent can only extend a path that comes up through one child.

def diameter_of_binary_tree(root):
    best = 0
    def height(node):
        nonlocal best
        if not node:
            return 0
        left = height(node.left)
        right = height(node.right)
        best = max(best, left + right)
        return 1 + max(left, right)
    height(root)
    return best

The function returns a one-sided height but records a two-sided path. Binary Tree Maximum Path Sum (124), a LeetCode Hard, is the same code with two tweaks: use node values instead of edge counts, and clamp negative child contributions to zero with max(0, left). If you understand why Diameter works, Max Path Sum stops being hard.

Lowest common ancestor

The lowest common ancestor (LCA) of two nodes is the deepest node that has both as descendants, where a node counts as its own descendant. LCA of a Binary Tree (236) uses the return value as a signal: "a target node I found below me, or null."

def lowest_common_ancestor(root, p, q):
    if not root or root is p or root is q:
        return root
    left = lowest_common_ancestor(root.left, p, q)
    right = lowest_common_ancestor(root.right, p, q)
    if left and right:
        return root
    return left or right

If both subtrees report a hit, the current node is where the two paths split, so it is the answer. This relies on the problem's guarantee that both nodes exist in the tree. If an interviewer removes that guarantee, you need to count matches rather than return early, which is a common follow-up.

When top-down fails, try bottom-up. Balanced Binary Tree (110) solved top-down calls height from every node, which is O(n²) on a skewed tree. Solved bottom-up, returning height or -1 for "unbalanced," it is O(n).

Template 3: BFS Level Order

BFS level order is an iterative traversal that processes the tree one level at a time using a queue. The key trick is to snapshot the queue length at the start of each level, so you know exactly which nodes belong to it.

from collections import deque

def level_order(root):
    if not root:
        return []
    result = []
    queue = deque([root])
    while queue:
        level = []
        for _ in range(len(queue)):
            node = queue.popleft()
            level.append(node.val)
            if node.left:
                queue.append(node.left)
            if node.right:
                queue.append(node.right)
        result.append(level)
    return result

Use it when the problem mentions levels, rows, depth-by-depth output, "closest to the root," or "minimum depth." Most variations change only what you do with each level list:

• Binary Tree Right Side View (199): keep the last value of each level.
• Zigzag Level Order (103): reverse every other level.
• Minimum Depth (111): return the depth of the first leaf you dequeue. BFS beats DFS here because it can stop early.
• Maximum Width (662): store (node, index) pairs where children get 2*i and 2*i + 1, and take last index minus first index plus one per level.

This queue-based structure is the same BFS you use on graphs, covered in our graph algorithms coding interview guide.

Template 4: BST Techniques (Ordering and Bounds)

A binary search tree interview question almost always wants you to use the ordering property. If you solve a BST problem with generic tree code that ignores ordering, expect the interviewer to ask, "Can you use the fact that it is a BST?"

Three techniques cover nearly all of them.

1. Inorder gives sorted order. Kth Smallest Element in a BST (230) is an inorder traversal that stops at the kth node. The iterative form lets you stop early cleanly:

def kth_smallest(root, k):
    stack = []
    node = root
    while stack or node:
        while node:
            stack.append(node)
            node = node.left
        node = stack.pop()
        k -= 1
        if k == 0:
            return node.val
        node = node.right

The same loop powers BST Iterator (173) and Minimum Absolute Difference in BST (530).

2. Bounds validate structure. Validate Binary Search Tree (98) is a top-down problem. Comparing a node only to its direct children is the classic wrong answer, because a value deep in the left subtree must still be less than the root. Pass an allowed (low, high) range down instead:

def is_valid_bst(root):
    def valid(node, low, high):
        if not node:
            return True
        if not (low < node.val < high):
            return False
        return valid(node.left, low, node.val) and valid(node.right, node.val, high)
    return valid(root, float("-inf"), float("inf"))

3. Walk one path, not the whole tree. Search, insert, and LCA of a BST (235) only need one root-to-node path, so they run in O(h). For LCA, if both values are smaller than the current node go left, if both are larger go right, and otherwise you are at the split point.

Template 5: Serialization and Construction (Divide and Construct)

Construction problems build a tree from a description, and serialization problems turn a tree into a string and back. Both use divide and conquer: identify the root, split the remaining input into left and right parts, and recurse.

Construct from Preorder and Inorder (105). Preorder's first element is the root. Find it in the inorder array: everything to its left forms the left subtree, everything to its right forms the right subtree. Use a hash map from value to inorder index so each lookup is O(1), giving O(n) total instead of O(n²).

def build_tree(preorder, inorder):
    index = {val: i for i, val in enumerate(inorder)}
    pre_iter = iter(preorder)
    def build(lo, hi):
        if lo > hi:
            return None
        val = next(pre_iter)
        node = TreeNode(val)
        mid = index[val]
        node.left = build(lo, mid - 1)
        node.right = build(mid + 1, hi)
        return node
    return build(0, len(inorder) - 1)

Building the left subtree before the right matters, because that is the order in which preorder hands out values. The postorder-and-inorder version (106) consumes postorder from the end and builds right before left. This approach assumes unique values, which is worth confirming with your interviewer.

Serialize and Deserialize Binary Tree (297). Write a preorder traversal that emits a marker such as # for null children. The null markers make the encoding unambiguous, so a single traversal is enough to rebuild the tree.

def serialize(root):
    out = []
    def dfs(node):
        if not node:
            out.append("#")
            return
        out.append(str(node.val))
        dfs(node.left)
        dfs(node.right)
    dfs(root)
    return ",".join(out)

def deserialize(data):
    vals = iter(data.split(","))
    def build():
        val = next(vals)
        if val == "#":
            return None
        node = TreeNode(int(val))
        node.left = build()
        node.right = build()
        return node
    return build()

For a BST (449), you can drop the null markers, since preorder plus the bounds technique from Template 4 is enough to rebuild the tree.

Practice Mapping Table: 30 Tree Questions to 5 Templates

Use this table in two passes. First, solve problems by template to build fluency. Then shuffle the list and name the template before writing code. Problem numbers refer to LeetCode.

A few entries mix templates. Path Sum III combines top-down DFS with the prefix-sum hash map from our coding interview patterns cheat sheet. House Robber III is tree DP: returning a pair of values per node is the bottom-up template applied to an optimization problem, which our dynamic programming patterns guide covers under tree DP.

Many of these appear on the standard curated lists; our comparison of Blind 75, NeetCode 150, and Grind 75 helps you pick one.

How Should You Approach a Tree Question in the Interview?

Name the template before you write a line of code. A short routine keeps you from coding in the wrong direction:

1. Clarify the node shape and edge cases. Can the tree be empty? Are values unique? Can they be negative? Negative values change Max Path Sum and break many "early exit" tricks.
2. Ask the direction question. Does a node need its ancestors' context (top-down), its children's results (bottom-up), or its level (BFS)? Is the tree a BST?
3. Define the function's contract in one sentence. "Returns the height of this subtree, or -1 if it is unbalanced." Say it out loud. Our guide on how to think out loud in a coding interview explains why this narration matters as much as the code.
4. Write the base case first. Usually if not node: return <identity value>.
5. Trace a three-node example. Walk through a root with two leaves before you claim the code works.
6. State complexity. O(n) time, O(h) space for DFS, O(w) for BFS. If you need a refresher on the notation, use our Big O notation cheat sheet.

If step 2 stalls, try both directions on the three-node example. For more recovery tactics, see what to do when you are stuck in a coding interview.