剑指offer T32及其变种从上到下打印二叉树(之字型打印)

T32-1

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    /*
    思想:利用层次遍历思想，只不过注意这里返回的是一个数组，所以可以先借助一个list，先把元素存到Listz中然后再根据list的size去新建一个len=size的数组，再返回
    */
    public int[] levelOrder(TreeNode root) {
      if(root==null) return new int[0];  
      List<Integer> list = new ArrayList<>();
      LinkedList<TreeNode> queue = new LinkedList<>();
      //层次遍历
      queue.add(root);
      while(!queue.isEmpty()){
          TreeNode temp = queue.remove();
          list.add(temp.val);
          if(temp.left!=null){
              queue.add(temp.left);
          }
          if(temp.right!=null){
              queue.add(temp.right);
          }
      }
     //数组转化
     int idx = 0;
     int[] res= new int[list.size()];
     for(int i=0;i<list.size();i++){
         res[idx++] = list.get(i);
     }
     return res;
    }
}

T32-2
思想：32-1的一种变形，也就是相当于逐层打印，还是利用层次遍历，不过要区别不同层，注意一点如何更新rear指针（指向每层的最后一个结点）

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
    List<List<Integer>> res = new ArrayList<>();
    if(root==null) return res;
    LinkedList<TreeNode> queue = new LinkedList<>();
    List<Integer> layer = new ArrayList<>();
    //rear用于指向每层的最后一个阶段
    TreeNode rear = null;
    //层次遍历 
    queue.add(root);
    rear = root;
    while(!queue.isEmpty()){
        TreeNode temp = queue.remove();
        layer.add(temp.val);
        //先将非空左右孩子入队，便于更新rear
        if(temp.left!=null){
            queue.add(temp.left);
        }
        if(temp.right!=null){
            queue.add(temp.right);
        }
        //表明temp是本层最后一个结点
        if(temp.equals(rear)){
          res.add(layer);
          layer = new ArrayList<>();
          //更新rear指针，令其指向下一层的最后一个结点也就是此时queue中的最后一个入队结点
          //这里注意要加一个队列是否为空的判断，为空时表示没有下一层了，也就不用更新rear了，当队列不为空时才去更新rear
          if(!queue.isEmpty()){
           rear = queue.getLast();
          }
        }
    }
    return res;
    }
}

T32-3 之字型打印二叉树
思想:题目意思是先按从左到右的顺序打印每一层的元素再按从右到左的顺序打印下一层元素依次类推，交替打印
其实也就是让我们分奇偶层打印，还是可以按照从左往右的顺序进行层次遍历，然后只不过在往res添加本层元素列表layer时要依旧层数是奇数层还是偶数层：
当是偶数层时就直接添加layer即可
当是奇数层时要添加layer的逆序，因为layer中是按从左往右打印本层元素的

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
     List<List<Integer>> res = new ArrayList<>();
     if(root==null) return res;
     LinkedList<TreeNode> queue = new LinkedList<>();
     List<Integer> layer = new ArrayList<>();
     //rear用于指向每层的最后一个阶段
     TreeNode rear = null;
     //层次遍历 
     queue.add(root);
     rear = root;
     int layerCounts = 0;//表示层数
     while(!queue.isEmpty()){
        TreeNode temp = queue.remove();
        layer.add(temp.val);
        //按从左到右的顺序打印本层元素(顺序打印下一层元素)
        if(temp.left!=null){
            queue.add(temp.left);
        }
        if(temp.right!=null){
            queue.add(temp.right);
        }
        //表明temp是本层最后一个结点
        if(temp.equals(rear)){
          //判断本层的层数是奇数还是偶数以此决定打印顺序  
          if(layerCounts%2!=0){
            Collections.reverse(layer);
          }
          res.add(layer);
          //层数+1
          layerCounts++;  
          layer = new ArrayList<>();
          if(!queue.isEmpty()){
           rear = queue.getLast();
          } 
        }
    }
    return res;  
}}

T32-3改进型：
思想：上面那个做法还需要额外的逆序操作，此时可以借助LinkedList实现双端队列来避免进行额外的逆序操作

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
     List<List<Integer>> res = new ArrayList<>();
     if(root==null) return res;
     LinkedList<TreeNode> queue = new LinkedList<>();
     //注意这里用LinkedList也就是双端队列来存每层元素
     LinkedList<Integer> layer = new LinkedList<>();
     //rear用于指向每层的最后一个阶段
     TreeNode rear = null;
     //表示层数
     int layerCounts = 0;
     //层次遍历 
     queue.add(root);
     rear = root;
     while(!queue.isEmpty()){
      TreeNode temp = queue.remove();
      //根据层数的奇偶来确定本层元素的打印顺序不是遍历顺序，遍历顺序均是按从左往右！！！   
      if(layerCounts%2==0){
       layer.addLast(temp.val);
      }else{
        layer.addFirst(temp.val);
      }
      if(temp.left!=null) queue.add(temp.left);
      if(temp.right!=null) queue.add(temp.right);
      //temp为本层的最后一个结点
      if(temp.equals(rear)){
        res.add(layer);  
       //层数自增1   
       layerCounts++;
       layer = new LinkedList<>();
       //更新rear指针
       if(!queue.isEmpty()){
         rear = queue.getLast();
       }
      } 
     }
     return res;
    }
}