Binary Tree Zigzag Level Order Traversal

https://leetcode.com/problems/binary-tree-zigzag-level-order-traversal/

Given a binary tree, return the zigzag level order traversal of its nodes' values. (ie, from left to right, then right to left for the next level and alternate between).

For example:
Given binary tree {3,9,20,#,#,15,7},

    3
   / \
  9  20
    /  \
   15   7

 

return its zigzag level order traversal as:

[
  [3],
  [20,9],
  [15,7]
]

 

confused what "{1,#,2,3}" means? > read more on how binary tree is serialized on OJ.

解题思路：

这道题用的是二叉树的层次遍历，难度不大，但是有点绕。开始想到用deque来做，最后发现其实只要一个stack就可以了。

具体是，我们令第一层为1。这样遍历奇数层的时候，奇数层是从左到有输出，但由于它的下一层（偶数层）是要从右到左输出的，我们就先将左子树进栈，再将右子树进栈。

同理，遍历偶数层的时候，偶数层是从右到左遍历的，下一层要从左到右输出，我们就先将右子树进栈，再将左子树进栈。

其他过程和层次遍历没什么不同。

要注意的是：

1. 这里需要用到两个stack，用来维护当前层次的stack，和下一层次的stack。因为stack不是queue，push进元素的时候，就无法按照原来元素的顺序取出了。

2. 这里要注意因为每层的遍历顺序也不同，下一层的输出顺序也不同，所以只要stack就可以了，先进后出，并不需要deque。

/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
        List<List<Integer>> result = new ArrayList<List<Integer>>();
        if(root == null) {
            return result;
        }
        Stack<TreeNode> stack = new Stack<TreeNode>();
        stack.push(root);
        int level = 1;
        while(stack.size() > 0) {
            int size = stack.size();
            Stack<TreeNode> nextLevelStack = new Stack<TreeNode>();
            List<Integer> thisLevel = new ArrayList<Integer>();
            while(size > 0) {
                TreeNode current = stack.pop();
                thisLevel.add(current.val);
                if(level % 2 == 1) {
                    if(current.left != null) {
                        nextLevelStack.push(current.left);
                    }
                    if(current.right != null) {
                        nextLevelStack.push(current.right);
                    }
                }
                if(level % 2 == 0) {
                    if(current.right != null) {
                        nextLevelStack.push(current.right);
                    }
                    if(current.left != null) {
                        nextLevelStack.push(current.left);
                    }
                }
                size--;
            }
            result.add(thisLevel);
            level++;
            stack = nextLevelStack;
        }
        return result;
    }
}

update 2015/05/18:

二刷，一个讨巧的解法，比上面容易理解多了。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
        List<List<Integer>> result = new ArrayList<List<Integer>>();
        if(root == null) {
            return result;
        }
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.offer(root);
        int level = 0;
        while(queue.size() > 0) {
            int levelSize = queue.size();
            List<Integer> levelList = new ArrayList<Integer>();
            while(levelSize > 0) {
                TreeNode node = queue.poll();
                if(level % 2 == 0) {
                    levelList.add(node.val);
                } else {
                    levelList.add(0, node.val);
                }
                levelSize--;
                if(node.left != null) {
                    queue.offer(node.left);
                }
                if(node.right != null) {
                    queue.offer(node.right);
                }
            }
            result.add(levelList);
            level++;
        }
        return result;
    }
}

 //20181003

用了一个双向链表Deque。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
        List<List<Integer>> res = new ArrayList<List<Integer>>();
        if (root == null) {
            return res;
        }        
        
        Queue<TreeNode> queue = new LinkedList<TreeNode>();        
        queue.offer(root);
        
        int level = 0;
        while (queue.size() > 0) {
            int levelSize = queue.size();
            Deque<Integer> cur = new LinkedList<Integer>();
            
            while (levelSize > 0) {
                TreeNode node = queue.poll();
                levelSize--;
                if (node == null) {
                    continue;
                }
                queue.offer(node.left);
                queue.offer(node.right);
                
                if (level % 2 == 0) {
                    cur.addLast(node.val);
                } else {
                    cur.addFirst(node.val);
                }                
            }
            if (cur.size() > 0) {
                res.add(new LinkedList<Integer>(cur));
            }            
            level++;
        }        
        return res;
    }
}