LeetCode-Tree&BFS-102-M：二叉树的层次遍历（Binary Tree Level Order Traversal）

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

思路

（1）借用两个队列来交替完成，不够优化。参见剑指Offer-树-面试题32-2：分行从上到下打印二叉树。
（2）注意点：
1）第一个结点的处理。可以统一在后面添加到链表中，这里用queue2封装第一个结点。
2）后续小链表添加值怎么处理。写在后面的while循环内会造成最后多一个空的小数组。why？

解法1-两个队列

执行用时 :2 ms, 在所有 Java 提交中击败了21.23%的用户
内存消耗 :36.3 MB, 在所有 Java 提交中击败了55.89%的用户

class Solution {

    List<List<Integer>> list1 = new ArrayList<>();
    List<Integer> list2 = new ArrayList<>();
    Queue<TreeNode> queue1 = new LinkedList<>();
    Queue<TreeNode> queue2 = new LinkedList<>();

    public List<List<Integer>> levelOrder(TreeNode root) {
        //1.层次遍历
        //2.分层存储
        
        if(root == null){
            return list1;
        }

        queue2.offer(root);
        //list2.add(root.val);
        // list1.add(list2);

        while(!queue1.isEmpty() || !queue2.isEmpty()){

            while(queue1.isEmpty()){
            
				while(!queue2.isEmpty()){
                    queue1.offer(queue2.poll());
                }
                //queue1=new LinkedList<>(queue2);
                //queue2.clear();
                list2 = new ArrayList<>();
                list1.add(list2);
            }
            
             TreeNode curNode = queue1.poll();
             list2.add(curNode.val);
            
            if(curNode.left != null){
                //list2.add(curNode.left.val);
                queue2.offer(curNode.left);
            }

            if(curNode.right != null){
               // list2.add(curNode.right.val);
                queue2.offer(curNode.right);
            }

        }

        return list1;
    }
}

解法2-1个队列实现BFS

（1）队列的值不是一直在更新的，只有跳出循环后，才会重新赋值，尽管在此之前的长度已经改变了。

执行用时 :1 ms, 在所有 Java 提交中击败了98.78%的用户
内存消耗 :36.5 MB, 在所有 Java 提交中击败了25.42%的用户

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

解法3-递归

https://leetcode.com/problems/binary-tree-level-order-traversal/discuss/33445/Java-Solution-using-DFS

---

执行用时 :1 ms, 在所有 Java 提交中击败了98.78%的用户
内存消耗 :36.3 MB, 在所有 Java 提交中击败了68.67%的用户

class Solution {

    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> res = new ArrayList<List<Integer>>();
        levelHelper(res, root, 0);
        return res;
    }
    
    public void levelHelper(List<List<Integer>> res, TreeNode root, int height) {
        if (root == null){
            return ;
        } 

        if (height >= res.size()) {
            res.add(new LinkedList<Integer>());
        }
        
        res.get(height).add(root.val);
        levelHelper(res, root.left, height+1);
        levelHelper(res, root.right, height+1);
    }
}