描述

给定一个二叉树，返回该二叉树的之字形层序遍历，（第一层从左向右，下一层从右向左，一直这样交替）

数据范围：0 \le n \le 15000≤n≤1500,树上每个节点的val满足 |val| <= 1500∣val∣<=1500
要求：空间复杂度：O(n)O(n)，时间复杂度：O(n)O(n)
例如：
给定的二叉树是{1,2,3,#,#,4,5}

该二叉树之字形层序遍历的结果是
[
[1],
[3,2],
[4,5]
]

示例1

输入： 
{1,2,3,#,#,4,5}
复制
返回值： 
[[1],[3,2],[4,5]]
复制
说明： 
如题面解释，第一层是根节点，从左到右打印结果，第二层从右到左，第三层从左到右。

示例2

输入： 
{8,6,10,5,7,9,11}
复制
返回值： 
[[8],[10,6],[5,7,9,11]]
复制

示例3

输入： 
{1,2,3,4,5}
复制
返回值： 
[[1],[3,2],[4,5]]
解题思路：
该题是基于二叉树的层序遍历，记录每一层的层数，奇偶层数的左右子树入栈顺序相反。
两次for循环，第一次循环是将本层数据依次存入数组，第二次for循环是根据层数将下一层入栈，两次都有必要。 

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};
*/
class Solution {
public:
    vector<vector<int> > Print(TreeNode* pRoot) {
        vector<int> tmp;
        stack<TreeNode*> st;
        vector<vector<int> > res;
        vector<TreeNode*>tmpNode;
        int cnt = 0;
        if (pRoot == NULL) {
            return {};
        }
        st.push(pRoot);
        while (!st.empty()) {
            cnt++;
            int len = st.size();
            for (int i = 0; i < len; i++) {
                TreeNode* node = st.top();
                tmp.push_back(node->val);
                st.pop();
                tmpNode.push_back(node);
            }
            for (int i = 0; i < len; i++) {
                if (cnt % 2 == 1) {
                    if (tmpNode[i]->left != NULL)st.push(tmpNode[i]->left);
                    if (tmpNode[i]->right != NULL)st.push(tmpNode[i]->right);
                } else {
                    if (tmpNode[i]->right != NULL)st.push(tmpNode[i]->right);
                    if (tmpNode[i]->left != NULL)st.push(tmpNode[i]->left);
                }
            }
            tmpNode.clear();
            res.push_back(tmp);
            tmp.clear();
        }
        return res;
    }
    
};