Binary Tree Zigzag Level Order Traversal

1，题目要求

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,null,null,15,7],

    3
   / \
  9  20
    /  \
   15   7

return its zigzag level order traversal as:

[
  [3],
  [20,9],
  [15,7]
]

给定二叉树，返回其节点值的Z字形级别遍历。 （即，从左到右，然后从右到左进行下一级别并在之间交替）。

2，题目思路

对于这道题，要求将一棵二叉树按照Z字形层次输出。

所谓的Z字形输出，也是按照层次进行遍历，只不过按照从左往右、从右往左、再从左往右的顺序进行遍历。

在实现上，我们发现，我们首先要确定当前的行是从左往右输出还是从从右往左输出的。因此这里我们可以设置一个bool变量，每输出一行，就进行一次反转。
另外，我们还需要确定每一行的数据是什么。这里，我们在利用队列实现层次遍历的基础上，每次在开始对当前队列遍历前， 获得队列中的元素的个数，这个个数就一定是当前层的节点的个数。

因此，在实现上，我们通过获得节点个数申请一个对应大小的容器，然后根据bool变量的情况，按照从左往右或者从右往左的顺序加入节点到容器。当当前容器都插入数据后，当前层就便利完成了，将其加入到res中，反转bool，开始下一层的遍历。

当然，还有一种跟简单的方法：经过观察之后我们发现，奇数层都是从左往右，偶数层都是从右往左，因此，我们只需要按照常规层次遍历的方法进行遍历，然后根据当前层的奇偶情况，判断是否使用reverse函数来反转。

3，代码实现

1，利用bool变量判断当前遍历方向

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */

int x = []() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    return 0;
}();

class Solution {
public:
    vector<vector<int>> zigzagLevelOrder(TreeNode* root) {
        if(root == nullptr)
            return {};
        
        vector<vector<int>> res;
        queue<TreeNode*> q;
        q.push(root);
        bool isLeft2Right = true;
        while(!q.empty()){
            int size = q.size();
            vector<int> tmp (size, 0);
            for(int i = 0;i<size;i++){
                int val = q.front()->val;
                if(isLeft2Right)
                    tmp[i] = val;
                else
                    tmp[size-1-i] = val;
                
                if(q.front()->left!=nullptr)
                    q.push(q.front()->left);
                if(q.front()->right!=nullptr)
                    q.push(q.front()->right);
                q.pop();
            }
            res.push_back(tmp);
            isLeft2Right = !isLeft2Right;
        }
        return res;
    }
};

2，利用层数奇偶、利用reverse函数

/**
 * 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) {
            if (!root) return {};
            vector<vector<int>> ret;
            queue<TreeNode*> q;
            q.push(root);
            int order = 1;
            while (!q.empty()) {
                int size = q.size();
                vector<int> level;
                for (int i = 0; i < size; ++i) {
                    TreeNode* curr = q.front();
                    level.push_back(curr -> val);
                    if (curr -> left) q.push(curr -> left);
                    if (curr -> right) q.push(curr -> right);
                    q.pop();
                }

                if (order % 2 == 0) {
                    reverse(level.begin(), level.end());
                }
                ret.push_back(level);
                order++;

            }
            return ret;
        }
};