二叉树的层次遍历

二叉树的层次遍历

 

给定一个二叉树，返回其按层次遍历的节点值。 （即逐层地，从左到右访问所有节点）。

例如: 给定二叉树: [3,9,20,null,null,15,7],

    3
   / \
  9  20
    /  \
   15   7

返回其层次遍历结果：

[
  [3],
  [9,20],
  [15,7]
]

我的思路

通过像二叉树的最大深度的算法，一个getLevel通过递归，求出当前节点的层级，然后给当前的层级的List<Integer>加上当前节点的val。

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> list = new ArrayList<>();
        if(null==root){
            return list;
        }
        getLevel(root, list,-1);
        return list;
    }
    public static int getLevel(TreeNode root,List<List<Integer>> list,int n){
        int layerNum = n +1;
        if(null!=root){
            setList(list,layerNum,root);
            if(root.left != null||root.right != null ){
                getLevel(root.left,list,layerNum);
                getLevel(root.right,list,layerNum);
            }
        }
        return layerNum;
    }
    public static void setList(List<List<Integer>> list,int layerNum,TreeNode root){
        List<Integer> layerList = new ArrayList<Integer>();
        try{
            layerList = list.get(layerNum);
            layerList.add(root.val);
        }catch(IndexOutOfBoundsException e){
            layerList.add(root.val);
            list.add(layerNum,layerList);
        }
    }
}

我的问题：

用时12ms，是所有答案里面基本最长时间的了。应该是异常那边耗时过长。

答案代码

思路一

用时1ms将每一层数据都放到队列中，然后取出来，这里要注意，先放左节点，再放右节点。

class Solution {
   public List<List<Integer>> levelOrder(TreeNode root) {
        if(root == null)
            return new ArrayList<>();
        List<List<Integer>> res = new ArrayList<>();
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.add(root);
        while(!queue.isEmpty()){
            int count = queue.size();
            List<Integer> list = new ArrayList<Integer>();
            while(count > 0){
                TreeNode node = queue.poll();
                list.add(node.val);
                if(node.left != null)
                    queue.add(node.left);
                if(node.right != null)
                    queue.add(node.right);
                count--;
            }
            res.add(list);
        }
        return res;
    }
}

思路二

用时2ms，跟我之前的思路一致，但代码写得比我的优雅。可以多学习。使用的是一个hashMap作为容器，存放每个层的数据。

class Solution {
    private Map<Integer, List<Integer>> maps = new HashMap<Integer, List<Integer>>();
    
    private int maxLevel = -1;
​
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> lists = new ArrayList<List<Integer>>();
        dfsTree(root, 0);
        for (int i = 0; i <= maxLevel; i++) {
            lists.add(maps.get(i));
        }
        return lists;
    }
    
    private void dfsTree(TreeNode note, int level) {
        if (note == null) {
            return;
        }
        List<Integer> lists = maps.get(level);
        if (lists == null) {
            lists = new ArrayList<Integer>();
            maps.put(level, lists);
        }
        lists.add(note.val);
        maxLevel = level > maxLevel ? level : maxLevel;
        dfsTree(note.left, level + 1);
        dfsTree(note.right, level + 1);
    }
}