32.【二叉树】二叉树从上到下打印

题目1：从上往下按层打印

描述

从上往下打印出二叉树的每个节点，同层节点从左至右打印。

思路

利用一个队列按照层的顺序依次入队列遍历即可。

代码实现

/**
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

    public TreeNode(int val) {
        this.val = val;

    }
}
*/
public class Solution {
    public ArrayList<Integer> PrintFromTopToBottom(TreeNode root) {
		ArrayList<Integer> list = new ArrayList<Integer>();
		if(root == null){
			return list;
		}
		Deque <TreeNode> deque = new LinkedList<TreeNode>();
		deque.add(root);
		while(!deque.isEmpty()){
			TreeNode now = deque.pop();
			list.add(now.val);
			if(now.left != null){
				deque.add(now.left);
			}
			if(now.right!=null){
				deque.add(now.right);
			}
		}
		return list;
    }
}

题目2：

描述：

从上到下按层打印二叉树，同一层的节点按从左到右的顺序打印，每一层打印到一行。

思路

1.使用队列保存节点

2.新增变量用以保存当前层的节点数量

代码实现

public List<List<Integer>> levelOrder(TreeNode root) {
        //特殊情况判断
        if(root == null)
            return new ArrayList<>();
        //新建结果集和队列
        List<List<Integer>> res = new ArrayList<>();
        Queue <TreeNode> queue = new LinkedList<TreeNode>();
        
        //根节点进入队列
        int count = 0;
        queue.offer(root);
        while(!queue.isEmpty()){
            //保存每一层的输出
            List<Integer> tmp = new ArrayList<Integer>();
            //当前层的节点数
            count = queue.size();
            while(count > 0){
                TreeNode t = queue.poll();
                tmp.add(t.val);
                if(t.left != null) queue.add(t.left);
                if(t.right != null) queue.add(t.right);
                count --;
            }
            res.add(tmp);
        }
        return res;
    }

题目3：

描述：

请实现一个函数按照之字形顺序打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右到左的顺序打印，第三行再按照从左到右的顺序打印，其他行以此类推。

思路：

添加一个标志位，用来记录是否需要将每一层的节点反转即可，反转用栈实现

代码实现：

 public List<List<Integer>> levelOrder(TreeNode root) {
        if(root == null)
            return new ArrayList<>();
        List<List<Integer>> res = new ArrayList<>();
        Queue <TreeNode> queue = new LinkedList<TreeNode>();
        boolean flag = true;
        int count = 0;
        queue.offer(root);
        while(!queue.isEmpty()){
            List<Integer> tmp = new ArrayList<Integer>();
            count = queue.size();
            while(count > 0){
                TreeNode t = queue.remove();
                tmp.add(t.val);
                if(t.left != null) queue.add(t.left);
                if(t.right != null) queue.add(t.right);
                count --;
            }
            if(flag){
                flag = false;
                res.add(tmp);
                continue;
            }else{
                flag = true;
                //反转结果集中数字
                Stack <Integer> s = new Stack();
                for(int i=0;i<tmp.size();i++){
                    s.add(tmp.get(i));
                }
                tmp.clear();
                while(!s.isEmpty()){
                    tmp.add(s.pop());
                }
                res.add(tmp);
            }

        }
        return res;