题目

103. 二叉树的锯齿形层序遍历【中等】

题解

感觉今天这道锯齿形层序遍历是昨天那道二叉树层序遍历的进阶版

栈版

自己想到的方法是，既然出现了“逆序”，那果断想到栈啊，正常层序遍历代码+栈解决，于是代码如下：

class Solution {
    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
        List<List<Integer>>levelOrder=new ArrayList<List<Integer>>();//记录遍历结果
        if(root==null)
            return levelOrder;
        Queue<TreeNode>queue=new LinkedList<TreeNode>();//队列
        int level=1;//记录层数
        queue.offer(root);
        int sk;
        while(!queue.isEmpty()){
            sk=queue.size();
            List<Integer>Level=new ArrayList<Integer>();
            //奇数层正常操作
            if(level%2==1){
                while(sk>0){
                    TreeNode p=queue.poll();
                    Level.add(p.val);
                    if(p.left!=null)
                        queue.offer(p.left);
                    if(p.right!=null)
                        queue.offer(p.right);
                    sk--;
                }
            }
            //偶数层元素出队以后先入栈，再依次出栈存入层次遍历序
            else{
                Stack<Integer>stack=new Stack<Integer>();
                while(sk>0){
                    TreeNode p=queue.poll();
                    stack.push(p.val);
                    if(p.left!=null)
                        queue.offer(p.left);
                    if(p.right!=null)
                        queue.offer(p.right);
                    sk--;
                }
                //出栈
                while(!stack.empty()){
                    int value=stack.pop();
                    Level.add(value);
                }
            }
            level++;
            levelOrder.add(Level);
        }
        return levelOrder;
    }
}

双端队列版

双端队列可以在队列任意一端插入元素，用Deque实现

class Solution {
    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
        List<List<Integer>>levelOrder=new ArrayList<List<Integer>>();//记录遍历结果
        if(root==null)
            return levelOrder;
        Queue<TreeNode>queue=new LinkedList<TreeNode>();//队列
        queue.offer(root);
        int sk;
        boolean reverse=false;//判断该层需不需要逆序
        while(!queue.isEmpty()){
            sk=queue.size();
            Deque<Integer>levelqueue=new LinkedList<Integer>();//双端队列记录每层遍历序
            while(sk>0){
                TreeNode p=queue.poll();
                if(reverse)//逆序（偶数层）
                    levelqueue.offerFirst(p.val);//从头入队
                else
                    levelqueue.offerLast(p.val);
                if(p.left!=null)
                    queue.offer(p.left);
                if(p.right!=null)
                    queue.offer(p.right);
                sk--;
            }
            reverse=!reverse;
            levelOrder.add(new LinkedList<Integer>(levelqueue));//Daque转化List
        }
        return levelOrder;
    }
}