LC-1026. 节点与其祖先之间的最大差值（二叉树递归）

1026. 节点与其祖先之间的最大差值

难度中等144

给定二叉树的根节点 root，找出存在于 不同 节点 A 和 B 之间的最大值 V，其中 V = |A.val - B.val|，且 A 是 B 的祖先。

（如果 A 的任何子节点之一为 B，或者 A 的任何子节点是 B 的祖先，那么我们认为 A 是 B 的祖先）

示例 1：

输入：root = [8,3,10,1,6,null,14,null,null,4,7,13]
输出：7
解释： 
我们有大量的节点与其祖先的差值，其中一些如下：
|8 - 3| = 5
|3 - 7| = 4
|8 - 1| = 7
|10 - 13| = 3
在所有可能的差值中，最大值 7 由 |8 - 1| = 7 得出。

示例 2：

输入：root = [1,null,2,null,0,3]
输出：3

提示：

• 树中的节点数在 2 到 5000 之间。
• 0 <= Node.val <= 105

DFS回溯

class Solution {
    int res = 0;
    public int maxAncestorDiff(TreeNode root) {
        dfs(root);
        return res;
    }

    // 返回当前节点 子节点的最小值和最大值
    public int[] dfs(TreeNode root){
        int[] result = new int[]{root.val, root.val};// 最小值，最大值
        if(root.left != null){
            int[] left = dfs(root.left);
            res = Math.max(res, Math.max(Math.abs(root.val - left[0]), Math.abs(root.val - left[1])));
            result[0] = Math.min(result[0], left[0]);
            result[1] = Math.max(result[1], left[1]);
        }
        if(root.right != null){
            int[] right = dfs(root.right);
            res = Math.max(res, Math.max(Math.abs(root.val - right[0]), Math.abs(root.val - right[1])));
            result[0] = Math.min(result[0], right[0]);
            result[1] = Math.max(result[1], right[1]);
        }
        return result;
    }
}

更优雅一点：

https://leetcode.cn/problems/maximum-difference-between-node-and-ancestor/solution/by-chenyunerer-k6ji/

class Solution {
    public int maxAncestorDiff(TreeNode root) {
        if(root == null){
            return 0;
        }
        // 返回以root为根节点的最大差值
        return dfs(root, root.val, root.val);
    }
    public int dfs(TreeNode root, int min, int max){
        if(root == null) return 0; // 递归边界，到达叶子节点下层节点
        // 每经过一个节点，则根据当前节点值，重新计算最小边界和最大边界值（不断扩张已知的范围）
        min = Math.min(min, root.val);
        max = Math.max(max, root.val);
        if(root.left == null && root.right == null){
            // 到叶子节点的时候，此时该DFS路径的上下边界值已经是已知的最大范围，则计算差值
            return max - min;
        }
        // 递归处理左右子树的最大差值
        int leftMax = dfs(root.left, min, max);
        int rightMax = dfs(root.right, min, max);
        // 返回最大差值的最大值
        return Math.max(leftMax, rightMax);
    }
}