Maximum Difference Between Node and Ancestor

Maximum Difference Between Node and Ancestor - Problem

You are given the root of a binary tree, and your mission is to find the maximum absolute difference between any ancestor-descendant pair in the tree.

An ancestor of a node is any node that lies on the path from the root to that node (including the root itself). A descendant is any node in the subtree rooted at a given node.

Goal: Find the maximum value v where v = |a.val - b.val| and node a is an ancestor of node b.

Example: If you have a path from root to leaf like 8 → 3 → 1, you can compare 8 with 3, 8 with 1, and 3 with 1 to find the maximum difference.

Input & Output

example_1.py — Basic Tree

$ Input: root = [8,3,10,1,6,null,14,null,null,4,7,13]

› Output: 7

💡 Note: The maximum difference is between node 8 (ancestor) and node 1 (descendant), giving |8-1| = 7. Other possible differences include |3-1| = 2, |8-14| = 6, but 7 is the maximum.

example_2.py — Linear Tree

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

› Output: 3

💡 Note: The tree forms a path 1→2→0→3. The maximum difference is |0-3| = 3. Note that 1 and 0 are also ancestor-descendant with difference |1-0| = 1, and 2 and 3 give |2-3| = 1.

example_3.py — Single Node

$ Input: root = [5]

› Output: 0

💡 Note: A single node tree has no ancestor-descendant pairs, so the maximum difference is 0.

Constraints

The number of nodes in the tree is in the range [2, 5000]
0 ≤ Node.val ≤ 10⁵
Note: Since we need at least one ancestor-descendant pair, minimum tree size is 2 nodes

Visualization

Tap to expand

Understanding the Visualization

Start the Journey

Begin at the family patriarch/matriarch (root) - they are both the tallest and shortest person initially

Meet Each Descendant

As you visit each family member down the lineage, update who is the tallest and shortest

Calculate Differences

At any point, the maximum height difference is simply tallest - shortest among people met so far

Explore All Branches

Visit every family branch (path) and track the overall maximum difference found

Return Maximum

The answer is the largest height difference found across all family lineages

Key Takeaway

🎯 Key Insight: For any root-to-leaf path, the maximum ancestor-descendant difference equals the difference between the highest and lowest values on that path. We only need one DFS traversal to track min/max values and find the answer!

Asked in

A Amazon 35 G Google 28 f Meta 22 ⊞ Microsoft 18

The optimal solution uses single DFS traversal with min/max tracking along each root-to-leaf path. Key insight: the maximum difference between any ancestor and descendant on a path equals the difference between the maximum and minimum values on that path. Time: O(n), Space: O(h).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Ancestor-Descendant Pairs)	O(n²)	O(h)	For each node, check all its descendants and compute maximum difference
Single DFS with Min/Max Tracking (Optimal)	O(n)	O(h)	Track minimum and maximum values along each root-to-leaf path in one traversal

Brute Force (Check All Ancestor-Descendant Pairs) — Algorithm Steps

Start from root and visit every node
For each node, perform DFS on its subtree
Calculate absolute difference between current node and each descendant
Track the maximum difference found across all pairs
Return the overall maximum difference

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at Root

Begin with root as first ancestor

Check All Descendants

For current ancestor, traverse entire subtree

Calculate Differences

Compute |ancestor.val - descendant.val| for each pair

Track Maximum

Keep track of the largest difference found

Repeat

Move to next node and repeat the process

Code -

solution.c — C

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

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

int maxDiff = 0;

void dfsDescendants(struct TreeNode* ancestor, struct TreeNode* node) {
    if (!node) return;
    
    int diff = abs(ancestor->val - node->val);
    if (diff > maxDiff) {
        maxDiff = diff;
    }
    
    dfsDescendants(ancestor, node->left);
    dfsDescendants(ancestor, node->right);
}

void dfsAncestors(struct TreeNode* node) {
    if (!node) return;
    
    dfsDescendants(node, node->left);
    dfsDescendants(node, node->right);
    
    dfsAncestors(node->left);
    dfsAncestors(node->right);
}

int maxAncestorDiff(struct TreeNode* root) {
    if (!root) return 0;
    maxDiff = 0;
    dfsAncestors(root);
    return maxDiff;
}

int main() {
    // Input parsing would go here
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n nodes, we potentially visit all n nodes in worst case (skewed tree)

⚠ Quadratic Growth

Space Complexity

O(h)

Recursion stack depth equals tree height h

✓ Linear Space

52.0K Views

Medium-High Frequency

~15 min Avg. Time

2.2K 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 (Check All Ancestor-Descendant Pairs) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler