一、题目

二、广度优先BFS

照着之前整理的BFS模板一下就写出来了。模板详细的分析整理见之前博客。

唯一的一个点是一边刷题一边学基础语法和数据结构。一开始有点懵怎么向二位的list里加元素。原来只有先新建一个list ,再向list里add就可以。

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>();
        if(root==null){
            return res;
        }
        Queue<TreeNode> q =new LinkedList<>();
        q.offer(root);
        
        while(!q.isEmpty()){
            int size = q.size();
            List<Integer> A = new ArrayList<>();
            for(int i=0 ;i<size;i++){    
                root=q.poll();
                A.add(root.val);
                if(root.left != null){
                    q.add(root.left);
                }
                if(root.right != null){
                    q.add(root.right);
                }
                // else{return null;}
            }
            res.add(A);
        }
        return res;
    }
}

复制代码

几个bug点分析

1、A要定义再函数外面，一开始定义再for里面，一个完整for循环放出来一层数据，所以定义在外面就可以。

2、一开始返回null，一看是写了一个return null。return之后就结束了。一开始加 null 是递归写习惯了边界条件
因为是往que里面加元素，所以不要return 和边界判断

三、递归

思路

思路：
先返回根节点
再返回其左右子树
再返回左右树的左右节点

代码

出现了递归点,但是怎么放到二维数组里呢，想想。但二维数组实在不熟，没想出来，看了评论区一个大佬递归思想后自己复现：

class Solution {
    List<List<Integer>> res = new ArrayList<>();
    public List<List<Integer>> levelOrder(TreeNode root) {
        // List<List<Integer>> res = new ArrayList<>();
        int lever = 0;
        levelOrder(root,lever);
        return res;
    }
    public void levelOrder(TreeNode root,int lever){
        if (root==null){
            return ;
        }
        // ArrayList<Integer> list = new ArrayList<>(); 
        // 这个层第一次来，进行扩容存放该层的元素
        if(res.size()==lever){
            // list.add();
            res.add(new ArrayList<Integer>());
        }
        //递归中每一层的lever值是一样的，该层之后在来的时候直接存放就可以
        res.get(lever).add(root.val);
        // 递归一次lever+1；
        lever = lever+1;
        levelOrder(root.left,lever);
        levelOrder(root.right,lever);
    }
}
复制代码

遇到的bug分析

一开始看了大佬思路后自己复现写出来是这个样的：

class Solution {
    List<List<Integer>> res = new ArrayList<>();
    public List<List<Integer>> levelOrder(TreeNode root) {
        // List<List<Integer>> res = new ArrayList<>();
        int lever = 0;
        levelOrder(root,lever);
        return res;

    }
    public void levelOrder(TreeNode root,int lever){
        if (root==null){
            return ;
        }
        ArrayList<Integer> list = new ArrayList<>(); 
        if(res.size()==lever){
            list.add(root.val);
        }
        
        res.add(list);
        lever = lever+1;
        levelOrder(root.left,lever);
        levelOrder(root.right,lever);
    }
}

复制代码

开始想为什么，整理了一下：

就是上面那个原因，一样的层的时候lever一样，但我每一次都给它扩容了，所以自然后面添加不进去，所以又开始思索怎么只在层第一次出现给扩容。参考了一下评论
发现一个窍门：

if(res.size()==lever){
            // list.add();
            res.add(new ArrayList<Integer>());
        }
res.get(lever).add(root.val);

复制代码

就很绝，解决！
二维list向某一个维度加元素：
list.get(lever).add(node.val);
可以用这个函数来把元素加到一个层，而不是每次增加res中list的数量
这样同一层的节点的lever和那个就会相等。

一开始还想着递归参数放左右子树，但后来发现这样不仅麻烦逻辑我还很难自恰，放弃

 public void levelOrder(TreeNode root_left,TreeNode root_right,int lever){
        if (root_left==null&&root_right==null){
            return ;
        }
        ArrayList<Integer> list = new ArrayList<>(); 
        if(res.size()==lever){
            list.add(root_left.val,root_right.val);
        }
        
        res.add(list);
        lever = lever+1;
        levelOrder(root_left.left,root_left.right,lever);
        levelOrder(root_right.left,root_right.right,lever);
    }
}
复制代码