993. 二叉树的堂兄弟节点 + 2641. 二叉树的堂兄弟节点 II

 题目1

在二叉树中，根节点位于深度 0 处，每个深度为 k 的节点的子节点位于深度 k+1 处。

如果二叉树的两个节点深度相同，但 父节点不同 ，则它们是一对堂兄弟节点。

我们给出了具有唯一值的二叉树的根节点 root ，以及树中两个不同节点的值 x 和 y 。

只有与值 x 和 y 对应的节点是堂兄弟节点时，才返回 true 。否则，返回 false。

示例 1：

输入：root = [1,2,3,4], x = 4, y = 3
输出：false

思路

我们需要借助一个map保存每一个点它所在的层数以及它的父节点的值，map的键为这个结点的val，map的值为由Pair<layer,father.val>组成的数对，在一次DFS遍历后，我们的map中就保存了每一个点的层数和父节点信息。如果想要判断这两个点是否为堂兄弟，只需要判断他们是否位于同一层且具有不同的父节点。

代码实现

/**
 * 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 {
    Map<Integer,Pair<Integer,Integer>> map = new HashMap<>();
    public void findLayerAndFather(TreeNode node, int layer,TreeNode father) {
        if (node == null) return;
        if (father != null) {
            map.put(node.val,new Pair<>(layer,father.val));
        } else {
            map.put(node.val,new Pair<>(layer,-1));
        }
        findLayerAndFather(node.left,layer+1,node);
        findLayerAndFather(node.right,layer+1,node);
    }
    
    public boolean isCousins(TreeNode root, int x, int y) {
        //x:[layer,father]
        findLayerAndFather(root,0,null);
        Pair<Integer,Integer> p1 = map.get(x);
        Pair<Integer,Integer> p2 = map.get(y);
        return p1.getKey() == p2.getKey() && p1.getValue() != p2.getValue();
    }
}

题目2

给你一棵二叉树的根 root ，请你将每个节点的值替换成该节点的所有 堂兄弟节点值的和 。

如果两个节点在树中有相同的深度且它们的父节点不同，那么它们互为 堂兄弟 。

请你返回修改值之后，树的根 root 。

注意，一个节点的深度指的是从树根节点到这个节点经过的边数。

示例 1：

输入：root = [5,4,9,1,10,null,7]
输出：[0,0,0,7,7,null,11]
解释：上图展示了初始的二叉树和修改每个节点的值之后的二叉树。
- 值为 5 的节点没有堂兄弟，所以值修改为 0 。
- 值为 4 的节点没有堂兄弟，所以值修改为 0 。
- 值为 9 的节点没有堂兄弟，所以值修改为 0 。
- 值为 1 的节点有一个堂兄弟，值为 7 ，所以值修改为 7 。
- 值为 10 的节点有一个堂兄弟，值为 7 ，所以值修改为 7 。
- 值为 7 的节点有两个堂兄弟，值分别为 1 和 10 ，所以值修改为 11 。

思路

这一题相对上一题就复杂了一点，不只是需要判断某两个点是否为堂兄弟，而是需要将所有点的值都更新为它的堂兄弟的结点的和。

我们要计算所有点的堂兄的和，就需要使用层序遍历，先求出下一层所有结点的和nextLevelSum，然后再通过一次遍历，遍历当前层的所有结点，并计算出当前节点的左右孩子的和curSum,接下来就可以更新当前节点的左右孩子，即用nextLevelSum - curSum就是当前节点左右孩子的所有堂兄弟结点的和

代码实现

/**
 * 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 {
    public TreeNode replaceValueInTree(TreeNode root) {
        root.val = 0;
        List<TreeNode> q = List.of(root);
        while (!q.isEmpty()) {
            List<TreeNode> temp = q;
            q = new ArrayList<>();
            int nextLevelSum = 0;
            //记录下一层结点的和
            for (TreeNode node : temp) {
                if (node.left != null) {
                    nextLevelSum += node.left.val;
                    q.add(node.left);
                }
                if (node.right != null) {
                    nextLevelSum += node.right.val;
                    q.add(node.right);
                }
            }
            //下一次遍历记录当前结点的左右兄弟的和
            for (TreeNode node : temp) {
                int curSum = 0;
                curSum += (node.left != null ? node.left.val : 0);
                curSum += (node.right != null ? node.right.val : 0);
                if (node.left != null) {
                    node.left.val = nextLevelSum - curSum;
                }
                if (node.right != null) {
                    node.right.val = nextLevelSum - curSum;
                }
            }
        }
        return root;
    }
}