【Py/Java/C++三种语言详解】LeetCode每日一题240208【二叉树BFS】LeetCode993、二叉树的堂兄弟节点

有华为OD考试扣扣交流群可加948025485
可上全网独家的 欧弟OJ系统 练习华子OD、大厂真题
绿色聊天软件戳 od1336了解算法冲刺训练

题目链接

LeetCode993、二叉树的堂兄弟节点

题目描述

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

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

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

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

示例 1：

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

示例 2：

输入：root = [1,2,3,null,4,null,5], x = 5, y = 4
输出：true

示例 3：

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

提示：

• 二叉树的节点数介于 2 到 100 之间。
• 每个节点的值都是唯一的、范围为 1 到 100 的整数。

解题思路

和 LeetCode2641、二叉树的堂兄弟节点II 类似，堂兄弟节点深度相同，很容易想到使用BFS来完成。

需要解决两个问题：

1. 如何判断x和y是否位于同一层
2. 如果位于同一层，如何判断x和y是堂兄弟节点而不是属于同一个父节点的兄弟节点。

问题一很好解决，在每一层的横向遍历结束，当前层的所有节点都储存在队列中。此时可以获得该层节点值构成的集合level = set(node.val for node in q)，就能够通过哈希集合的查找，快速地判断x和y是否位于同一层中了。

问题二有两种方法可以解决。

一种比较容易想到的方法是，在层序遍历过程中使用哈希表h，储存每一个节点node的父节点。当h[x] == h[y]时，就说明x和y是同一个父节点的两个子节点的值，反之则不是。这种做法需要使用哈希表，空间复杂度为O(N)。

另一种做法是在层序遍历过程中，一旦发现某个节点同时存在两个孩子，那么则额外判断这两个孩子的值是否同时为x和y，若是则直接返回False。因为前一个方法哈希表的作用仅仅是用于排除兄弟节点的情况，因此额外加上这步判断后，可以免去哈希表的使用，使空间复杂度降低到O(1)。

代码

方法一：哈希表储存父节点用以判断是否为堂兄弟

python

# 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: 
# BFS法一：储存父节点
    def isCousins(self, root: Optional[TreeNode], x: int, y: int) -> bool:
        if x == root.val or y == root.val:
            return False
        q = deque([root])
        h = dict()      # 用哈希表储存父节点
        while(q):
            qSize = len(q)
            for _ in range(qSize):
                node = q.popleft()
                # 在常规的入队操作中，多加一步
                # 储存每一个节点的父节点的值
                if node.left:
                    q.append(node.left)
                    h[node.left.val] = node.val
                if node.right:
                    q.append(node.right)
                    h[node.right.val] = node.val
            # 获得该层节点值构成的集合
            level = set(node.val for node in q)
            # 若x和y均不位于该层中，则继续进行BFS
            if x not in level and y not in level:
                continue
            # 若x和y均位于该层中，且x和y的父节点不同，说明他们是堂兄弟节点，返回True
            elif x in level and y in level and h[x] != h[y]:
                return True
            # 其余情况，返回False
            else:
                return False

java

class Solution {
    public boolean isCousins(TreeNode root, int x, int y) {
        if (x == root.val || y == root.val) {
            return false;
        }

        Queue<TreeNode> q = new ArrayDeque<>();
        Map<Integer, Integer> parent = new HashMap<>();
        q.offer(root);

        while (!q.isEmpty()) {
            int size = q.size();
            Set<Integer> level = new HashSet<>();
            for (int i = 0; i < size; i++) {
                TreeNode node = q.poll();
                if (node.left != null) {
                    q.offer(node.left);
                    parent.put(node.left.val, node.val);
                }
                if (node.right != null) {
                    q.offer(node.right);
                    parent.put(node.right.val, node.val);
                }
                level.add(node.val);
            }

            if (!level.contains(x) && !level.contains(y)) {
                continue;
            } else if (level.contains(x) && level.contains(y) && !parent.get(x).equals(parent.get(y))) {
                return true;
            } else {
                return false;
            }
        }

        return false;
    }
}

cpp

class Solution {
   public:
    bool isCousins(TreeNode *root, int x, int y) {
        if (root->val == x || root->val == y) return false;

        queue<TreeNode *> q;
        unordered_map<int, int> parent;
        q.push(root);

        while (!q.empty()) {
            int size = q.size();
            unordered_set<int> level;
            for (int i = 0; i < size; ++i) {
                TreeNode *node = q.front();
                q.pop();
                if (node->left) {
                    q.push(node->left);
                    parent[node->left->val] = node->val;
                }
                if (node->right) {
                    q.push(node->right);
                    parent[node->right->val] = node->val;
                }
                level.insert(node->val);
            }

            if (level.find(x) == level.end() && level.find(y) == level.end()) {
                continue;
            } else if (level.find(x) != level.end() && level.find(y) != level.end() &&
                       parent[x] != parent[y]) {
                return true;
            } else {
                return false;
            }
        }

        return false;
    }
};

时空复杂度

时间复杂度：O(N)。仅需一次遍历整棵树。

空间复杂度：O(N)。哈希表所占空间。

方法二：在层序遍历中判断是否为同一个父节点

python

# 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:    
    # BFS法二：在层序遍历中判断是否为同一个父节点
    def isCousins(self, root: Optional[TreeNode], x: int, y: int) -> bool:
        if x == root.val or y == root.val:
            return False
        q = deque([root])
        while(q):
            qSize = len(q)
            for _ in range(qSize):
                node = q.popleft()
                # 如果两个孩子节点均存在，且恰好等于x和y，那么直接返回False
                if node.left and node.right:
                    temp = (node.left.val, node.right.val)
                    if temp == (x, y) or temp == (y, x):
                        return False
                # 常规的入队操作
                if node.left:
                    q.append(node.left)
                if node.right:
                    q.append(node.right)
            # 获得该层节点值构成的集合
            level = set(node.val for node in q)
            # 若x和y均不位于该层中，则继续进行BFS
            if x not in level and y not in level:
                continue
            # 若x和y均位于该层中，由于兄弟节点的情况已经在前面判断过了，此时x和y必然为堂兄弟节点
            # 返回True
            elif x in level and y in level:
                return True
            # x和y中只有一个位于该层，说明他们深度不同，必然不是堂兄弟节点，返回False
            else:
                return False

java

class Solution {
    public boolean isCousins(TreeNode root, int x, int y) {
        if (x == root.val || y == root.val) {
            return false;
        }
        
        Queue<TreeNode> q = new ArrayDeque<>();
        q.offer(root);
        
        while (!q.isEmpty()) {
            int size = q.size();
            Set<Integer> level = new HashSet<>();
            for (int i = 0; i < size; i++) {
                TreeNode node = q.poll();
                if (node.left != null && node.right != null) {
                    int leftVal = node.left.val;
                    int rightVal = node.right.val;
                    if ((leftVal == x && rightVal == y) || (leftVal == y && rightVal == x)) {
                        return false;
                    }
                }
                if (node.left != null) {
                    q.offer(node.left);
                }
                if (node.right != null) {
                    q.offer(node.right);
                }
                level.add(node.val);
            }
            if (level.contains(x) && level.contains(y)) {
                return true;
            } else if (level.contains(x) || level.contains(y)) {
                return false;
            }
        }
        
        return false;
    }
}

cpp

class Solution {
   public:
    bool isCousins(TreeNode *root, int x, int y) {
        if (x == root->val || y == root->val) {
            return false;
        }

        queue<TreeNode *> q;
        q.push(root);

        while (!q.empty()) {
            int size = q.size();
            unordered_set<int> level;
            for (int i = 0; i < size; ++i) {
                TreeNode *node = q.front();
                q.pop();
                if (node->left && node->right) {
                    int leftVal = node->left->val;
                    int rightVal = node->right->val;
                    if ((leftVal == x && rightVal == y) || (leftVal == y && rightVal == x)) {
                        return false;
                    }
                }
                if (node->left) {
                    q.push(node->left);
                }
                if (node->right) {
                    q.push(node->right);
                }
                level.insert(node->val);
            }
            if (level.find(x) != level.end() && level.find(y) != level.end()) {
                return true;
            } else if (level.find(x) != level.end() || level.find(y) != level.end()) {
                return false;
            }
        }

        return false;
    }
};

时空复杂度

时间复杂度：O(N)。仅需一次遍历整棵树。

空间复杂度：O(1)。

---

华为OD算法/大厂面试高频题算法练习冲刺训练

• 华为OD算法/大厂面试高频题算法冲刺训练目前开始常态化报名！目前已服务100+同学成功上岸！

• 课程讲师为全网50w+粉丝编程博主@吴师兄学算法 以及小红书头部编程博主@闭着眼睛学数理化

• 每期人数维持在20人内，保证能够最大限度地满足到每一个同学的需求，达到和1v1同样的学习效果！

• 60+天陪伴式学习，40+直播课时，300+动画图解视频，300+LeetCode经典题，200+华为OD真题/大厂真题，还有简历修改、模拟面试、专属HR对接将为你解锁

• 可上全网独家的欧弟OJ系统练习华子OD、大厂真题

• 可查看链接 大厂真题汇总 & OD真题汇总(持续更新)

• 绿色聊天软件戳 od1336了解更多