按之字形顺序打印二叉树

剑指OFFER题49------按牛客网通过率排序

时间：2019.1.6.2215
作者：Waitt

题目

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

时间限制：1秒 空间限制：32768K 热度指数：127726

解答

解法1：

利用传统的层序遍历按行输出，用一个队列保存结点，再偶数层时将结果反转存入，时间复杂度较高，此处不作讨论。

解法2：

类似层序遍历按行输出的计数方式，利用双边队列(deque)进行存储：
奇数层：
在队列尾部添加元素，先队列头的左子树，后队列头的右子树。
在队列前部弹出元素。
偶数层：
在队列前部添加元素，先队列尾的右子树，后队列尾的左子树。
在队列尾部弹出元素。

/*
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> > a;//保存最终结果
        int c=1;//表示层数
        if(!pRoot)
            return a;
        deque<TreeNode*> q;//双边队列
        q.push_back(pRoot);
        while(q.size())
        {
            vector<int> b;
            int n=q.size();//上一层的结点数目。
            if(c%2!=0)//奇数层
            {
                for(int i=0;i<n;i++)//在队列尾部添加元素，先队列头的左子树，后队列头的右子树。
                {
                    if(q.front()->left)
                        q.push_back(q.front()->left);//在队列尾部添加元素，先队列头的左子树
                    if(q.front()->right)
                        q.push_back(q.front()->right);//在队列尾部添加元素，后队列头的右子树
                    b.push_back(q.front()->val);
                    q.pop_front();//在队列前部弹出元素。
                }
            }
            else
            {
                for(int i=0;i<n;i++)//在队列前部添加元素，先队列尾的右子树，再队列尾的左子树。
                {
                    if(q.back()->right)
                        q.push_front(q.back()->right);//在队列前部添加元素，先队列尾的右子树
                    if(q.back()->left)
                        q.push_front(q.back()->left);//在队列前部添加元素，后队列尾的左子树
                    b.push_back(q.back()->val);
                    q.pop_back();//在队列尾部弹出元素。
                }
            }
            c++;
            a.push_back(b);
        }
        return a;
    }    
};

解法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> > a;
        if(!pRoot)
            return a;
        stack<TreeNode*> q1,q2;//q1存奇数层，q2存偶数层
        q1.push(pRoot);
        int c=1;//层数
        while(q1.size()||q2.size())
        {
            vector<int> b;
            if(c%2!=0)//奇数层处理
            {
                while(q1.size())
                {
                    if(q1.top()->left)
                        q2.push(q1.top()->left);
                    if(q1.top()->right)
                        q2.push(q1.top()->right);
                    b.push_back(q1.top()->val);
                    q1.pop();
                }
            }
            else//偶数层处理
            {
                while(q2.size())
                {
                    if(q2.top()->right)
                        q1.push(q2.top()->right);
                    if(q2.top()->left)
                        q1.push(q2.top()->left);
                    b.push_back(q2.top()->val);
                    q2.pop();
                }
            }
            a.push_back(b);
            c++;//层数叠加
        }
        return a;
    }
    
};