按之字形顺序打印二叉树

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

思路1：
先全都存储在一个临时列表中，并记录每层个数，再根据层数奇偶性确定从左往右放还是从右往左放.
但是：在海量数据时，这样效率太低了。

public class Solution {
    public ArrayList<ArrayList<Integer> > Print(TreeNode pRoot) {
        ArrayList<Integer> al=new ArrayList<>();//记录每层数目
        ArrayList<Integer> res1=new ArrayList<>();//放初得结果
        ArrayList<ArrayList<Integer> > res2=new ArrayList<>();//放最终结果
        ArrayDeque<TreeNode> ad=new ArrayDeque<>();
        if(pRoot==null)return res2;
        int now=0,thisLayer=1,nextLayer=0;
        ad.add(pRoot);
        al.add(thisLayer);
        while(!ad.isEmpty()){
            TreeNode temp=ad.pollFirst();
            res1.add(temp.val);
            now++;
            if(temp.left!=null){
                ad.add(temp.left);
                nextLayer++;
            }
            if(temp.right!=null){
                ad.add(temp.right);
                nextLayer++;
            }
            if(now==thisLayer){
                al.add(nextLayer);//最后会含有0
                now=0;
                thisLayer=nextLayer;
                nextLayer=0;
            }
        }
        int r=0;
        for(int i=0;i<al.size()-1;i++){
            int l=r;
            r+=al.get(i);
            ArrayList<Integer> part_res=new ArrayList<>();
            if((i+1)%2==1){
                for(int j=l;j<r;j++){
                    part_res.add(res1.get(j));
                }
            }else{
                for(int j=r-1;j>=l;j--){
                    part_res.add(res1.get(j));
                }
            }
            res2.add(part_res);

        }
        return res2;
    }
}

思路2：
可直接按打印顺序存入，利用Java中的LinkedList的底层实现是双向链表的特点。

• 1)可用做队列,实现树的层次遍历
  

• 2)可双向遍历,奇数层时从前向后遍历，偶数层时从后向前遍历
  

import java.util.*;
public class Solution {
    public ArrayList<ArrayList<Integer> > Print(TreeNode pRoot) {
        ArrayList<ArrayList<Integer> > res=new ArrayList<>();//放最终结果
        ArrayList<Integer> al=new ArrayList<>();
        if(pRoot==null)return res;
        LinkedList<TreeNode> ll=new LinkedList<>();
        ll.addLast(null);
        ll.addLast(pRoot);
        boolean leftToright=true;
        while(ll.size()!=1){
            TreeNode node=ll.removeFirst();
            if(node==null){//为空表示本层所有结点的孩子结点均已遍历完且存入双端链表，可开始做存储操作
                Iterator<TreeNode> iter=null;
                if(leftToright){
                    iter=ll.iterator();
                }else{
                    iter=ll.descendingIterator();
                }
                leftToright=!leftToright;
                while(iter.hasNext()){
                    TreeNode temp=(TreeNode)iter.next();
                    al.add(temp.val);
                }
                res.add(new ArrayList<Integer>(al));//匿名对象能减小内存开销
                al.clear();
                ll.addLast(null);//用于下一次迭代存储
                continue;//以防继续向下走完本轮循环，从而产生空指针异常
            }
            if(node.left!=null){
                ll.addLast(node.left);
            }
            if(node.right!=null){
                ll.addLast(node.right);
            }
        }
        return res;
    }
}