LeetCode 623. Add One Row to Tree - 二叉树（Binary Tree）系列题27

Given the root of a binary tree and two integers val and depth, add a row of nodes with value val at the given depth depth.

Note that the root node is at depth 1.

The adding rule is:

• Given the integer depth, for each not null tree node cur at the depth depth - 1, create two tree nodes with value val as cur's left subtree root and right subtree root.
• cur's original left subtree should be the left subtree of the new left subtree root.
• cur's original right subtree should be the right subtree of the new right subtree root.
• If depth == 1 that means there is no depth depth - 1 at all, then create a tree node with value val as the new root of the whole original tree, and the original tree is the new root's left subtree.

Example 1:

Input: root = [4,2,6,3,1,5], val = 1, depth = 2
Output: [4,1,1,2,null,null,6,3,1,5]

Example 2:

Input: root = [4,2,null,3,1], val = 1, depth = 3
Output: [4,2,null,1,1,3,null,null,1]

Constraints:

• The number of nodes in the tree is in the range [1, 104].
• The depth of the tree is in the range [1, 104].
• -100 <= Node.val <= 100
• -105 <= val <= 105
• 1 <= depth <= the depth of tree + 1

给定一棵二叉树和两个整数val和depth，根节点所在层定义为第一层，要求新增加一层节点值都为val的节点，作为树的新的第depth层（也就是说新增加的一层在原来第depth-1层的下一层）。

新增一层的节点需要遵循以下规则：

1）为第depth-1层的每个节点分别创建两个节点值为val新节点，它们分别作为第depth-1层的每个节点的新的左右子节点。

2）第depth-1层的每个节点的原来左子节点作为新的左子节点的左子节点

3）第depth-1层的每个节点的原来右子节点作为新的右子节点的右子节点

4）如果depth等于1，表示在根节点之上增加一层（一个节点），那么新创建的节点将作为新的根节点，旧根节点作为新根节点的左子节点。

根据题目描述，很显然是用水平遍历算法，因为水平遍历刚好是对树一层一层进行遍历。通常我们用BFS进行水平遍历，用一个队列存放当前层的所有节点，当遍历到第depth-1层时，就要开始对该层每个节点进行处理，从队列中取出一个节点，新创建两个值为val的节点，第一个新节点的左子节点指针指向原节点的左子节点，原节点的左子节点指针指向该节点；第二个新节点的右子节点指针指向原节点的右子节点，原节点的右子节点指针指向该节点。这样就完成了对第depth-1层的一个节点的处理，对剩下的节点做同样处理，整个第depth-1层处理完之后，就完成了新的第depth层的增加。

class Solution:
    def addOneRow(self, root: Optional[TreeNode], val: int, depth: int) -> Optional[TreeNode]:
        if depth == 1 or not root:
            newRoot = TreeNode(val, root)
            return newRoot
        
        d = 1
        q = deque([root])
        while q:
            n = len(q)
            for i in range(n):
                node = q.popleft()
                if d == depth - 1:
                    lnode, rnode = TreeNode(val, node.left), TreeNode(val, None, node.right)
                    node.left, node.right = lnode, rnode
                else:
                    if node.left:
                        q.append(node.left)
                    if node.right:
                        q.append(node.right)
            if d == depth - 1:
                break
            d += 1
        
        return root