按之字形顺序打印二叉树

题目描述
请实现一个函数按照之字形打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右至左的顺序打印，第三行按照从左到右的顺序打印，其他行以此类推。

解法一：
 使用两个双端队列容器，一个当队列用（从左到右打印），一个当栈用（从右到左打印）。
 大致思路如下：

• 定义两个双端队列的数据结构 deq_1, deq_2，相互初始化。
• deq_1 中的元素的左右子树，按顺序进入 deq_2，然后 deq_1 中的元素再按顺序出队列
• deq_2 中的元素的左右子树，按顺序进入 deq_1，然后 deq_2 中的元素再按顺序出队列
• 重复上述2,3步，直到两个队列都为空为止。

/*
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<vector<int>> vec;
        
        if (!pRoot)
            return vec;
        
        deque<TreeNode*> deq1, deq2;
        int flag = 1;
        int length;
        
        deq1.push_back(pRoot);
        
        while (!deq1.empty() || !deq2.empty())
        {
            if (flag == 1)
            {
                flag = -1;
                vector<int> v;
                //填充deq2
                filling_deque(deq1, deq2);
                //出列，列空
                while (!deq1.empty())
                {
                    v.push_back(deq1[0]->val);
                    deq1.pop_front();
                }
                vec.push_back(v);
            }
            else
            {
                flag = 1;
                vector<int> v;
                filling_deque(deq2, deq1);
                //出栈，栈空
                int length = deq2.size();
                for (int i = length - 1; i >= 0; i--)
                {
                    v.push_back(deq2[i]->val);
                    deq2.pop_back();
                }
                    
                vec.push_back(v);
            }
        }
        return vec;
    }
private:
    //传进去的deq_not_null不为空，deq_null为空
    void filling_deque(const deque<TreeNode*>& deq_not_null, deque<TreeNode*>& deq_null)
    {
        int length = deq_not_null.size();
        
        for (int i = 0; i < length; i++)
        {
            if (deq_not_null[i]->left)
                deq_null.push_back(deq_not_null[i]->left);
            if (deq_not_null[i]->right)
                deq_null.push_back(deq_not_null[i]->right);
        }
    }
};

解法二：
 使用两个栈来做，思路大同小异。只不过解法二是边出栈边填充另一个栈，而解法一是先顺序访问填充另一个栈之后，再出按规则弹出元素。相比来看，可能解法二更简洁一点。

/*
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<vector<int>> vec;
        if(pRoot==NULL)
           return vec;
        
        stack<TreeNode*> s1;
        stack<TreeNode*> s2;
        s1.push(pRoot);
        int flag = 1;
        
        while(!s1.empty()||!s2.empty()){
            if(flag == 1){
                flag = 0;
                vector<int> v1;
                while(!s1.empty()){
                    TreeNode* t=s1.top();
                    v1.push_back(t->val);
                    s1.pop();
                    if(t->left!=NULL)
                        s2.push(t->left);
                    if(t->right!=NULL)
                        s2.push(t->right);
                }
                vec.push_back(v1);
            }
            else{
                flag = 1;
                vector<int> v2;
                while(!s2.empty()){
                    TreeNode* t=s2.top();
                    v2.push_back(t->val);
                    s2.pop();
                    if(t->right!=NULL)
                        s1.push(t->right);
                    if(t->left!=NULL)
                        s1.push(t->left);
                }
                vec.push_back(v2);
            }
        }
       return vec;
    }
};