【LeetCode】662. 二叉树最大宽度

题目

662. 二叉树最大宽度

给你一棵二叉树的根节点 root ，返回树的 最大宽度 。

树的 最大宽度 是所有层中最大的 宽度 。

每一层的 宽度 被定义为该层最左和最右的非空节点（即，两个端点）之间的长度。将这个二叉树视作与满二叉树结构相同，两端点间会出现一些延伸到这一层的 null 节点，这些 null 节点也计入长度。

题目数据保证答案将会在 32 位 带符号整数范围内。

示例 1：

输入：root = [1,3,2,5,3,null,9]
输出：4
解释：最大宽度出现在树的第 3 层，宽度为 4 (5,3,null,9) 。

示例 2：

输入：root = [1,3,2,5,null,null,9,6,null,7]
输出：7
解释：最大宽度出现在树的第 4 层，宽度为 7 (6,null,null,null,null,null,7) 。

示例 3：

输入：root = [1,3,2,5]
输出：2
解释：最大宽度出现在树的第 2 层，宽度为 2 (3,2) 。

提示：

• 树中节点的数目范围是 [1, 3000]
• -100 <= Node.val <= 100

题解1

思路

• 对于满二叉树，若根节点的序号为$n$，则其左子树节点序号为$2n$，右子树为$2n+1$ 从1开始
• bfs遍历整个树，标记节点；并计算同层之间节点距离的最大值

代码

# 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 widthOfBinaryTree(self, root: Optional[TreeNode]) -> int:
        queue = collections.deque([(root,1)])
        ret = 0
        while queue:
            left, right = -1,-1
            for _ in range(len(queue)):
                cur = queue.popleft()
                if left == -1: left = cur[1]
                right = cur[1]
                if cur[0].left: queue.append((cur[0].left, 2*cur[1]))
                if cur[0].right: queue.append((cur[0].right, 2*cur[1] + 1))
            ret = max(ret, right-left + 1)
        return ret

复杂度

• 时间复杂度：$O(n)$
• 空间复杂度：$O(n)$

题解2

思路

• 对于满二叉树，若根节点的序号为$n$，则其左子树节点序号为$2n$，右子树为$2n+1$ 从1开始
• 按照左子树优先的顺序，dfs遍历整颗树，第一次遍历到的节点则为该层最左侧的节点，使用哈希表保存
• 每一次遍历到其他结点，计算其与最左侧节点的距离，并更新结果集

代码

# 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 widthOfBinaryTree(self, root: Optional[TreeNode]) -> int:
        levelMin = {}
        ret = 1
        def dfs(node: Optional[TreeNode], depth: int, index: int):
            nonlocal ret
            if not node: return
            if depth not in levelMin: levelMin[depth] = index
            else: ret = max(ret, index - levelMin[depth]+1)
            dfs(node.left, depth+1, 2*index)
            dfs(node.right, depth+1, 2*index+1)
        
        dfs(root, 0, 1)
        return ret

复杂度

• 时间复杂度：$O(n)$
• 空间复杂度：$O(n)$