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 in the BST.

According to the definition of LCA: "The lowest common ancestor is defined between two nodes p and q as the lowest node in T that has both p and q as descendants (where we allow a node to be a descendant of itself)."

Key Properties:

All nodes in the left subtree have values less than the root
All nodes in the right subtree have values greater than the root
We can use these properties to efficiently navigate the tree

Input & Output

Example 1 — Different Subtrees

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

› Output: 6

💡 Note: The LCA of nodes 2 and 8 is 6. Node 2 is in the left subtree and node 8 is in the right subtree of node 6, making 6 the lowest common ancestor.

Example 2 — Same Subtree

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

› Output: 2

💡 Note: The LCA of nodes 2 and 4 is 2. Since node 4 is a descendant of node 2, and we allow a node to be a descendant of itself, the LCA is 2.

Example 3 — Root as LCA

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

› Output: 2

💡 Note: The LCA of nodes 1 and 3 is 2. Node 1 is in the left subtree and node 3 is in the right subtree, so root 2 is their lowest common ancestor.

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 BST

Visualization

Tap to expand

Asked in

a Amazon 45 M Microsoft 38 G Google 35 f Facebook 28

The key insight is leveraging BST properties where left nodes are smaller and right nodes are larger than their parent. The optimal approach navigates directly to the LCA by checking if both target nodes are on the same side or different sides of the current node. Time: O(h), Space: O(1).

Common Approaches

✓ Brute Force - Check Every Node

⏱️ Time: O(n²) Space: O(h)

Traverse the entire tree and for each node, check if both p and q exist in its subtree. The first such node found in a bottom-up manner would be the LCA. This requires checking every possible ancestor.

Optimal BST Navigation

⏱️ Time: O(h) Space: O(1)

Leverage the BST property that all left descendants are smaller and right descendants are larger. If both target values are on the same side of current node, go deeper in that direction. When they're on different sides, current node is the LCA.

Path Comparison Approach

⏱️ Time: O(h) Space: O(h)

Store the path from root to each target node, then compare these paths to find where they diverge. The last common node in both paths is the LCA. This approach uses BST properties for efficient path finding.

Brute Force - Check Every Node — Algorithm Steps

Step 1: Traverse all nodes in the tree
Step 2: For each node, check if both p and q exist in its subtree
Step 3: Return the lowest node that contains both

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Root

Does node 6 contain both 2 and 8? Yes - continue deeper

Check Children

Check left subtree (2) and right subtree (8) recursively

Find LCA

Node 6 is the lowest node containing both 2 and 8

Code -

solution.c — C

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

typedef struct TreeNode {
    int val;
    struct TreeNode* left;
    struct TreeNode* right;
} TreeNode;

TreeNode* createNode(int val) {
    TreeNode* node = (TreeNode*)malloc(sizeof(TreeNode));
    node->val = val;
    node->left = NULL;
    node->right = NULL;
    return node;
}

TreeNode* buildTree(int* arr, int size, int index) {
    if (index >= size || arr[index] == -1) {
        return NULL;
    }
    
    TreeNode* root = createNode(arr[index]);
    root->left = buildTree(arr, size, 2 * index + 1);
    root->right = buildTree(arr, size, 2 * index + 2);
    
    return root;
}

TreeNode* lowestCommonAncestor(TreeNode* root, int p, int q) {
    if (root == NULL) return NULL;
    
    // If both p and q are smaller than root, LCA is in left subtree
    if (p < root->val && q < root->val) {
        return lowestCommonAncestor(root->left, p, q);
    }
    
    // If both p and q are greater than root, LCA is in right subtree
    if (p > root->val && q > root->val) {
        return lowestCommonAncestor(root->right, p, q);
    }
    
    // If one is smaller and one is greater, or one equals root, then root is LCA
    return root;
}

int parseArray(char* line, int* arr) {
    int count = 0;
    int i = 0;
    int len = strlen(line);
    
    // Skip initial '['
    while (i < len && line[i] != '[') i++;
    i++;
    
    while (i < len && line[i] != ']') {
        // Skip whitespace and commas
        while (i < len && (line[i] == ' ' || line[i] == ',')) i++;
        
        if (i >= len || line[i] == ']') break;
        
        // Check for null values (represented as gaps in level-order)
        if (strncmp(line + i, "null", 4) == 0) {
            arr[count++] = -1;
            i += 4;
        } else {
            // Parse number
            int num = 0;
            int negative = 0;
            if (line[i] == '-') {
                negative = 1;
                i++;
            }
            while (i < len && line[i] >= '0' && line[i] <= '9') {
                num = num * 10 + (line[i] - '0');
                i++;
            }
            if (negative) num = -num;
            arr[count++] = num;
        }
    }
    
    return count;
}

int main() {
    char line1[10000], line2[10000], line3[10000];
    
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    fgets(line3, sizeof(line3), stdin);
    
    // Remove newlines
    line1[strcspn(line1, "\n")] = 0;
    line2[strcspn(line2, "\n")] = 0;
    line3[strcspn(line3, "\n")] = 0;
    
    // Parse tree array
    int arr[1000];
    int size = parseArray(line1, arr);
    
    // Parse p and q values
    int p = atoi(line2);
    int q = atoi(line3);
    
    // Build tree from array
    TreeNode* root = buildTree(arr, size, 0);
    
    // Find LCA
    TreeNode* lca = lowestCommonAncestor(root, p, q);
    
    // Output result
    printf("%d\n", lca->val);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n nodes, we perform a subtree search that could visit all n nodes

✓ Linear Growth

Space Complexity

O(h)

Recursion stack depth equals tree height h

✓ Linear Space

156.0K 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

Lowest Common Ancestor of a Binary Search Tree - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Check Every Node — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler