236. Lowest Common Ancestor of a Binary Tree

Problem Statement

You’re given the root of a binary tree and two distinct nodes p and q that are guaranteed to exist in the tree. Your task is to return the node that is their lowest common ancestor: the deepest node in the tree that has both p and q somewhere in its subtree (and a node counts as being in its own subtree).

This can be trickier than it looks because the ancestor might be one of the nodes themselves, and p and q can lie on different sides of the tree at unknown depths. A naive “walk upward” idea isn’t directly available unless you build extra parent information, and brute searching from every node repeats the same subtree work many times.

Constraints:

• The number of nodes in the tree is in the range $[2, 10^5]$.
• $-10^9 \leq$ Node.val $\leq 10^9$
• All Node.val are unique.
• p $!=$ q
• p and q will exist in the tree.

Examples

1 / 4

The Problem With Checking Every Subtree

A straightforward idea is: for every node, check whether p and q are both somewhere in its subtree, and pick the deepest such node. The issue is that “is X in this subtree?” is itself a traversal, so repeating it for many nodes causes a lot of repeated work. On a large tree (up to $10^5$ nodes), doing subtree searches repeatedly can explode to quadratic time. The repeated work comes from re-walking the same branches over and over: many candidate ancestors share big overlapping portions of the tree, yet a naive method re-computes membership for those portions each time.

Optimized Approach Using Postorder DFS

The key is to traverse bottom-up and let each subtree report what it contains. When exploring a node, you only need to know whether the left subtree contains p or q, and whether the right subtree contains p or q. If both sides report a “hit,” then the current node is the lowest place where the two targets come together, so it must be the LCA. This approach feels inevitable once you notice that the LCA is precisely the first node (from the bottom) where paths to p and q merge. A postorder traversal naturally surfaces that merge point because it processes children before parents.

Why this works even when one node is an ancestor of the other
A common mistake is to assume the LCA must be strictly above both nodes. But the definition allows a node to be a descendant of itself. In the bottom-up reporting approach, if the current node is p (or q), it reports itself upward. If the other target is somewhere below it, that information will come back through one subtree, and the algorithm correctly returns the current node as the merge point.

Solution Steps

Below are the step-by-step instructions to implement the greedy solution:

1. If root is None, return None.
2. If root is p or q, return root.
3. Recursively compute left = lowestCommonAncestor(root.left, p, q).
4. Recursively compute right = lowestCommonAncestor(root.right, p, q).
5. If both left and right are not None, return root (this is where p and q split across subtrees).
6. Otherwise, return left if it’s not None, else return right.

Let’s look at the following illustration to get a better understanding of the solution.

1 / 11

Python Implementation

Let’s look at the code for the solution we just discussed.

from queue import Queue
from collections import *

def lowestCommonAncestor(root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
    # Base case: empty subtree
    if root is None:
        return None

    # If we hit one of the target nodes, bubble it up
    if root is p or root is q:
        return root

    # Search left and right subtrees
    left = lowestCommonAncestor(root.left, p, q)
    right = lowestCommonAncestor(root.right, p, q)

    # If both sides found something, current node is the LCA
    if left is not None and right is not None:
        return root

    # Otherwise return whichever side found a target (or None)
    return left if left is not None else right

class TreeNode:
    def __init__(self, data):
        self.data = data
        self.left = None
        self.right = None
        
class BinaryTree:
    def __init__(self, nodes):
        self.root = self.createBinaryTree(nodes)

    def createBinaryTree(self, nodes):
        if len(nodes) == 0:
            return None

        # Create the root node of the binary tree
        root = TreeNode(nodes[0].data)

        # Create a queue and add the root node to it
        queue = Queue()
        queue.put(root)

        # Start iterating over the list of nodes starting from the second node
        i = 1
        while i < len(nodes):
            # Get the next node from the queue
            curr = queue.get()

            # If the node is not None, create a new TreeNode object for its left child,
            # set it as the left child of the current node, and add it to the queue
            if nodes[i] is not None:
                curr.left = TreeNode(nodes[i].data)
                queue.put(curr.left)

            i += 1

            # If there are more nodes in the list and the next node is not None,
            # create a new TreeNode object for its right child, set it as the right child
            # of the current node, and add it to the queue
            if i < len(nodes) and nodes[i] is not None:
                curr.right = TreeNode(nodes[i].data)
                queue.put(curr.right)

            i += 1

        # Return the root of the binary tree
        return root

    # function to find a node given the value stored in the node
    def find(self, value):
        q = deque([self.root])
        while q:
            currentNode = q.popleft()
            if currentNode:
                if currentNode.data == value:
                    return currentNode
                q.append(currentNode.left)
                q.append(currentNode.right)
            if all(val == None for val in q):
                break
        return None
        
    def levelOrder(self):
        """Return tree values in level-order as a Python list."""
        if self.root is None:
            return []
    
        result = []
        q = deque([self.root])
    
        while q:
            node = q.popleft()
            result.append(node.data)
            if node.left:
                q.append(node.left)
            if node.right:
                q.append(node.right)
    
        return result
            
# driver code   
def main():
    input_trees = [[TreeNode(100), TreeNode(50), TreeNode(200), TreeNode(25), TreeNode(75), TreeNode(350)],
        [TreeNode(100), TreeNode(200), TreeNode(75), TreeNode(50), TreeNode(25), TreeNode(350)],
        [TreeNode(350), TreeNode(100), TreeNode(75), TreeNode(50), TreeNode(200), TreeNode(25)],
        [TreeNode(100), TreeNode(50), TreeNode(200), TreeNode(25), TreeNode(75), TreeNode(350)],
        [TreeNode(25), TreeNode(50), TreeNode(75), TreeNode(100), TreeNode(200), TreeNode(350)]]
    
    input_nodes = [
        [25, 75],
        [50, 350],
        [100, 200],
        [50, 25],
        [350, 200]
    ]

    for i in range(len(input_trees)):
        tree = BinaryTree(input_trees[i])
        print(i+1, ".\tBinary tree:", tree.levelOrder())
        print("\tp = ", input_nodes[i][0])
        print("\tq = ", input_nodes[i][1])
        lca = lowestCommonAncestor(tree.root, tree.find(input_nodes[i][0]), tree.find(input_nodes[i][1]))
        print("\n\tLowest common ancestor: ", lca.data, sep="")
        print("-"*75)

if __name__ == "__main__":
    main()

Time Complexity

The time complexity is $O(n)$ because each node is visited at most once, and the work done per node is constant aside from the two recursive calls.

Space Complexity

The space complexity is $O(h)$ in the worst case due to the recursion stack, where $h$ is the height of the tree. In a skewed tree, $h$ can be $n$, so worst-case stack usage is linear in the number of nodes.

Edge Cases

Below are special cases you should verify your solution handles correctly.

• One node is the ancestor of the other
  Input: p $= 5$, q $= 4$ in root $= [3,5,1,6,2,0,8,null,null,7,4]$
  Why it works: when recursion reaches p, it returns p, and that value bubbles up, making p the merge point when the other node is found below it.
• Targets are in different subtrees of the root
  Input: p $= 5$, q $= 1$ in root $=[3,5,1,…]$
  Why it works: left recursion returns $5$, right recursion returns $1$, so the root returns itself as the first node combining both.
• Very small tree
  Input: root $= [1,2]$, p $= 1$, q $= 2$
  Why it works: hitting p returns it immediately, and the other target found in a child makes p the correct LCA.
• Highly unbalanced tree (linked-list shaped)
  Small example: $1−>2−>3−>4$, p $= 3$, q $= 4$
  Why it works: recursion still bubbles up the first shared node; only the recursion depth grows.

Common Pitfalls

Below are common mistakes to avoid while implementing the solution.

• Comparing by value instead of node identity: in many interview setups, p and q are node references, not just values. Use root is p / root is q (or pointer equality) rather than root.val == p.val.
• Forgetting the “node can be a descendant of itself” rule: leads to returning the parent of the correct LCA when one node is an ancestor of the other.
• Trying to build full root-to-node paths unnecessarily: it can work, but is easy to implement incorrectly and can add extra memory and bookkeeping.
• Not considering recursion depth for $10^5$ nodes: in Python, a skewed tree can exceed the recursion limit. In interviews, mentioning an iterative variant is often appreciated (even if you code the recursive one).