[LeetCode] 623. Add One Row to Tree

Given the root of a binary tree, then value v and depth d, you need to add a row of nodes with value v at the given depth d. The root node is at depth 1.

The adding rule is: given a positive integer depth d, for each NOT null tree nodes N in depth d-1, create two tree nodes with value v as N's left subtree root and right subtree root. And N's original left subtree should be the left subtree of the new left subtree root, its original right subtree should be the right subtree of the new right subtree root. If depth d is 1 that means there is no depth d-1 at all, then create a tree node with value v as the new root of the whole original tree, and the original tree is the new root's left subtree.

Example 1:

Input: 
A binary tree as following:
       4
     /   
    2     6
   /    / 
  3   1 5   

v = 1

d = 2

Output: 
       4
      / 
     1   1
    /     
   2       6
  /      / 
 3   1   5   

Example 2:

Input: 
A binary tree as following:
      4
     /   
    2    
   /    
  3   1    

v = 1

d = 3

Output: 
      4
     /   
    2
   /     
  1   1
 /       
3       1

Note:

1. The given d is in range [1, maximum depth of the given tree + 1].
2. The given binary tree has at least one tree node.

在二叉树中增加一行。

给定一个二叉树，根节点为第1层，深度为 1。在其第 d 层追加一行值为 v 的节点。

添加规则：给定一个深度值 d （正整数），针对深度为 d-1 层的每一非空节点 N，为 N 创建两个值为 v 的左子树和右子树。

将 N 原先的左子树，连接为新节点 v 的左子树；将 N 原先的右子树，连接为新节点 v 的右子树。

如果 d 的值为 1，深度 d - 1 不存在，则创建一个新的根节点 v，原先的整棵树将作为 v 的左子树。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/add-one-row-to-tree
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

这道题我提供两种做法，BFS和DFS，思路是一样的，都是从根节点往下，一直遍历到 d - 1 层，然后把新的节点加进去。

首先是BFS，我们用queue遍历到目标层 d 的上一层 d - 1，然后对着d - 1 层，先把他的左孩子右孩子用temp指针保存起来，再把需要增加的节点加进去。注意唯一的corner case就是如果新的节点需要加在第一层的话，返回的就是新的根节点了。

时间O(n)

空间O(n)

Java实现

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public TreeNode addOneRow(TreeNode root, int v, int d) {
        // corner case
        if (d == 1) {
            TreeNode newRoot = new TreeNode(v);
            newRoot.left = root;
            return newRoot;
        }

        // normal case
        // BFS遍历node一直到d - 1层
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        for (int i = 1; i < d - 1; i++) {
            int size = queue.size();
            for (int j = 0; j < size; j++) {
                TreeNode cur = queue.poll();
                if (cur.left != null) {
                    queue.offer(cur.left);
                }
                if (cur.right != null) {
                    queue.offer(cur.right);
                }
            }
        }

        // 把新一层的node接在第d - 1和第d层之间
        while (!queue.isEmpty()) {
            TreeNode cur = queue.poll();
            TreeNode temp = cur.left;
            cur.left = new TreeNode(v);
            cur.left.left = temp;
            temp = cur.right;
            cur.right = new TreeNode(v);
            cur.right.right = temp;
        }
        return root;
    }
}

DFS，可以直接参见代码。

时间O(n)

空间O(n)

Java实现

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public TreeNode addOneRow(TreeNode root, int v, int d) {
        // corner case
        if (d == 1) {
            TreeNode newRoot = new TreeNode(v);
            newRoot.left = root;
            return newRoot;
        }
        // normal case
        helper(v, root, 1, d);
        return root;
    }

    private void helper(int val, TreeNode root, int curDepth, int d) {
        if (root == null) {
            return;
        }
        if (curDepth == d - 1) {
            TreeNode temp = root.left;
            root.left = new TreeNode(val);
            root.left.left = temp;
            temp = root.right;
            root.right = new TreeNode(val);
            root.right.right = temp;
        } else {
            helper(val, root.left, curDepth + 1, d);
            helper(val, root.right, curDepth + 1, d);
        }
    }
}

LeetCode 题目总结