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

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

✓ Dp 2d

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

Stack

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

Brute Force (Multiple Traversals)

⏱️ Time: O(n²) Space: O(h + k)

This approach breaks the problem into steps: first find the maximum depth, then collect all deepest leaves, and finally find their lowest common ancestor using a separate LCA algorithm.

One-Pass DFS (Optimal)

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

This optimal approach combines depth calculation and LCA finding in a single DFS traversal. Each recursive call returns both the maximum depth of the subtree and the LCA of the deepest leaves in that subtree.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

Time & Space Complexity

Time Complexity

⏱️

⚠ Quadratic Growth

Space Complexity

✓ 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