剑指offer 从上往下打印二叉树 | 把二叉树打印成多行 | 按之字形顺序打印二叉树

从上往下打印二叉树

分析

题目很简短，需要我们自上而下，自左至右打印数据，这个“打印”我们可以理解为在列表中按照这个顺序添加参数。原本想到的是递归的方法，但是它不能做到这种按层的打印，必定会沿着子树不断递归。按层打印的效果的实现可以通过队列，先入队当前节点的左右节点，然后把当前节点的值打印，再出队左子节点，对左子节点的子节点进行入队，然后再出队右子节点，它的子节点入队。这样这一层已经按照顺序打印，下一层也已经按照顺序排队等待出队了，这样就实现了按层打印。
特殊情况处理：

      if (root == null) {
          return list;
      }

代码

public class Solution {
        public ArrayList<Integer> PrintFromTopToBottom(TreeNode root) {
              ArrayList<Integer> list  = new ArrayList<>();
              if (root == null) {
                  return list;
              }

              Queue<TreeNode> q = new LinkedList<TreeNode>();
              q.add(root);

              while (q.isEmpty() == false) {
                  TreeNode node = q.poll();
                  if (node.left != null) {
                      q.add(node.left);
                  }
                  if (node.right != null) {
                      q.add(node.right);
                  }
                  list.add(node.val);
              }
              return list;

        }
}

把二叉树打印成多行

分析

直接点出这题和上一题的区别，上一题只要按照从上到下，从左到右的顺序打印就可以了，而这题需要实现“分层”，嵌套ArrayList。
解决思路是分清层与层之间的区别，逐层处理数据，判断采用while非空判断。
队列：队列可以实现从上到下，从左到右的遍历顺序，这里不赘述。
如何分层？代码中用到了两层while(!que.isEmpty())，第一层是用来判断下一层有没有节点的，第二层是用来判断当前遍历层是否还有节点剩余。采用temp临时队列来保存下一层的节点，当前层“取”完后就把其中的节点移到que，开始下一层的读取。

代码

public class Solution {
    ArrayList<ArrayList<Integer> > Print(TreeNode pRoot) {
        ArrayList<ArrayList<Integer>> listAll = new ArrayList();
        Queue<TreeNode> que = new LinkedList<TreeNode>();
        if(pRoot == null) {
            return listAll;
        }
        que.offer(pRoot);
        while(!que.isEmpty()){
            ArrayList<TreeNode> temp = new ArrayList();
            ArrayList<Integer> list = new ArrayList();
            while(!que.isEmpty()){
                TreeNode node = que.poll();
                list.add(node.val);
                if(node.left != null) {
                    temp.add(node.left);
                }
                if(node.right != null) {
                    temp.add(node.right);
                }
            }
            listAll.add(list);
            for(int i = 0; i < temp.size(); i++) {
                que.offer(temp.get(i));
            }
        }
        return listAll;
    }
    

}    

按之字形顺序打印二叉树

分析

和上一题的区别是它在打印的时候多了一个方向性，那么需要解决两个问题：一个问题是怎么实现来回的方向判断，另一个问题是怎么实现反置打印。
方向判断：
采用一个boolean值来实现方向的判断，每次判断后都取反。
反置打印：
借助栈，把数据存入和取出，这时就可以实现反转了。

代码

public class Solution {
    boolean flag = true;
    public ArrayList<ArrayList<Integer> > Print(TreeNode pRoot) {
        ArrayList<ArrayList<Integer>> listAll = new ArrayList();
        Queue<TreeNode> que = new LinkedList<TreeNode>();
        if(pRoot == null) {
            return listAll;
        }
        que.offer(pRoot);
        while(!que.isEmpty()){
            ArrayList<TreeNode> temp = new ArrayList();
            ArrayList<Integer> list = new ArrayList();
            while(!que.isEmpty()){
                TreeNode node = que.poll();
                list.add(node.val);
                if(node.left != null) {
                    temp.add(node.left);
                }
                if(node.right != null) {
                    temp.add(node.right);
                }
            }
            if(flag == false) {
                Stack<Integer> stack = new Stack();
                for(Integer val : list) {
                    stack.push(val);
                }
                ArrayList<Integer> nums = new ArrayList();
                while(stack.isEmpty() == false) {
                    nums.add(stack.pop());
                }
                list = nums;
                flag = true;
            }else {
                flag = false;
            }
            listAll.add(list);
          
            for(int i = 0; i < temp.size(); i++) {
                que.offer(temp.get(i));
            }


        }
        return listAll;
    }

}