Java/102.Binary Tree Level Order Traversal 二叉树的层次遍历

一、Binary Tree Level Order Traversal I

 

代码部分一（1ms）：

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

1. 树为空时，return null。

2. 遍历树--> root入队，通过队列遍历树，当父层节点出队时，子层节点入队。每次将一层遍历完，将其层（list)存到结果res。

3. return res。

 

代码部分二（1ms):

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> result = new ArrayList<>();
        set(root, 0, result);
        return result;
    }

    public void set(TreeNode treeNode, int level, List<List<Integer>> result) {
        if(treeNode==null){
            return;
        }
        if(level==result.size()){
            result.add(new ArrayList<>());
        }
        result.get(level).add(treeNode.val);
        set(treeNode.left,level+1,result);
        set(treeNode.right,level+1,result);
    }
}

 

1. 调用set（）

2.  判断数是否为空，为空则return；

3. 判断当前遍历的层次level，result中是否有记录了（是否第一次遍历该层）

4. 根据对应层次添加节点 result.get(level).add

5. 递归函数

6. 返回结果 result

 

 

二、Binary Tree Level Order Traversal I

 

代码部分一（1ms）

class Solution {
    public List<List<Integer>> levelOrderBottom(TreeNode root) {
        List<List<Integer>> res = new ArrayList<List<Integer>>();
        count(root, 0, res);
        return res;
    }
    
    public void count(TreeNode root, int i, List<List<Integer>> res){
        if(null == root)
            return;
        if(i >= res.size()){
            res.add(0,new ArrayList<Integer>());
        }
        res.get(res.size()-i-1).add(root.val);
        count(root.left, i+1, res);
        count(root.right, i+1, res);
    }
}

1. 调用count()

2. 判断数是否为空，是则return;

3. 判断当前层次“i”是否有记录了（是否第一次到达“i”层）

4. 将本层节点存入对应的 “倒层”（res.size()-i-1)

5. 递归遍历

6. 返回结果 res

 

代码部分二（2ms）:

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

1. 通过二叉树的层次遍历I 的方法得出正序结果

2. 利用Collections.reverse(),倒序list

3. 返回结果