力扣每日一题 623. 在二叉树中增加一行

给定一个二叉树的根 root 和两个整数 val 和 depth ，在给定的深度 depth 处添加一个值为 val 的节点行。

注意，根节点 root 位于深度 1 。

加法规则如下:

• 给定整数 depth，对于深度为 depth - 1 的每个非空树节点 cur ，创建两个值为 val 的树节点作为 cur 的左子树根和右子树根。
• cur 原来的左子树应该是新的左子树根的左子树。
• cur 原来的右子树应该是新的右子树根的右子树。
• 如果 depth == 1 意味着 depth - 1 根本没有深度，那么创建一个树节点，值 val 作为整个原始树的新根，而原始树就是新根的左子树。

 

示例 1:

输入: root = [4,2,6,3,1,5], val = 1, depth = 2
输出: [4,1,1,2,null,null,6,3,1,5]

示例 2:

输入: root = [4,2,null,3,1], val = 1, depth = 3
输出:  [4,2,null,1,1,3,null,null,1]

 

提示:

• 节点数在 [1, 104] 范围内
• 树的深度在 [1, 104]范围内
• -100 <= Node.val <= 100
• -105 <= val <= 105
• 1 <= depth <= the depth of tree + 1

Related Topics

树

深度优先搜索

广度优先搜索

二叉树

基于二叉树的知识，进行插入一层，其他配套代码均可运行，可以用于验证

import java.util.LinkedList;

/**
 * @description： 二叉树节点类
 * @author: ShaoYJ
 * @date: 2022/8/6 14:56
 */
class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;

    TreeNode() {
    }

    TreeNode(int val) {
        this.val = val;
    }

    TreeNode(int val, TreeNode left, TreeNode right) {
        this.val = val;
        this.left = left;
        this.right = right;
    }
}


/**
 * @description： 主类
 * @author: ShaoYJ
 * @date: 2022/8/5 19:58
 */
public class Q623 {
    static int counter = 0;

    /**
     * 创建一个二叉树
     * @param root 根节点（null）
     * @param nums 整数数组
     * @param index 数组索引，可用于定位到将要被插入的元素
     * @return 树根节点
     */
    public TreeNode createTreeNode(TreeNode root, int[] nums, int index) {
        if (index < nums.length) {
            if (nums[index] == 0) {
                return null;
            } else {
                root.val = nums[index];
                TreeNode left = new TreeNode();
                root.left = createTreeNode(left, nums, ++counter);
                TreeNode right = new TreeNode();
                root.right = createTreeNode(right, nums, ++counter);
                return root;
            }
        }
        return root;
    }


    /**
     * 先序遍历
     *
     * @param root 根节点
     */
    public static void preTraverse(TreeNode root) {
        if (root != null) {
            preTraverse(root.left);
            System.out.print(root.val);
            preTraverse(root.right);
        }
    }

    /**
     * 中序遍历
     *
     * @param root 根节点
     */
    public static void inTraverse(TreeNode root) {
        if (root != null) {
            System.out.print(root.val);
            inTraverse(root.left);
            inTraverse(root.right);
        }
    }

    /**
     * 后序遍历
     *
     * @param root 根节点
     */
    public static void postTraverse(TreeNode root) {
        if (root != null) {
            postTraverse(root.left);
            postTraverse(root.right);
            System.out.print(root.val);
        }
    }

    /**
     * 层次遍历
     * 基于队列的思想，实现父节点出队的时候，对应孩子节点同步入队
     * @param root 根节点
     */
    public static void levelTraverse(TreeNode root) {
        if (root != null) {
            LinkedList<TreeNode> queue = new LinkedList<>();
            TreeNode current;
            queue.offer(root);
            while (!queue.isEmpty()) {
                //  依次出队
                current = queue.poll();
                System.out.print(current.val);
                /*
                 将被出队的元素的孩子节点入队
                 */
                if (current.left != null) {
                    queue.offer(current.left);
                }
                if (current.right != null) {
                    queue.offer(current.right);
                }
            }
        }
    }

    /**
     * 力扣623 在二叉树的指定高度添加一层
     * @param root  根节点
     * @param val 待插入的值
     * @param depth 待插入树的高度
     * @return 根节点
     */
    public TreeNode addOneRow(TreeNode root, int val, int depth) {
        if(root!=null) {
            if (depth == 1) {
                /*
                相当于构建新的根节点
                 */
                root = new TreeNode(val, root, null);
            }
            if (depth == 2) {
                /*
                 基于根节点，重新构建根节点的左右孩子节点
                 同时分别将原本各自的孩子节点，付给新的孩子节点
                 */
                root.left = new TreeNode(val, root.left, null);
                root.right = new TreeNode(val, null, root.right);
            } else {
                /*
                    不停的节点下探到depth高度
                 */
                root.left = addOneRow(root.left, val, depth - 1);
                root.right = addOneRow(root.right, val, depth - 1);
            }
        }
        return root;
    }

    public static void main(String[] args) {
        Q623 q623 = new Q623();
        int[] nums = new int[]{1, 2, 4, 0, 0, 0, 3, 0, 0};
        TreeNode root = q623.createTreeNode(new TreeNode(), nums, counter);
        System.out.print("中序遍历");
        inTraverse(root);

        System.out.print("\n先序遍历");
        preTraverse(root);

        System.out.print("\n后序遍历");
        postTraverse(root);

        System.out.print("\n层次遍历");
        levelTraverse(root);

        System.out.print("\n二叉树的指定高度添加一层");
        root = q623.addOneRow(root,8,2);
        levelTraverse(root);


    }
}