剑指offer----之字形打印二叉树

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

思路：

（1）如果每层都是从左到右一次打印这样只需要一个队列，在访问当前节点时，把当前节点的孩子存入队列就可以实现。

（2）现在奇数层出队顺序是正确的，偶数层的话就是队列反过来的顺序，所以依然用队列在每一层出队节点，如果左右孩子存在，入队节点的左右孩子，

（3）为了实现在偶数层是从右到左打印，那么在奇数层把节点的左右节点入队时，可以添加一个栈，入栈顺序是偶数层从左到右的顺序，出栈顺序就是从右到左。

总的思路：

两个辅助空间，

队列：每一层都要出队当前节点的时候把不为空的左右孩子入队。

栈：在奇数层，在入队当前节点的左右孩子时，同时将左右孩子入栈。在偶数层出队的时候也让栈里节点依次出栈，此时还需要把出栈节点的左右孩子入队。栈的作用就是把偶数层从左到右一次保存起来。在访问偶数层时把它出栈就行。

import java.util.ArrayList;
import java.util.LinkedList;
/*
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>> list1 = new  ArrayList<ArrayList<Integer>>();
	       
	       if(pRoot == null)
	       {
	           return list1;
	       }
	        LinkedList<TreeNode> queue = new LinkedList<TreeNode>();//存放每层的节点
	        LinkedList<TreeNode> stack = new LinkedList<TreeNode>();//存放偶数层的节点
	        TreeNode current = pRoot;
        	TreeNode queueNode = null;
	        queue.offer(current);
	        int count;//记录当前层已经打印的个数
	        int last;//记录当前层一个有多少个
        	boolean flag = true;
	        while(!queue.isEmpty()||!stack.isEmpty())
	        {
	        	//打印奇数层入队偶数层，入栈偶数层（入栈节点和入队节点相同）。
	        	if(flag)
	        	{
	        		flag = false;
                    count = 0;
		        	last = queue.size();
		        	ArrayList<Integer> list2 = new ArrayList<Integer>();//用于存放本层节点的值
		        	//打印一层
		        	while(count < last)
		        	{
		        		current = queue.poll();//出队一个节点并将气质加入到list2中
		        		list2.add(current.val);
		        		count++;//每出队一个几点就增加一个当前层已经打印的节点个数
		        		if(current.left != null)
                        {
                            stack.push(current.left);
                            queue.offer(current.left);
                        }
		        			
		        		if(current.right != null)
                        {
                            stack.push(current.right);
                            queue.offer(current.right);
                        }
		        			
		        	}
		        	list1.add(list2);
	        	}
                //打印偶数层，出队节点，根据出队节点将下一层节点入队，（出栈节点不为空的左右孩子）出栈的节点是需要打印的节点
	        	else
	        	{
                    flag = true;
	        		count = 0;
		        	last = stack.size();
		        	ArrayList<Integer> list3 = new ArrayList<Integer>();//用于存放本层节点的值
		        	//打印偶数层
		        	while(count < last)
		        	{
		        		current = stack.pop();//出栈偶数层节点
		        		list3.add(current.val);
		        		count++;//每出队一个几点就增加一个当前层已经打印的节点个数
                        queueNode = queue.poll();//出队节点，按照出队节点入队下一层节点从左到右
		        		if(queueNode.left != null)
                        {
                            queue.offer(queueNode.left);
                        }
		        			
		        		if(queueNode.right != null)
                        {
                            queue.offer(queueNode.right);
                        }
		        			
		        	}
		        	list1.add(list3);
	        	}
	        
	        }
	       return list1; 
    }

}