32 - I. 从上到下打印二叉树，转int[]，队列poll add，二叉树层序遍历，32 II，32 - III.

32 - I. 从上到下打印二叉树

利用队列的特点，先入先出，poll的同时add该节点的左右子树。

• poll：删除队头元素，并返回删除的元素，如果队列为null，返回null
• add：在队尾添加元素，添加成功返回true，如果队列已满无法添加则抛出异常。

• ArrayList转int[]

    public int[] levelOrder(TreeNode root) {
        Deque<TreeNode> ts = new LinkedList<>();
        ArrayList<Integer> ans = new ArrayList<>();
        if(root==null) {
            int[] a = new int[0];
            return a;
        }
        TreeNode d1;
        ts.push(root);
        while (!ts.isEmpty()) {
            d1 = ts.poll();
            if (d1==null) continue;
            ans.add(d1.val);
            ts.add(d1.left);
            ts.add(d1.right);
        }
        int[] a = new int[ans.size()];
        for (int i = 0; i < ans.size(); i++) {
            a[i] = ans.get(i);
        }
        return a;
    }

32 - II. 从上到下打印二叉树 II

与上题相比，输出的形式变了。
同样用poll()和add()

• poll和pop的区别在于，当栈为null时，pop报异常，poll返回null
  用add()不用push

改的地方：

*　List<List<Integer>> lists = new ArrayList<>();
*　for(i=size;i=0;i--),
tns栈，用来存放节点
lists是List的数组，用来存放全部结果
tmp是interger的数组，用来存放一行的结果

public List<List<Integer>> levelOrder(TreeNode root) {
    Deque<TreeNode> tns = new LinkedList<>();
    List<List<Integer>> lists = new ArrayList<>();
    tns.push(root);
    while(!tns.isEmpty()){
        List<Integer> tmp = new ArrayList<>();
        for (int i = tns.size();i>0; i--) {
            TreeNode n = tns.poll();
            if (n.left!=null){
                tns.add(n.left);
            }
            if (n.right!=null){
                tns.add(n.right);
            }
            tmp.add(n.val);

        }
        lists.add(lists1);
    }
    return lists;

32 - III. 从上到下打印二叉树 III

这里tmp改为LinkedList，如果层数为偶数就正常存入，如果为奇数就反着存。
需要用到addFirst()

public List<List<Integer>> levelOrder(TreeNode root) {
    Queue<TreeNode> queue = new LinkedList<>();
    List<List<Integer>> res = new ArrayList<>();
    if(root != null) queue.add(root);
    while(!queue.isEmpty()) {
        LinkedList<Integer> tmp = new LinkedList<>();
        for(int i = queue.size(); i > 0; i--) {
            TreeNode node = queue.poll();
            if (res.size()%2==0){
                tmp.add(node.val);
            }else{
                tmp.addFirst(node.val);
            }
            if(node.left != null) queue.add(node.left);
            if(node.right != null) queue.add(node.right);
        }
        res.add(tmp);
    }
    return res;
}