剑指Offer——按之字形顺序打印二叉树

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

方法一：  这个方法和深度遍历没啥区别，BFS每次只取一个，但是这里得到队列的长度size，这里的size就是这一层的节点的个数。然后通过poll方法循环出这个size的节点。这里之字形取值的核心思路就是：
       (1)list.add(T): 按照索引顺序从小到大依次添加
       (2)list.add(index, T): 将元素插入index位置，index索引后的元素依次后移,这就完成了每一行元素的倒序，或者使用Collection.reverse()方法倒序也可以

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Queue;

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

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

    }

}
*/
public class Solution {
    //1.这个方法和深度遍历没啥区别，BFS每次只取一个，但是这里得到队列的长度size，这里的size就是这一层的节点的个数
    //然后通过poll方法循环出这个size的节点。这里之字形取值的核心思路就是：
       //(1)list.add(T): 按照索引顺序从小到大依次添加
       //(2)list.add(index, T): 将元素插入index位置，index索引后的元素依次后移,这就完成了每一行元素的倒序，或者使用Collection.reverse()方法倒序也可以
    public ArrayList<ArrayList<Integer> > Print(TreeNode pRoot) {
        ArrayList<ArrayList<Integer>> result=new  ArrayList<ArrayList<Integer>>();
        if(pRoot==null){
            return result;
        }
        Queue<TreeNode> queue=new LinkedList<>();
        queue.add(pRoot);
        boolean reverse=true;
        while(!queue.isEmpty()){
            int size=queue.size();
            ArrayList<Integer> list=new ArrayList<>();
            for(int i=0;i<size;i++)
            {
                TreeNode node=queue.poll();
                if(reverse){
                    list.add(node.val);
                }
                else{
                    list.add(0,node.val);
                }
              if(node.left!=null){
                  queue.add(node.left);
              }
              if(node.right!=null){
                  queue.add(node.right);
              }
            }
            if(list.size()>0){
                result.add(list);
            }
            reverse=!reverse;
        }
        return result;
    }

}

方法二：对一颗二叉树进行测试，发现这个规律：    借助两个栈，在打印某一层节点时，把下一层节点的子节点存放到栈里，如果当前打印的是奇数层，则先保存左节点，再保存右节点到第一个栈里。如果当前打印的是偶数层，则先保存右节点，再保存左节点到第一个栈里

import java.util.ArrayList;
import java.util.Stack;

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

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

    }

}
*/
public class Solution {
    //借助两个栈，在打印某一层节点时，把下一层节点的子节点存放到栈里
    //如果当前打印的是奇数层，则先保存左节点，再保存右节点到第一个栈里
    //如果当前打印的是偶数层，则先保存右节点，再保存左节点到第一个栈里
    public ArrayList<ArrayList<Integer> > Print(TreeNode pRoot) {
        ArrayList<ArrayList<Integer> > result=new ArrayList<ArrayList<Integer> >();
        if(pRoot==null){
            return result;
        }
        Stack<TreeNode> stack1=new Stack<>();
        Stack<TreeNode> stack2=new Stack<>();
        stack1.add(pRoot);
        int level=1;
        while(!stack1.isEmpty() || !stack2.isEmpty()){
            ArrayList<Integer> list=new ArrayList<>();
            //奇数层
            while(!stack1.isEmpty() && level%2==1){
                pRoot=stack1.pop();
               
                if(pRoot!=null){
                    if(pRoot.left!=null)
                        stack2.push(pRoot.left);
                    if(pRoot.right!=null)
                        stack2.push(pRoot.right);
                     list.add(pRoot.val);
                }
            }
            while(!stack2.isEmpty() && level%2==0){
                pRoot=stack2.pop();
                if(pRoot!=null)
                {
                    if(pRoot.right!=null){
                        stack1.push(pRoot.right);
                    }
                    if(pRoot.left!=null){
                        stack1.push(pRoot.left);
                    }
                      list.add(pRoot.val);
                }
                
            }
            result.add(list);
            level++;
        }
       return result;
        
    }

}