按之字形顺序打印二叉树：最直观的想法是，使用res存储结果，使用temp存储临时结果，使用que存储队列，如果根节点为空直接返回空，反之将根节点加入队列中。当队列不为空时，记录当前队列长度len，其为每一层的元素个数，在循环前清空temp数组，接着循环len次，在循环体中执行弹出队头元素、将队头元素加入temp中、加入队头元素的非空左右孩子到que中，循环结束后将temp数组加入res中。最后当队列为空时表明遍历结束，此时对奇数下标数组进行反转处理即可得到最后的结果数组。

vector<vector<int> > Print(TreeNode* pRoot) {
        vector<vector<int>> res;
        if(!pRoot)
            return res;
        queue<TreeNode*> que;
        vector<int> temp;
        que.push(pRoot);
        while(!que.empty())
        {
            // 注意如果直接在for循环写que.size其是变化的
            int len=que.size();
            temp.clear();
            // 每一层有que.size个元素
            for(int i=0;i<len;i++)
            {
                TreeNode * cur=que.front();
                temp.push_back(cur->val);
                que.pop();
                if(cur->left)
                    que.push(cur->left);
                if(cur->right)
                    que.push(cur->right);
            }
            res.push_back(temp);
        }
        // 处理奇数下标数组
        for(int i=0;i<res.size();i++)
            if(i%2!=0)
                reverse(res[i].begin(),res[i].end());
        return res;
    }

优化：上述方法中，我们是先按照层序遍历加入到数组，再对奇数下标数组单独处理的，但是实际上我们可以在加入的时候就进行单独处理。相比于上述方法，我们可以新增一个level变量表示层数，其中根节点在第0层。唯一的改变是，当在循环中弹出元素后，如果是在偶数层则加入到数组尾部，反之如果是在奇数层则加入到数组头部，循环结束后再将level加一。这样就不需要最后单独处理奇数。即元素还是顺序加入队列的，只不过是逆序加入数组的，当为奇数下标数组时。

vector<vector<int> > Print(TreeNode* pRoot) {
        vector<vector<int>> res;
        if(!pRoot)
            return res;
        queue<TreeNode*> que;
        vector<int> temp;
        que.push(pRoot);
        int level=0;
        while(!que.empty())
        {
            // 注意如果直接在for循环写que.size其是变化的
            int len=que.size();
            temp.clear();
            // 每一层有que.size个元素
            for(int i=0;i<len;i++)
            {
                TreeNode * cur=que.front();
                if(level%2!=0)
                    temp.insert(temp.begin(),cur->val);
                else
                    temp.push_back(cur->val);
                que.pop();
                if(cur->left)
                    que.push(cur->left);
                if(cur->right)
                    que.push(cur->right);
            }
            res.push_back(temp);
            level++;
        }
        return res;
    }

idea：遇到逆序想到什么？第一种方法中我们想到了反转！实现反转可以使用什么？栈结构！栈是先进后出！！此题中是奇偶数顺序不同，于是我们想到对奇偶数单独处理！双栈！一个栈s1存储奇数行，一个栈s2存储偶数行。当有一个栈不为空时则执行循环，首先遍历奇数层，其是先左后右，接着是偶数层，其是先右后左。首先奇数行先左后右加入到偶数层，则出来顺序即为先右后左即逆序，同时偶数行是先右后左加入到奇数层，则出来顺序即为先左后右即正序。如果不熟悉的话可以举一个例子来模拟一遍喔！

vector<vector<int> > Print(TreeNode* pRoot) 
{
    vector<vector<int>> res;
    if(!pRoot)
       return res;
    // 存奇数层 下标从1开始 1、3、5... 根节点为第一层
    stack<TreeNode*> s1;
    // 存偶数层
    stack<TreeNode*> s2;
    vector<int> temp;
    s1.push(pRoot);
    // 当s1或者s2有一者不为空则执行循环
    while(!s1.empty() || !s2.empty())
    {
        // 使用前清空
        temp.clear();
        // 遍历奇数层
        while(!s1.empty())
        {
           TreeNode *cur=s1.top();
           s1.pop();
           temp.push_back(cur->val);
           // 先左
           if(cur->left)
               s2.push(cur->left);
           // 后右
           if(cur->right)
               s2.push(cur->right);
        }
        // 不为空收录
        if(temp.size())
             res.push_back(temp);
        // 使用前清空
        temp.clear();
        // 遍历偶数层
        while(!s2.empty())
        {
            TreeNode *cur=s2.top();
            s2.pop();
            temp.push_back(cur->val);
            // 先右
            if(cur->right)
               s1.push(cur->right);
            // 后左
            if(cur->left)
               s1.push(cur->left);
        }
        // 不为空收录
        if(temp.size())
          res.push_back(temp);
    }
    return res;
}