#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;
    }
};