关于java:32-I-从上到下打印二叉树转int队列poll-add二叉树层序遍历32-II32-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;
}