Lowest Common Ancestor of Deepest Leaves - Practice Coding Problems

Lowest Common Ancestor of Deepest Leaves - Problem

Lowest Common Ancestor of Deepest Leaves

You're given the root of a binary tree, and your task is to find the lowest common ancestor (LCA) of all the deepest leaves in the tree.

What you need to know:

A leaf is a node with no children
Depth starts at 0 for the root, and increases by 1 for each level down
The deepest leaves are all leaf nodes at the maximum depth
The LCA is the deepest node that has all target nodes in its subtree

Goal: Find the node that is the common ancestor of all deepest leaves, positioned as low as possible in the tree.

Example: In a tree where the deepest leaves are at depth 3, you need to find their lowest common ancestor - this could be a leaf itself (if there's only one deepest leaf) or an internal node that connects multiple deepest leaves.

Input & Output

example_1.py — Basic Tree

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

› Output: Node with value 2

💡 Note: The deepest leaves are nodes 7 and 4 at depth 3. Their lowest common ancestor is node 2 at depth 2.

example_2.py — Single Node

$ Input: root = [1]

› Output: Node with value 1

💡 Note: There's only one node which is both the root and the only leaf. It's its own LCA.

example_3.py — Linear Tree

$ Input: root = [0,1,3,null,2]

› Output: Node with value 2

💡 Note: The deepest leaf is node 2 at depth 3. Since it's the only deepest leaf, it's its own LCA.

Constraints

The number of nodes in the tree will be in the range [1, 1000]
0 ≤ Node.val ≤ 1000
Each node value is unique
The tree is guaranteed to be a valid binary tree

Visualization

Tap to expand

Understanding the Visualization

Explore Family Branches

Visit each family branch (subtree) to find the youngest generation depth and their meeting point

Compare Branch Depths

Compare the youngest generation depth between left and right family branches

Choose Meeting Point

If branches have different depths, choose the meeting point from the deeper branch. If same depth, current ancestor becomes the meeting point

Key Takeaway

🎯 Key Insight: The optimal solution visits each family member once and simultaneously tracks both the deepest generation and the best meeting point, making it efficient with O(n) time complexity.

Asked in

f Facebook 42 a Amazon 35 G Google 28 ⊞ Microsoft 22

The optimal solution uses a single DFS traversal that simultaneously calculates the maximum depth and finds the LCA. The key insight is that each recursive call returns both the depth of the deepest leaf in its subtree and the LCA of those deepest leaves. When both left and right subtrees have the same maximum depth, the current node becomes the LCA.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Multiple Traversals)	O(n²)	O(h + k)	Find deepest leaves first, then find their LCA separately
One-Pass DFS (Optimal)	O(n)	O(h)	Find depth and LCA simultaneously in single traversal

Brute Force (Multiple Traversals) — Algorithm Steps

Traverse the tree to find the maximum depth
Traverse again to collect all nodes at maximum depth
Use a separate function to find LCA of collected deepest leaves
Return the LCA result

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Max Depth

First traversal to determine the maximum depth in the tree

Collect Deepest Leaves

Second traversal to identify all leaves at the maximum depth

Find LCA

Third operation to find the lowest common ancestor of collected leaves

Code -

solution.c — C

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

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

int findMaxDepth(struct TreeNode* node) {
    if (!node) return -1;
    int leftDepth = findMaxDepth(node->left);
    int rightDepth = findMaxDepth(node->right);
    return 1 + (leftDepth > rightDepth ? leftDepth : rightDepth);
}

void collectDeepestLeaves(struct TreeNode* node, int depth, int maxDepth, struct TreeNode** leaves, int* count) {
    if (!node) return;
    if (depth == maxDepth && !node->left && !node->right) {
        leaves[(*count)++] = node;
    }
    collectDeepestLeaves(node->left, depth + 1, maxDepth, leaves, count);
    collectDeepestLeaves(node->right, depth + 1, maxDepth, leaves, count);
}

bool isTarget(struct TreeNode* node, struct TreeNode** targets, int count) {
    for (int i = 0; i < count; i++) {
        if (targets[i] == node) return true;
    }
    return false;
}

struct TreeNode* findLCA(struct TreeNode* node, struct TreeNode** targets, int count) {
    if (!node || isTarget(node, targets, count)) return node;
    struct TreeNode* left = findLCA(node->left, targets, count);
    struct TreeNode* right = findLCA(node->right, targets, count);
    if (left && right) return node;
    return left ? left : right;
}

struct TreeNode* lcaDeepestLeaves(struct TreeNode* root) {
    int maxDepth = findMaxDepth(root);
    struct TreeNode** deepestLeaves = (struct TreeNode**)malloc(1000 * sizeof(struct TreeNode*));
    int count = 0;
    collectDeepestLeaves(root, 0, maxDepth, deepestLeaves, &count);
    struct TreeNode* result = findLCA(root, deepestLeaves, count);
    free(deepestLeaves);
    return result;
}

int main() {
    printf("LCA found\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

O(n) to find max depth + O(n) to collect deepest leaves + O(n²) worst case for LCA of multiple nodes

⚠ Quadratic Growth

Space Complexity

O(h + k)

O(h) for recursion stack depth plus O(k) to store k deepest leaves

✓ Linear Space

78.6K Views

Medium Frequency

~15 min Avg. Time

2.3K 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 (Multiple Traversals) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler