[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]
]

OJ's Binary Tree Serialization:

The serialization of a binary tree follows a level order traversal, where '#' signifies a path terminator where no node exists below.

Here's an example:

   1
  / 
 2   3
    /
   4
    
     5

The above binary tree is serialized as "{1,2,3,#,#,4,#,#,5}".

This problem cost me a lot of time, even though it seems like an easy binary tree traversal problem. my poor skills for handling complex abstract was laid bare(again) finding yourself is not so clever is always frustrated.
Anyway, I do came up this idea almost alone :) I believe if I keep pushing forward I can be better and better. and actually Im pretty enjoy this kinda shit.

This problem is very similar to level order traversal, but its zigzag manner makes it a little tricky. By using two stacks, one for left->right, one for right->left, and switch between as long as the current-selected stack is empty.
using a boolean value to determines the direction, and the direction determines which stack we have to pushed in.

pop from the current-selected stack as currentNode, push the value in the level array.(if current-selected stack is empty, terminate the function.)
if current turn is a "left" turn, then we push left then right child of currentNode in another stack.
if current turn is a "right" turn, then we push right then left child of currentNode in another stack.
then if current-selected stack is empty, reverse the current-direction, make current-selected statck to another stack, merge the level with final result, realloc a new level array, then starts over.

My AC version:

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> zigzagLevelOrder(TreeNode *root) {
        if (!root) return vector<vector<int>>();
        stack<TreeNode*> left;
        stack<TreeNode*> right;
        vector<stack<TreeNode*>> stacks;
        vector<vector<int>> result;
        int direction = 0;
        stacks.push_back(left);
        stacks.push_back(right);
        stacks[direction].push(root);
        
        stack<TreeNode*>* cs;
        vector<int> level;
        while ((cs = &stacks[direction]) && !cs->empty()){
            TreeNode* currentNode = cs->top();
            if (currentNode){
                level.push_back(currentNode->val);
            }
            cs->pop();
            stack<TreeNode*>* nextStack = &stacks[(direction+1)%2];
            if (!direction){
                //left
                if (currentNode->left)
                    nextStack->push(currentNode->left);
                if (currentNode->right)
                    nextStack->push(currentNode->right);
            }
            else{
                //right
                if (currentNode->right)
                    nextStack->push(currentNode->right);
                if (currentNode->left)
                    nextStack->push(currentNode->left);
            }
            if (cs->empty()){
                direction = (direction + 1)%2;
                result.push_back(level);
                level = vector<int>();
            }
        }
        return result;
    }
};