Lowest Common Ancestor of a Binary Search Tree

Lowest Common Ancestor of a Binary Search Tree - Problem

Given a Binary Search Tree (BST), find the lowest common ancestor (LCA) node of two given nodes p and q in the BST.

The lowest common ancestor is defined as the lowest node in the tree that has both p and q as descendants. Note that a node can be a descendant of itself.

🌳 Key Insight: In a BST, all nodes in the left subtree are smaller than the root, and all nodes in the right subtree are larger. This property makes finding the LCA much more efficient than in a regular binary tree!

Example: If we have nodes with values 2 and 8 in a BST, and the root is 6, then 6 is their LCA because 2 < 6 < 8, meaning they diverge at node 6.

Input & Output

example_1.py — Basic LCA

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

› Output: 6

💡 Note: The LCA of nodes 2 and 8 is 6, since 2 < 6 < 8, making 6 the split point where their paths diverge.

example_2.py — LCA with ancestor relationship

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

› Output: 2

💡 Note: The LCA of nodes 2 and 4 is 2, since node 2 is an ancestor of node 4 (and a node can be an ancestor of itself).

example_3.py — Simple tree

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

› Output: 2

💡 Note: The LCA of nodes 1 and 3 is 2, since 1 < 2 < 3, making 2 the root where paths to both nodes split.

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
Both p and q will exist in the BST

Visualization

Tap to expand

Understanding the Visualization

Start at Peak

Begin at the root of the BST

Check Direction

Compare both targets with current elevation

Navigate Smart

Go left if both lower, right if both higher

Find Split

When targets are on different sides, you found the junction

Key Takeaway

🎯 Key Insight: In a BST, the LCA is the first node where the paths to p and q diverge - when one target is ≤ current node and the other is ≥ current node.

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 f Meta 28 Apple 22

The optimal solution uses the BST property to navigate directly to the LCA in O(h) time and O(1) space. By comparing target values with the current node, we can determine if both targets are in the same subtree or if we've found the split point where they diverge.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Path Storage	O(n)	O(h)	Store paths from root to both nodes, then find the last common node
BST Property Traversal (Optimal)	O(h)	O(1)	Use BST property to navigate directly to LCA without storing paths

Brute Force Path Storage — Algorithm Steps

Find path from root to node p using DFS
Find path from root to node q using DFS
Compare both paths from start until they differ
Return the last common node before divergence

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Path to P

Traverse tree to find path from root to node p

Find Path to Q

Traverse tree to find path from root to node q

Compare Paths

Compare both paths to find last common node

Code -

solution.c — C

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

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

bool findPath(struct TreeNode* node, struct TreeNode* target, 
              struct TreeNode** path, int* pathLen) {
    if (!node) return false;
    
    path[(*pathLen)++] = node;
    
    if (node == target) return true;
    
    if (findPath(node->left, target, path, pathLen) ||
        findPath(node->right, target, path, pathLen)) {
        return true;
    }
    
    (*pathLen)--;
    return false;
}

struct TreeNode* lowestCommonAncestor(struct TreeNode* root, 
                                     struct TreeNode* p, 
                                     struct TreeNode* q) {
    struct TreeNode* path1[1000];
    struct TreeNode* path2[1000];
    int len1 = 0, len2 = 0;
    
    findPath(root, p, path1, &len1);
    findPath(root, q, path2, &len2);
    
    struct TreeNode* lca = NULL;
    int minLen = len1 < len2 ? len1 : len2;
    
    for (int i = 0; i < minLen; i++) {
        if (path1[i] == path2[i]) {
            lca = path1[i];
        } else {
            break;
        }
    }
    
    return lca;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Need to traverse the tree to find paths to both nodes, worst case visits all nodes

✓ Linear Growth

Space Complexity

O(h)

Store two paths of length at most h (height of tree) plus recursion stack

✓ Linear Space

89.5K Views

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

Brute Force Path Storage — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler