2021-03-06

LeetCode 623 在二叉树上增加一行

    public TreeNode addOneRow(TreeNode root, int v, int d) {
        //当d为1时
        if(d == 1){
            TreeNode treeNode = new TreeNode(v);
            treeNode.left = root;
            return treeNode;
        }
        bfs(root,v,d);
        return root;
    }

       public void bfs(TreeNode root,int v,int target){
        Queue<TreeNode> queue = new ArrayDeque<>();
        int currentLevel = 0;
        boolean flag = false;
        queue.add(root);
        while (!queue.isEmpty() && !flag){
                currentLevel++;
                //到达目标层数
                if (currentLevel == target-1){
                    System.out.println("进入目标层数");
                    int size = queue.size();
                    for (int i = 0; i < size; i++) {
                        TreeNode treeNode = queue.poll();
                        TreeNode left = treeNode.left;
                        TreeNode right = treeNode.right;
                        TreeNode new_treeNode_left = new TreeNode(v);
                        TreeNode new_treeNode_right =new TreeNode(v);
                        //添加新层
                        treeNode.left = new_treeNode_left;
                        new_treeNode_left.left = left;
                        treeNode.right = new_treeNode_right;
                        new_treeNode_right.right = right;
                    }
                    flag = true;
                }else { 
                    System.out.println("quue.size"+queue.size());
                    int size = queue.size();
                    for (int i = 0; i < size; i++) {
                        System.out.println("i "+i);
                        TreeNode treeNode =queue.poll();
                        if (treeNode.left != null){
                             queue.add(treeNode.left);
                         }
                           
                        if (treeNode.right != null){
                            queue.add(treeNode.right);
                        }
                        
                    }
                }
            
        }
    }

代码详解

使用广度优先搜索，用currentLevel控制层数，当达到d-1层时不再向下探索，同时设置flag=true,停止while循环

 if (currentLevel == target-1){
                    System.out.println("进入目标层数");
                    int size = queue.size();
                    for (int i = 0; i < size; i++) {
                        TreeNode treeNode = queue.poll();
                        TreeNode left = treeNode.left;
                        TreeNode right = treeNode.right;
                        TreeNode new_treeNode_left = new TreeNode(v);
                        TreeNode new_treeNode_right =new TreeNode(v);
                        //添加新层
                        treeNode.left = new_treeNode_left;
                        new_treeNode_left.left = left;
                        treeNode.right = new_treeNode_right;
                        new_treeNode_right.right = right;
                    }
     flag = true;
 }

注意坑!!!

在一开始，我使用**for(int i=0;i<queue.size();i++)**控制循环，但是在循环体中，queue也发生的变化，queue.size()也发生了变化，所以for循环不再是想像中的次数。解决方法:在for循环外层设置size=queue.size(),for循环中这样使用(int i=0;i<size;i++)

深度优先搜索

本题中深度优先搜索执行效率更高

   public TreeNode addOneRow(TreeNode root, int v, int d) {
        if(d ==1){
            TreeNode tree = new TreeNode(v);
            tree.left = root;
            return tree;
        }

        dfs(root,v,d,1);
        return root;
    }

    public void dfs(TreeNode root,int v,int d,int currentLevel){
        if(root == null)
            return;
        //到达目标层
        if(currentLevel == d-1){
            TreeNode left  = root.left;
            TreeNode right = root.right;
            TreeNode new_left = new TreeNode(v);
            TreeNode new_right = new TreeNode(v);
            root.left = new_left;
            root.right = new_right;
            new_left.left = left;
            new_right.right =right;
        }

        dfs(root.left, v, d, currentLevel+1);
        dfs(root.right, v, d, currentLevel+1);
    }

代码分析

对于每一次遍历结点，都要保存当前结点所在层数，即dfs方法中要存在一个形参int currentLevel,遍历此节点的左右子树的时候为

       dfs(root.left, v, d, currentLevel+1);
       dfs(root.right, v, d, currentLevel+1);

即currentLevel+1

当currentLevel等于所需要的层数的时候，便进行相应的处理

        //到达目标层
        if(currentLevel == d-1){
            TreeNode left  = root.left;
            TreeNode right = root.right;
            TreeNode new_left = new TreeNode(v);
            TreeNode new_right = new TreeNode(v);
            root.left = new_left;
            root.right = new_right;
            new_left.left = left;
            new_right.right =right;
        }