#71 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).

Have you met this question in a real interview? 

Yes

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

题目思路：

这题我是先用两个queue去做BFS，把tree中的nodes都放到矩阵相应的位置上。然后，对奇数行做一个reverse。

Mycode（AC = 14ms）：

/**
 * Definition of TreeNode:
 * class TreeNode {
 * public:
 *     int val;
 *     TreeNode *left, *right;
 *     TreeNode(int val) {
 *         this->val = val;
 *         this->left = this->right = NULL;
 *     }
 * }
 */
 

class Solution {
    /**
     * @param root: The root of binary tree.
     * @return: A list of lists of integer include 
     *          the zigzag level order traversal of its nodes' values 
     */
public:
    vector<vector<int>> zigzagLevelOrder(TreeNode *root) {
        // write your code here
        vector<vector<int>> ans;
        if (root == NULL) return ans;
        
        // initialize 2 queues, one to 
        // store tree nodes, one to store
        // level/height of corresponding node
        queue<TreeNode *> helper;
        helper.push(root);
        queue<int> levels;
        levels.push(0);
        
        while (!helper.empty()) {
            TreeNode *node = helper.front();
            helper.pop();
            
            int level = levels.front();
            levels.pop();
            
            // push the node into ans, according
            // to its level
            if (ans.size() <= level) {
                ans.push_back({node->val});
            }
            else {
                ans[level].push_back(node->val);
            }
            
            // push the left/right tree and their
            // corresponding level into queue
            if (node->left) {
                helper.push(node->left);
                levels.push(level + 1);
            }
            if (node->right) {
                helper.push(node->right);
                levels.push(level + 1);
            }
        }
        
        // reverse the odd rows
        for (int i = 1; i < ans.size(); i += 2) {
            reverse(ans[i].begin(), ans[i].end());
        }
        
        return ans;
    }
};