按之字形顺序打印二叉树

题目描述

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

分析1：利用栈的“先进后出”，使用两个栈分别存储奇数层和偶数层的节点值

/*
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>> vvi;
        vector<int> vi;
        if(!pRoot) return {};
        stack<TreeNode*> p1,p2;   //分别用两个不同的栈存储奇数和偶数层的结点
        p1.push(pRoot);
        int level=0;      //二叉树的深度记录变量
        while(!p1.empty()||!p2.empty())  //直到所有节点都出栈，跳出循环
            {
              ++level;
              if(level%2==1) 
                {
                 while(!p1.empty())
                  {
                    int len=p1.size();
                    while(len--)
                      {
                        TreeNode* tem=p1.top();  //用一个变量记录栈顶节点，即每一层中的结点
                        p1.pop();                  //删除节点
                        vi.push_back(tem->val);   //将每一层节点的int数值存入vi
                        //当层数为奇数时，先左孩子后右孩子；
                        if(tem->left) p2.push(tem->left);   //将下一层的结点存储在另一个栈里
                        if(tem->right) p2.push(tem->right);   
                       }//如果存储在同一个栈里，当一层中的结点大于一个时，这一层的结点还没有完全取出来时，就会存储下一层的结点，
                     //  导致取出的栈顶元素有一部分是下一层的元素
                 }
              }
            else{
                while(!p2.empty())
                    {
                    int len=p2.size();
                    while(len--)
                        {
                        TreeNode* tem=p2.top();  //用一个变量记录栈顶节点，即每一层中的结点
                        p2.pop();                  //删除节点
                        vi.push_back(tem->val);   //将每一层节点的int数值存入vi
                        //当层数为偶数时，先右孩子后左孩子；
                        if(tem->right) p1.push(tem->right);
                        if(tem->left) p1.push(tem->left);
                    }
                }
            }
            vvi.push_back(vi);
            vi.clear();
        }
        return vvi;
    }
};

分析二：也可以将二叉树按层遍历后，将偶数层的序列颠倒输出

class Solution {
public:
    vector<vector<int> > Print(TreeNode* pRoot) {
        vector<vector<int>> res;
        if(pRoot == NULL)
            return res;
        queue<TreeNode*> que;
        que.push(pRoot);
        bool even = false;
        while(!que.empty()){
            vector<int> vec;
            const int size = que.size();
            for(int i=0; i<size; ++i){
                TreeNode* tmp = que.front();
                que.pop();
                vec.push_back(tmp->val);
                if(tmp->left != NULL)
                    que.push(tmp->left);
                if(tmp->right != NULL)
                    que.push(tmp->right);
            }
            if(even)
                std::reverse(vec.begin(), vec.end());
            res.push_back(vec);
            even = !even;
        }
        return res;
    }
     
};