关于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;
}