Lowest Common Ancestor of a Binary Search Tree

Link: LeetCode Problem

Problem Statement

Given a binary search tree (BST), find the lowest common ancestor (LCA) of two given nodes p and q in the BST.

According to the definition of LCA on Wikipedia:

“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).”

Examples

Example 1:

Input: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8  
Output: 6  
Explanation: The LCA of nodes 2 and 8 is 6.

Example 2:

Input: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4  
Output: 2  
Explanation: The LCA of nodes 2 and 4 is 2, since a node can be a descendant of itself.

Constraints

• The number of nodes in the tree is in the range [2, 10^5].

• -10^9 <= Node.val <= 10^9

• All Node.val are unique.

• p != q

• p and q will exist in the BST.

Intuition

BSTs are ordered:

• All nodes in the left subtree are < root.val

• All nodes in the right subtree are > root.val

So:

• If both p.val and q.val are less than root.val, LCA must be in left subtree

• If both p.val and q.val are greater than root.val, LCA must be in right subtree

• If one is on the left and one is on the right (or equal to root), then root is the LCA

Approach: Recursive BST Property

Java Code (Recursive)

class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        if (root == null) return null;

        if (p.val < root.val && q.val < root.val) {
            return lowestCommonAncestor(root.left, p, q);
        } else if (p.val > root.val && q.val > root.val) {
            return lowestCommonAncestor(root.right, p, q);
        } else {
            return root;
        }
    }
}

Java Code (Iterative)

class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        while (root != null) {
            if (p.val < root.val && q.val < root.val) {
                root = root.left;
            } else if (p.val > root.val && q.val > root.val) {
                root = root.right;
            } else {
                return root;
            }
        }
        return null;
    }
}

Time & Space Complexity

• Time Complexity: O(H)

  • H = height of the BST → O(log N) for balanced BST, O(N) for skewed.

• Space Complexity:

  • Recursive: O(H) (call stack)

  • Iterative: O(1)

Dry Run

Tree:         6
            /   \
           2     8
          / \   / \
         0   4 7   9
            / \
           3   5

p = 2, q = 8

Since 2 < 6 < 8 → LCA is 6

Conclusion

This problem is a classic example of leveraging the BST invariant to guide recursive/iterative search efficiently, making it faster than generic LCA solutions on normal binary trees.