Lowest Common Ancestor of a Binary Tree - Practice Coding Problems

Lowest Common Ancestor of a Binary Tree - Problem

Given a binary tree and two nodes p and q, find their Lowest Common Ancestor (LCA). The LCA is defined as the deepest node that has both p and q as descendants (a node can be a descendant of itself).

Think of it like a family tree - if you have two people, their lowest common ancestor is their most recent shared relative. In a binary tree, it's the node closest to the leaves that can reach both target nodes by going down the tree.

Goal: Return the LCA node of the two given nodes.
Input: Root of binary tree and two target nodes p and q
Output: The LCA node

Input & Output

example_1.py — Basic LCA

$ Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1

› Output: 3

💡 Note: The LCA of nodes 5 and 1 is 3. Node 3 is the lowest node that has both 5 and 1 as descendants.

example_2.py — LCA is one of the nodes

$ Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4

› Output: 5

💡 Note: The LCA of nodes 5 and 4 is 5. Node 5 is an ancestor of node 4, so it serves as the LCA.

example_3.py — Simple two-node tree

$ Input: root = [1,2], p = 1, q = 2

› Output: 1

💡 Note: In a simple tree with root 1 and left child 2, the LCA of 1 and 2 is 1 (the root).

Constraints

The number of nodes in the tree is in the range [2, 10⁵]
-10⁹ ≤ Node.val ≤ 10⁹
All Node.val are unique
p ≠ q
p and q will exist in the tree

Visualization

Tap to expand

Understanding the Visualization

Start the search

Begin from the family tree root and explore downward

Locate descendants

Find which branches contain each target person

Find convergence

The first ancestor who has both people in different branches is the LCA

Key Takeaway

🎯 Key Insight: The LCA is the deepest node that sits at the "fork in the road" between two target nodes - where their paths through the tree diverge.

Asked in

f Meta 85 a Amazon 72 G Google 68 ⊞ Microsoft 45 Apple 32

The optimal solution uses a single recursive DFS traversal with O(n) time complexity. The key insight is that the LCA is the first node where the search paths diverge - one target is found in the left subtree and the other in the right subtree. Each recursive call returns whether it found a target node, and the LCA is identified when both subtrees return a positive result.

Common Approaches

Approach	Time	Space	Notes
✓ Recursive DFS (Optimal)	O(n)	O(h)	Single recursive traversal to find LCA efficiently
Brute Force (Check Every Node)	O(n²)	O(h)	For each node, check if it's an ancestor of both p and q

Recursive DFS (Optimal) — Algorithm Steps

Start DFS from root, checking if current node is p or q
Recursively search left and right subtrees
If current node is a target OR both subtrees contain targets, return true
The LCA is the first node where left and right both return true
Return the LCA node found during traversal

Visualization

Tap to expand

Step-by-Step Walkthrough

Start from root

Begin DFS traversal from root, checking if current node matches targets

Recursive search

Search left and right subtrees recursively for target nodes

Identify convergence

When both subtrees return non-null, current node is the LCA

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

// Definition for a binary tree node
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
};

struct TreeNode* lowestCommonAncestor(struct TreeNode* root, struct TreeNode* p, struct TreeNode* q) {
    if (!root) return NULL;
    
    // If current node is one of the targets, return it
    if (root == p || root == q) {
        return root;
    }
    
    // Search in left and right subtrees
    struct TreeNode* left = lowestCommonAncestor(root->left, p, q);
    struct TreeNode* right = lowestCommonAncestor(root->right, p, q);
    
    // If both subtrees contain one target each, current node is LCA
    if (left && right) {
        return root;
    }
    
    // Return the non-null result (if any)
    return left ? left : right;
}

// Helper function to create a new node
struct TreeNode* createNode(int val) {
    struct TreeNode* node = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    node->val = val;
    node->left = NULL;
    node->right = NULL;
    return node;
}

// Test helper function
struct TreeNode* buildTree() {
    struct TreeNode* root = createNode(3);
    root->left = createNode(5);
    root->right = createNode(1);
    root->left->left = createNode(6);
    root->left->right = createNode(2);
    root->right->left = createNode(0);
    root->right->right = createNode(8);
    root->left->right->left = createNode(7);
    root->left->right->right = createNode(4);
    return root;
}

int main() {
    struct TreeNode* tree = buildTree();
    struct TreeNode* p = tree->left; // Node 5
    struct TreeNode* q = tree->right; // Node 1
    struct TreeNode* result = lowestCommonAncestor(tree, p, q);
    printf("LCA of %d and %d is: %d\n", p->val, q->val, result->val);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Visit each node at most once during the traversal

✓ Linear Growth

Space Complexity

O(h)

Recursion stack depth equals tree height h, O(log n) for balanced trees

✓ Linear Space

142.4K Views

Very High Frequency

~15 min Avg. Time

2.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Recursive DFS (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler