Leetcode: 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]
]

Similar to Leetcode: Binary Tree Level Order Traversal, but use two stacks to realize zigzag level order traversal. One stack to store nodes at current level, the other to store nodes at the next level. Use a boolean parameter to determine the traverse direction.

/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public ArrayList<ArrayList<Integer>> zigzagLevelOrder(TreeNode root) {
        ArrayList<ArrayList<Integer>> res = new ArrayList<ArrayList<Integer>>();
        if (root == null) {
            return res;
        }
        
        Stack<TreeNode> stack = new Stack<TreeNode>();
        stack.push(root);
        boolean isLeftToRight = false;
        while (!stack.empty()) {
            ArrayList<Integer> level = new ArrayList<Integer>();
            Stack<TreeNode> next = new Stack<TreeNode>();
            int size = stack.size();
            for (int i = 0; i < size; i++) {
                TreeNode node = stack.pop();
                level.add(node.val);
                if (isLeftToRight) {
                    if (node.right != null) {
                        next.push(node.right);
                    }
                    if (node.left != null) {
                        next.push(node.left);
                    }
                } else {
                    if (node.left != null) {
                        next.push(node.left);
                    }
                    if (node.right != null) {
                        next.push(node.right);
                    }
                }
            }
            isLeftToRight = !isLeftToRight;
            res.add(level);
            stack = next;
        }
        
        return res;
    }
}