Lowest Common Ancestor of a Binary Tree III

Lowest Common Ancestor of a Binary Tree III - Problem

Imagine you're a genealogist tracing family lineages in a complex family tree. You have two people, and you need to find their closest common ancestor - the most recent person from whom both individuals descended.

In this problem, you're given two nodes p and q in a binary tree, where each node has a special feature: a direct reference to its parent! Your task is to find their Lowest Common Ancestor (LCA) - the deepest node that has both p and q as descendants.

Key points:

Each node has val, left, right, and parent references
A node can be considered a descendant of itself
The LCA is the lowest (deepest) node that contains both nodes in its subtree

The beauty of this version is that with parent pointers, we can traverse upward from any node, opening up elegant solutions!

Input & Output

example_1.py — Basic Tree

$ Input: Tree: [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, as it's the deepest node that has both 5 and 1 as descendants.

example_2.py — Same Subtree

$ Input: Tree: [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, since node 4 is a descendant of node 5, making 5 the lowest common ancestor.

example_3.py — Adjacent Nodes

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

› Output: 1

💡 Note: In a simple two-node tree where 2 is a child of 1, 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 exist in the tree

Visualization

Tap to expand

Understanding the Visualization

Start the Journey

Two relatives (p and q) begin tracing their lineage upward using parent pointers

Traverse Upward

Both follow their parent links toward older generations simultaneously

Switch Paths

When one reaches the family patriarch (root), they switch to trace the other person's lineage

Meet at LCA

The synchronized paths ensure they meet at their lowest common ancestor

Key Takeaway

🎯 Key Insight: With parent pointers, we can traverse upward from any node. The two-pointer technique with path synchronization ensures both pointers travel equal distances and meet exactly at the LCA, achieving optimal O(1) space complexity!

Asked in

f Facebook 45 ⊞ Microsoft 38 a Amazon 32 G Google 28

The optimal solution uses the two-pointers technique with path synchronization. By having two pointers traverse upward from p and q, and switching paths when they reach the root, we ensure both pointers travel the same total distance and meet exactly at the Lowest Common Ancestor. This achieves O(h) time and O(1) space complexity, making it both elegant and efficient.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Collect All Ancestors)	O(h)	O(h)	Collect all ancestors of first node, then traverse second node's ancestors until we find a match
Two Pointers (Path Synchronization)	O(h)	O(1)	Use two pointers to traverse upward simultaneously, synchronizing their paths to meet at LCA

Brute Force (Collect All Ancestors) — Algorithm Steps

Start from node p and traverse upward using parent pointers
Store each ancestor (including p itself) in a hash set
Start from node q and traverse upward using parent pointers
For each ancestor of q, check if it exists in our set
Return the first ancestor found in the set

Visualization

Tap to expand

Step-by-Step Walkthrough

Collect p's ancestors

Store all ancestors of p in a set

Check q's ancestors

Traverse upward from q, checking each ancestor against the set

Find LCA

Return first ancestor of q found in p's ancestor set

Code -

solution.c — C

/**
 * Definition for a Node.
 * struct Node {
 *     int val;
 *     struct Node *left;
 *     struct Node *right;
 *     struct Node *parent;
 * };
 */

struct Node* lowestCommonAncestor(struct Node* p, struct Node* q) {
    struct Node* ancestors[1000];
    int count = 0;
    struct Node* current = p;
    
    // Collect all ancestors of p
    while (current != NULL) {
        ancestors[count++] = current;
        current = current->parent;
    }
    
    // Traverse ancestors of q until we find common one
    current = q;
    while (current != NULL) {
        for (int i = 0; i < count; i++) {
            if (ancestors[i] == current) {
                return current;
            }
        }
        current = current->parent;
    }
    
    return NULL;
}

Time & Space Complexity

Time Complexity

⏱️

O(h)

Where h is the height of the tree. We traverse up to the root twice in worst case

✓ Linear Growth

Space Complexity

O(h)

We store up to h ancestors in the hash set

✓ Linear Space

89.3K Views

High Frequency

~15 min Avg. Time

1.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 (Collect All Ancestors) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler