Binary Tree Zigzag Level 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.

Analyse: The same as Binary Tree Level Order Traversal except that we need a boolean variable to determine whether the current level need reverse.

1. Recursion

Runtime: 4ms

/**
* Definition for a binary tree node.
* 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) {
vector<vector<int> >result;
zigzag(root, 0, true, result);
return result;
}
void zigzag(TreeNode* root, int level, bool l2r, vector<vector<int> >& result){
if(!root) return;
if(level == result.size()) result.push_back(vector<int> ());

if(l2r) result[level].push_back(root->val);
else result[level].insert(result[level].begin(), root->val);

zigzag(root->left, level + 1, !l2r, result);
zigzag(root->right, level + 1, !l2r, result);
}
};

2. Iteration

　 Runtime: 4ms.

/**
* Definition for a binary tree node.
* 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) {
vector<vector<int> >result;
if(!root) return result;
queue<TreeNode* > qu;
qu.push(root);
bool l2r = false;

while(!qu.empty()){
int n = qu.size();
l2r = !l2r;

vector<int> level;
while(n--){
TreeNode* temp = qu.front();
qu.pop();

if(l2r) level.push_back(temp->val);
else level.insert(level.begin(), temp->val); //if the boolean variable is not true, do reverse-sequence

if(temp->left) qu.push(temp->left);
if(temp->right) qu.push(temp->right);
}
result.push_back(level);
}
return result;
}
};