Lowest Common Ancestor of a Binary Tree II

Lowest Common Ancestor of a Binary Tree II - Problem

Lowest Common Ancestor of a Binary Tree II

You're given a binary tree and two nodes p and q that might or might not exist in the tree. Your task is to find the Lowest Common Ancestor (LCA) of these two nodes.

The LCA is defined as the lowest node in the tree that has both p and q as descendants (where we allow a node to be a descendant of itself).

Key Challenge: Unlike the classic LCA problem, here we must handle the case where one or both nodes don't exist in the tree. If either node is missing, return null.

Example: In a family tree, if you're looking for the common ancestor of two people, but one person isn't actually part of the family, there's no valid answer!

Goal: Return the LCA if both nodes exist, otherwise return null.

Input & Output

example_1.py — Both nodes exist

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

› Output: 3

💡 Note: Both nodes 5 and 1 exist in the tree. Node 3 is their lowest common ancestor since it's the lowest node that has both 5 and 1 as descendants.

example_2.py — Both nodes exist, one is ancestor

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

› Output: 5

💡 Note: Both nodes exist. Node 4 is a descendant of node 5, so node 5 is the LCA (a node can be an ancestor of itself).

example_3.py — One node doesn't exist

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

› Output: null

💡 Note: Node 9 doesn't exist in the tree, so there's no valid LCA. We return null as specified.

Constraints

The number of nodes in the tree is in the range [1, 10⁴]
-10⁹ ≤ Node.val ≤ 10⁹
All Node.val are unique
p ≠ q
p and q may or may not exist in the tree

Visualization

Tap to expand

Understanding the Visualization

Start at CEO

Begin traversal from the top of the organization

Search Departments

Recursively explore each department and team

Track Employees

Mark when we find each target employee during our search

Identify Manager

The first manager we find who has both employees in their organization (directly or indirectly) is our answer

Verify Employment

Only return the manager if we actually found both employees

Key Takeaway

🎯 Key Insight: We can efficiently find the LCA and verify node existence in a single traversal by using boolean flags to track our discoveries and post-order traversal to identify the lowest common ancestor.

Asked in

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

The optimal solution uses a single post-order traversal with boolean flags to track node existence. As we traverse, we identify potential LCA candidates and only return a valid result if both target nodes were found during the traversal. This achieves O(n) time complexity with a single pass through the tree.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Traversal with Boolean Flags (Optimal)	O(n)	O(h)	Single traversal that tracks node existence and finds LCA simultaneously
Brute Force (Separate Existence Check + Classic LCA)	O(3n) = O(n)	O(h)	First verify both nodes exist, then find LCA using classic algorithm

One-Pass Traversal with Boolean Flags (Optimal) — Algorithm Steps

Perform post-order traversal with boolean tracking
At each node, check if current node matches p or q
Recursively search left and right subtrees
Track if we've found p and q using boolean flags
Return LCA candidate only if both nodes exist in tree

Visualization

Tap to expand

Step-by-Step Walkthrough

Start DFS

Begin post-order traversal from root

Track nodes

Mark when we find p or q during traversal

Identify LCA

Node becomes LCA when it has both targets in different subtrees

Verify existence

Return result only if both nodes were found

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 foundP, foundQ;

struct TreeNode* dfs(struct TreeNode* node, struct TreeNode* p, struct TreeNode* q) {
    if (!node) return NULL;
    
    struct TreeNode* left = dfs(node->left, p, q);
    struct TreeNode* right = dfs(node->right, p, q);
    
    struct TreeNode* current = NULL;
    if (node->val == p->val) {
        foundP = true;
        current = node;
    } else if (node->val == q->val) {
        foundQ = true;
        current = node;
    }
    
    // Return LCA if found
    if ((left && right) || (current && (left || right))) {
        return node;
    }
    
    return current ? current : (left ? left : right);
}

struct TreeNode* lowestCommonAncestor(struct TreeNode* root, struct TreeNode* p, struct TreeNode* q) {
    foundP = false;
    foundQ = false;
    
    struct TreeNode* result = dfs(root, p, q);
    return (foundP && foundQ) ? result : NULL;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single traversal of all nodes in worst case

✓ Linear Growth

Space Complexity

O(h)

Recursion stack depth equal to tree height h

✓ Linear Space

52.0K Views

High Frequency

~18 min Avg. Time

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

One-Pass Traversal with Boolean Flags (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler