LeetCode-Tree&BFS-103-M：二叉树的锯齿形层次遍历（Binary Tree Zigzag Level Order Traversal）

给定一个二叉树，返回其节点值的锯齿形层次遍历。（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。

思路

（1）在LeetCode-Tree-102-M：二叉树的层次遍历的基础上对偶数行进行处理。
（2）另外参见剑指Offer-树-面试题32-3：按之字形顺序打印二叉树，不同的解法。借用了栈的处理。

解法1-两个队列

执行用时 :2 ms, 在所有 Java 提交中击败了21.23%的用户
内存消耗 :36.3 MB, 在所有 Java 提交中击败了55.89%的用户

class Solution {

    List<List<Integer>> list1 = new ArrayList<>();
    List<Integer> list2 = new ArrayList<>();

    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {

        if(root == null){
            return list1;
        }

        Queue<TreeNode> queue1 = new LinkedList<>();
        Queue<TreeNode> queue2 = new LinkedList<>();
        queue2.offer(root);
        int c=0;
        while(!queue1.isEmpty() || !queue2.isEmpty()){

            while(queue1.isEmpty()){
                while(!queue2.isEmpty()){
                    queue1.offer(queue2.poll());
                }

                list2 = new ArrayList<>();
                list1.add(list2);
                c++;
            }

            TreeNode curNode = queue1.poll();
            list2.add(curNode.val);

            if(curNode.left != null){
                queue2.offer(curNode.left);
            }

            if(curNode.right != null){
                queue2.offer(curNode.right);
            }

            //change the even level
            if(c%2 == 0 && (queue1.isEmpty())){
                int i = 0, j = list2.size()-1;
                while(i < j){
                    int temp = list2.get(j);
                    list2.set(j, list2.get(i));
                    list2.set(i, temp);
                    i++;
                    j--;
                }
            }
        }
        
        return list1;
    }
}

解法2-队列+栈

执行用时 :1 ms, 在所有 Java 提交中击败了98.78%的用户
内存消耗 :36 MB, 在所有 Java 提交中击败了73.21%的用户

class Solution {
    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>();
        if(root == null){
            return res;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        Stack<Integer> stack = new Stack<>();
        queue.offer(root);
        int c = 1;
        while(!queue.isEmpty()){
            int size = queue.size();
            List<Integer> list = new ArrayList<>();
            res.add(list);
            for(int i=0; i<size; i++){
                TreeNode cur = queue.poll();       
                
                if(c % 2==0){
                    stack.push(cur.val);
                    if(i+1 == size){
                        while(!stack.isEmpty()){
                            list.add(stack.pop());
                        }
                    }
                }else{
                    list.add(cur.val);
                }
                
                if(cur.left != null){
                    queue.offer(cur.left);
                }
                if(cur.right != null){
                    queue.offer(cur.right);
                } 
            }
            c++;
        }
        
        return res;
    }
}