问题1：从上到下打印出二叉树的每个节点，同一层的节点按照从左到右的顺序打印。

    二叉树的广度优先搜索 用队列进行实现 每次扫描到节点将其 插入队列中然后输出
    例如:
    给定二叉树: [3,9,20,null,null,15,7],
    3
    / \
    9 20
    / \
    15 7

    1. /**
    2.  * Definition for a binary tree node.
    3.  * public class TreeNode {
    4.  *     int val;
    5.  *     TreeNode left;
    6.  *     TreeNode right;
    7.  *     TreeNode(int x) { val = x; }
    8.  * }
    9.  */
    10. class Solution {
    11.     public int[] levelOrder(TreeNode root) {
    12.         if(root == null) return new int[0];
    13.         Queue<TreeNode> queue = new LinkedList<>(){{ add(root); }};
    14.         ArrayList<Integer> ans = new ArrayList<>();
    15.         while(!queue.isEmpty()) {
    16.             TreeNode node = queue.poll();
    17.             ans.add(node.val);
    18.             if(node.left != null) queue.add(node.left);
    19.             if(node.right != null) queue.add(node.right);
    20.         }
    21.         int[] res = new int[ans.size()];
    22.         for(int i = 0; i < ans.size(); i++)
    23.             res[i] = ans.get(i);
    24.         return res;
    25.     }
    26. }
    27. 延续上一题的做法的同时加入 限制 每层打印 难点
    28.     // for(int i = 0 ; i < queue.size() ; i++ ){ 是错的 因为queue.size是变量不能 作为判断条件 但是一开始就取得作为初始条件就好
    29. 例如:
    30. 给定二叉树: [3,9,20,null,null,15,7],

    问题2：
    从上到下按层打印二叉树，同一层的节点按从左到右的顺序打印，每一层打印到一行。
    延续上一题的做法的同时加入 限制 每层打印 难点
    // for(int i = 0 ; i < queue.size() ; i++ ){ 是错的 因为queue.size是变量不能 作为判断条件 但是一开始就取得作为初始条件就好
    例如:
    给定二叉树: [3,9,20,null,null,15,7],
    3
    / \
    9 20
    / \
    15 7

    1. /**
    2.  * Definition for a binary tree node.
    3.  * public class TreeNode {
    4.  *     int val;
    5.  *     TreeNode left;
    6.  *     TreeNode right;
    7.  *     TreeNode(int x) { val = x; }
    8.  * }
    9.  */
    10. class Solution {
    11.     public List<List<Integer>> levelOrder(TreeNode root) {
    12.         List<List<Integer>> list =new ArrayList<>();
    13.         if(root==null)return list;
    14.         Queue <TreeNode> queue = new LinkedList<>();
    15.         queue.add(root);
    16.         while(!queue.isEmpty()){
    17.          List <Integer> list1  = new ArrayList<>();
    18.         // for(int i = 0 ; i < queue.size() ; i++ ){ 是错的 因为queue.size是变量不能 作为判断条件 但是一开始就取得作为初始条件就好
    19.             for(int i = queue.size(); i > 0; i--) {
    20.             TreeNode t = queue.poll();
    21.             list1.add(t.val);   
    22.             if(t.left!= null)
    23.                     queue.add(t.left);
    24.             if(t.right!=null)
    25.                     queue.add(t.right); 
    26.         } 
    27.                 list.add(list1);
    28.                 }
    29.             return list;
    30.     }
    32. }

    问题3：
    请实现一个函数按照之字形顺序打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右到左的顺序打印，第三行再按照从左到右的顺序打印，其他行以此类推。
    从第一层开始记录 CNT =1 第二层 CNT=2 然后 调用Collections.reverse()进行翻转

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

    1. 3<br />   / \<br />  9  20<br />    /  \<br />   15   7
    1. /**
    2.  * Definition for a binary tree node.
    3.  * public class TreeNode {
    4.  *     int val;
    5.  *     TreeNode left;
    6.  *     TreeNode right;
    7.  *     TreeNode(int x) { val = x; }
    8.  * }
    9.  */
    10. class Solution {
    11.     public List<List<Integer>> levelOrder(TreeNode root) {
    12.         List<List<Integer>> list = new ArrayList<>();
    13.         if(root==null) return list;
    14.         Queue < TreeNode> queue =new LinkedList<>();
    15.         queue.offer(root);
    16.         int cnt =0;
    17.         while(!queue.isEmpty()){
    18.             List<Integer> list1 = new ArrayList<>();
    19.             for(int i = queue.size() ; i>0 ;i--){
    20.                 TreeNode t = queue.poll();
    21.                 list1.add(t.val);
    22.                 if(t.left != null) queue.offer(t.left);
    23.                 if(t.right != null) queue.offer(t.right);
    24.              }
    25.              cnt++;
    26.                if(cnt%2==0) 
    27.                {Collections.reverse(list1);} 
    29.                list.add(list1);
    30.         }
    31.     return list;
    33.     }
    34. }

    问题4：