（剑指 Offer）从上到下打印二叉树 I；从上到下打印二叉树 II

从上到下打印二叉树 I

二叉树的层次遍历，一般层次遍历使用队列，
思路如下：

• 将树根元素root入队

• 开始循环：每次判断队列是否为空，为空则结束循环

• 不为空执行以下步骤

1. 将队头元素出队，将队头val存储；
2. 将队头节点的左右孩子入队;
   代码如下

 ans.offer(root);
        while(!ans.isEmpty())
        {
            TreeNode temp = ans.poll();
            res.add(temp.val);
            if(temp.left != null) ans.offer(temp.left);
            if(temp.right != null) ans.offer(temp.right);
        }

总体代码如下：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public int[] levelOrder(TreeNode root) {
        Queue<TreeNode> ans = new LinkedList<>();
        ArrayList<Integer> res = new  ArrayList<Integer>();
        if(root == null)
        return new int[]{};
        ans.offer(root);
        while(!ans.isEmpty())
        {
            TreeNode temp = ans.poll();
            res.add(temp.val);
            if(temp.left != null) ans.offer(temp.left);
            if(temp.right != null) ans.offer(temp.right);
        }

        int[] res1 = new int[res.size()];
        for(int i = 0 ; i < res.size(); i++)
        {
            res1[i] = res.get(i);
        }
        return res1;

    }
}

从上到下打印二叉树 II

这个题目和上一个提的区别在分别存储每层的节点，使用一个size去存储每层节点的数量。即多加一个循环既可以解决：
总体代码如下：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        Queue<TreeNode> ans = new LinkedList<>();
        List<List<Integer> > ress = new ArrayList<List<Integer>>();
        if(root == null)
        return ress;
        ans.offer(root);
        while(!ans.isEmpty())
        {   
            int size = ans.size();
            ArrayList<Integer> res = new  ArrayList<Integer>();
            for(int i = 0 ; i < size ; i++)
            {
            TreeNode temp = ans.poll();
            res.add(temp.val);
            if(temp.left != null) ans.offer(temp.left);
            if(temp.right != null) ans.offer(temp.right);
            }
            ress.add(res);
            
        }
        
        return ress;

    }
}

还有一个三，这个只需要在上一个题目中加一个flag就可以，每次交换一下真假，
然后选择对res是否翻转即可。
使用Collections.reserver();
代码如下：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
         Queue<TreeNode> ans = new LinkedList<>();
        List<List<Integer> > ress = new ArrayList<List<Integer>>();
        if(root == null)
        return ress;
        ans.offer(root);
        boolean flag = true;
        while(!ans.isEmpty())
        {   
            int size = ans.size();
            ArrayList<Integer> res = new  ArrayList<Integer>();
            for(int i = 0 ; i < size ; i++)
            {
            TreeNode temp = ans.poll();
            res.add(temp.val);
            if(temp.left != null) ans.offer(temp.left);
            if(temp.right != null) ans.offer(temp.right);

            }
            if(flag)
            {
                ress.add(res);
                flag = !flag;  
            }
            else
            {
            Collections.reverse(res);
            flag = !flag;  
            ress.add(res);  
            }
    
        }
        
        return ress;

    }
}