Lowest Common Ancestor of a Binary Tree

Lowest Common Ancestor of a Binary Tree - Problem

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

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)."

Note: All node values are unique, and both p and q exist in the tree.

Input & Output

Example 1 — Basic Tree

$ 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 root and both 5 and 1 are in different subtrees.

Example 2 — Ancestor Relationship

$ 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 4 is a descendant of node 5, so 5 is their lowest common ancestor.

Example 3 — Two Node Tree

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

› Output: 1

💡 Note: In a two-node tree, the root is always the LCA of both nodes.

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

Asked in

f Facebook 78 a Amazon 65 M Microsoft 52 G Google 48

The recursive DFS approach is optimal - it uses post-order traversal to identify the LCA in a single pass. The key insight is that when we find both target nodes in different subtrees of a node, that node must be their LCA. Time: O(n), Space: O(h)

Common Approaches

✓ Optimized

⏱️ Time: N/A Space: N/A

Hash Map

⏱️ Time: N/A Space: N/A

Path Storage Approach

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

Find the path from root to p and root to q separately, then compare these paths to identify the deepest common node. This requires extra space to store both paths.

Recursive DFS

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

Use post-order DFS traversal. For each node, recursively check left and right subtrees. If we find p in one subtree and q in another, current node is the LCA. This is the optimal approach.

Algorithm Steps — Algorithm Steps

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) {
    if (size == 0 || arr[0] == -1) return NULL;
    
    TreeNode* root = createNode(arr[0]);
    TreeNode* queue[1000];
    int front = 0, rear = 0;
    queue[rear++] = root;
    int i = 1;
    
    while (front < rear && i < size) {
        TreeNode* node = queue[front++];
        
        if (i < size && arr[i] != -1) {
            node->left = createNode(arr[i]);
            queue[rear++] = node->left;
        }
        i++;
        
        if (i < size && arr[i] != -1) {
            node->right = createNode(arr[i]);
            queue[rear++] = node->right;
        }
        i++;
    }
    
    return root;
}

TreeNode* findNode(TreeNode* root, int val) {
    if (!root) return NULL;
    if (root->val == val) return root;
    
    TreeNode* left = findNode(root->left, val);
    if (left) return left;
    return findNode(root->right, val);
}

TreeNode* lca(TreeNode* root, TreeNode* p, TreeNode* q) {
    if (!root) return NULL;
    
    if (root == p || root == q) {
        return root;
    }
    
    TreeNode* left = lca(root->left, p, q);
    TreeNode* right = lca(root->right, p, q);
    
    if (left && right) {
        return root;
    }
    
    return left ? left : right;
}

int solution(int* treeArr, int size, int pVal, int qVal) {
    TreeNode* root = buildTree(treeArr, size);
    TreeNode* pNode = findNode(root, pVal);
    TreeNode* qNode = findNode(root, qVal);
    
    TreeNode* result = lca(root, pNode, qNode);
    return result ? result->val : -1;
}

int main() {
    char line1[10000], line2[100], line3[100];
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    fgets(line3, sizeof(line3), stdin);
    
    line1[strcspn(line1, "\n")] = 0;
    line2[strcspn(line2, "\n")] = 0;
    line3[strcspn(line3, "\n")] = 0;
    
    int treeArr[1000];
    int size = 0;
    
    char* p = line1 + 1;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']') break;
        
        if (strncmp(p, "null", 4) == 0) {
            treeArr[size++] = -1;
            p += 4;
        } else {
            treeArr[size++] = (int)strtol(p, &p, 10);
        }
    }
    
    int pVal = atoi(line2);
    int qVal = atoi(line3);
    
    int result = solution(treeArr, size, pVal, qVal);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

1.2M Views

High Frequency

~15 min Avg. Time

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