Forgetting null/base-case handling
Wrong move: Recursive traversal assumes children always exist.
Usually fails on: Leaf nodes throw errors or create wrong depth/path values.
Fix: Handle null/base cases before recursive transitions.
Move from brute-force thinking to an efficient approach using tree strategy.
Given the root of a binary tree, find the maximum value v for which there exist different nodes a and b where v = |a.val - b.val| and a is an ancestor of b.
A node a is an ancestor of b if either: any child of a is equal to b or any child of a is an ancestor of b.
Example 1:
Input: root = [8,3,10,1,6,null,14,null,null,4,7,13] Output: 7 Explanation: We have various ancestor-node differences, some of which are given below : |8 - 3| = 5 |3 - 7| = 4 |8 - 1| = 7 |10 - 13| = 3 Among all possible differences, the maximum value of 7 is obtained by |8 - 1| = 7.
Example 2:
Input: root = [1,null,2,null,0,3] Output: 3
Constraints:
[2, 5000].0 <= Node.val <= 105Problem summary: Given the root of a binary tree, find the maximum value v for which there exist different nodes a and b where v = |a.val - b.val| and a is an ancestor of b. A node a is an ancestor of b if either: any child of a is equal to b or any child of a is an ancestor of b.
Start with the most direct exhaustive search. That gives a correctness anchor before optimizing.
Pattern signal: Tree
[8,3,10,1,6,null,14,null,null,4,7,13]
[1,null,2,null,0,3]
Source-backed implementations are provided below for direct study and interview prep.
// Accepted solution for LeetCode #1026: Maximum Difference Between Node and Ancestor
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
class Solution {
private int ans;
public int maxAncestorDiff(TreeNode root) {
dfs(root, root.val, root.val);
return ans;
}
private void dfs(TreeNode root, int mi, int mx) {
if (root == null) {
return;
}
int x = Math.max(Math.abs(mi - root.val), Math.abs(mx - root.val));
ans = Math.max(ans, x);
mi = Math.min(mi, root.val);
mx = Math.max(mx, root.val);
dfs(root.left, mi, mx);
dfs(root.right, mi, mx);
}
}
// Accepted solution for LeetCode #1026: Maximum Difference Between Node and Ancestor
/**
* Definition for a binary tree node.
* type TreeNode struct {
* Val int
* Left *TreeNode
* Right *TreeNode
* }
*/
func maxAncestorDiff(root *TreeNode) (ans int) {
var dfs func(*TreeNode, int, int)
dfs = func(root *TreeNode, mi, mx int) {
if root == nil {
return
}
ans = max(ans, max(abs(mi-root.Val), abs(mx-root.Val)))
mi = min(mi, root.Val)
mx = max(mx, root.Val)
dfs(root.Left, mi, mx)
dfs(root.Right, mi, mx)
}
dfs(root, root.Val, root.Val)
return
}
func abs(x int) int {
if x < 0 {
return -x
}
return x
}
# Accepted solution for LeetCode #1026: Maximum Difference Between Node and Ancestor
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution:
def maxAncestorDiff(self, root: Optional[TreeNode]) -> int:
def dfs(root: Optional[TreeNode], mi: int, mx: int):
if root is None:
return
nonlocal ans
ans = max(ans, abs(mi - root.val), abs(mx - root.val))
mi = min(mi, root.val)
mx = max(mx, root.val)
dfs(root.left, mi, mx)
dfs(root.right, mi, mx)
ans = 0
dfs(root, root.val, root.val)
return ans
// Accepted solution for LeetCode #1026: Maximum Difference Between Node and Ancestor
struct Solution;
use rustgym_util::*;
trait Preorder {
fn preorder(&self, parent: Option<(i32, i32)>, abs: &mut i32);
}
impl Preorder for TreeLink {
fn preorder(&self, mut parent: Option<(i32, i32)>, abs: &mut i32) {
if let Some(node) = self {
let val = node.borrow().val;
let left = &node.borrow().left;
let right = &node.borrow().right;
parent = if let Some((min, max)) = parent {
*abs = (*abs).max((min - val).abs().max((max - val).abs()));
Some((min.min(val), max.max(val)))
} else {
Some((val, val))
};
left.preorder(parent, abs);
right.preorder(parent, abs);
}
}
}
impl Solution {
fn max_ancestor_diff(root: TreeLink) -> i32 {
let mut res = 0;
root.preorder(None, &mut res);
res
}
}
#[test]
fn test() {
let root = tree!(
8,
tree!(3, tree!(1), tree!(6, tree!(4), tree!(7))),
tree!(10, None, tree!(14, tree!(13), None))
);
let res = 7;
assert_eq!(Solution::max_ancestor_diff(root), res);
}
// Accepted solution for LeetCode #1026: Maximum Difference Between Node and Ancestor
/**
* Definition for a binary tree node.
* class TreeNode {
* val: number
* left: TreeNode | null
* right: TreeNode | null
* constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
* this.val = (val===undefined ? 0 : val)
* this.left = (left===undefined ? null : left)
* this.right = (right===undefined ? null : right)
* }
* }
*/
function maxAncestorDiff(root: TreeNode | null): number {
const dfs = (root: TreeNode | null, mi: number, mx: number): void => {
if (!root) {
return;
}
ans = Math.max(ans, Math.abs(root.val - mi), Math.abs(root.val - mx));
mi = Math.min(mi, root.val);
mx = Math.max(mx, root.val);
dfs(root.left, mi, mx);
dfs(root.right, mi, mx);
};
let ans: number = 0;
dfs(root, root.val, root.val);
return ans;
}
Use this to step through a reusable interview workflow for this problem.
BFS with a queue visits every node exactly once — O(n) time. The queue may hold an entire level of the tree, which for a complete binary tree is up to n/2 nodes = O(n) space. This is optimal in time but costly in space for wide trees.
Every node is visited exactly once, giving O(n) time. Space depends on tree shape: O(h) for recursive DFS (stack depth = height h), or O(w) for BFS (queue width = widest level). For balanced trees h = log n; for skewed trees h = n.
Review these before coding to avoid predictable interview regressions.
Wrong move: Recursive traversal assumes children always exist.
Usually fails on: Leaf nodes throw errors or create wrong depth/path values.
Fix: Handle null/base cases before recursive transitions.