993. 二叉树的堂兄弟节点

在二叉树中，根节点位于深度 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

提示：

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

 

# Definition for a binary tree node.
class TreeNode:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None

class Solution:
    # 用深度优先遍历求出每一个节点的深度与父节点 time O(N) space O(N)
    def isCousins(self, root: TreeNode, x: 'int', y: 'int') -> 'bool':
        parent = {}
        depth = {}

        def dfs(node, par=None):
            if node:
                depth[node.val] = 1 + depth[par.val] if par else 0
                parent[node.val] = par
                dfs(node.left, node)
                dfs(node.right, node)

        dfs(root)
        return depth[x] == depth[y] and parent[x] != parent[y]

    # 层序遍历，若x, y同一节点的左右子树，则return False，否则，继续遍历
    # 若 x, y在同一层，但不是左右子树，则return True
    def isCousins2(self, root: TreeNode, x: 'int', y: 'int') -> 'bool':
        queue = [root]
        while queue:
            now = []
            next_queue = []
            for node in queue:
                # 若为空
                if not node:
                    now.append(None)
                    continue
                # 把该节点的左右值添加
                if node.left:
                    now.append(node.left.val)
                else:
                    now.append(None)

                if node.right:
                    now.append(node.right.val)
                else:
                    now.append(None)
                # 若同父节点
                if x in now[-2:] and y in now[-2:]:
                    return False

                # 加入下层循环
                next_queue.append(node.left)
                next_queue.append(node.right)

                # 若在列表内
            if x in now and y in now:
                return True
            queue = next_queue
        return False

if __name__ == '__main__':
    s = Solution()
    root = TreeNode(10)
    root.left = TreeNode(5)
    root.right = TreeNode(-3)
    root.left.left = TreeNode(3)
    root.left.left.left = TreeNode(9)
    root.left.left.right = TreeNode(-2)
    root.left.right = TreeNode(2)
    root.left.right.right = TreeNode(1)
    root.right.right = TreeNode(11)
    '''
    输入:
          10
         /  \
        5   -3
       / \    \
      3   2   11
     / \   \
    9  -2   1
    '''
    print(s.isCousins2(root, 3, 11))