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

 1 /**
 2 
 3 Definition of TreeNode:
 4 public class TreeNode {
 5 public int val;
 6 public TreeNode left, right;
 7 public TreeNode(int val) {
 8 this.val = val;
 9 this.left = this.right = null;
10 }
11 }*/
12 public class Solution {
13 
14 /**
15  * @param root: The root of binary tree.
16  * @return: A list of lists of integer include 
17  *          the zigzag level order traversal of its nodes‘ values 
18  */
19 public ArrayList<ArrayList<Integer>> zigzagLevelOrder(TreeNode root) {
20     // write your code here
21      ArrayList <ArrayList<Integer>> result = new ArrayList();
22 
23     if (root == null) {
24         return result;
25     }
26     Queue<TreeNode> queue = new LinkedList<TreeNode>(); queue.offer(root);
27     int count = 0;
28     while(!queue.isEmpty()){
29     
30        int size = queue.size();
31        ArrayList<Integer> level = new ArrayList<Integer>();
32        
33        for(int i=0; i<size; i++){
34            
35            TreeNode head = queue.poll();
36            level.add(head.val);
37            if(head.left!=null) queue.offer(head.left);
38            if(head.right!=null) queue.offer(head.right);
39        }
40        if(count%2 == 1) Collections.reverse(level);
41        count++;
42        result.add(level);
43     }
44     return result;
45 }
46 }

 1 /**
 2 
 3 Definition of TreeNode:
 4 class TreeNode {
 5 public:
 6 int val;
 7 TreeNode left, right;
 8 TreeNode(int val) {
 9 this->val = val;
10 this->left = this->right = NULL;
11 }
12 }*/
13 class Solution {
14 
15 /**
16  * @param root: The root of binary tree.
17  * @return: A list of lists of integer include 
18  *          the zigzag level order traversal of its nodes‘ values 
19  */
20 public:
21 
22 vector<vector<int>> zigzagLevelOrder(TreeNode *root) {
23     // write your code here
24     vector<vector<int>> res;
25     if(!root) return res;
26     
27     stack<TreeNode*> s1;
28     stack<TreeNode*> s2;
29     
30     s1.push(root);
31     vector<int> level;
32     
33     while(!s1.empty() || !s2.empty()){
34         while(!s1.empty()){
35             TreeNode *cur = s1.top();
36             s1.pop();
37             level.push_back(cur->val);
38             if(cur->left) s2.push(cur->left);
39             if(cur->right) s2.push(cur->right);
40         }
41         if(!level.empty()) 
42         res.push_back(level);
43         level.clear();
44         while(!s2.empty()){
45             TreeNode *cur = s2.top();
46             s2.pop();
47             level.push_back(cur->val);
48             if(cur->right) s1.push(cur->right);
49             if(cur->left) s1.push(cur->left);
50         }
51         if(!level.empty())
52         res.push_back(level);
53         level.clear();
54     }
55     return res;
56 }
57 };