JZ77按之字形顺序打印二叉树

 题目来源：按之字形顺序打印二叉树_牛客题霸_牛客网

描述

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

数据范围：0 \le n \le 15000≤n≤1500,树上每个节点的val满足 |val| <= 100∣val∣<=100
要求：空间复杂度：O(n)O(n)，时间复杂度：O(n)O(n)

例如：
给定的二叉树是{1,2,3,#,#,4,5}

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

 我的代码：

 思路：既然是一行从左向右，一行从右向左，简单粗暴，设置一个tag，标记现在处于哪一行。

tag%2==0时（我是从0开始，0处于第一层，即奇数层)，正向，直接压入vector当中。

tag%2==1时，从右向左，借助stack来将序列反过来，再压入vector中。

本题主要借助层序遍历的结构，这是十分明晰的，因为我们要一层一层的压入vector中。

/*
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>> re;
        stack<int> st;
        int tag=0;//标记是第几层节点
        if(!pRoot) return re;
        queue<TreeNode*> q;
        q.push(pRoot);
        while(!q.empty()){
            vector<int> cur1;
            int sz=q.size();
            while(sz--){
                auto node = q.front();//当前队列中的值，即树中某个level的值
                q.pop();
                if(node->left) q.push(node->left);
                if(node->right) q.push(node->right);
                if(tag%2==1){//当是偶数层，要反向输出
                    st.push(node->val);
                }else{//当是奇数层，直接正向输出
                    cur1.push_back(node->val);
                }
            }
            if(tag%2==1){
                int si_st = st.size();
                while(si_st--){//将堆栈中的元素压入vector中。
                    cur1.push_back(st.top());
                    st.pop();
                }
            }
            re.push_back(cur1);//将本层的节点压入
            tag++;
        }
        return re;
    }
    
};

 

 题解：

题解的思路和我的思路差不多，最终的效率也差不多。

都是借助层序遍历和vector，但是题解没有用stack，而是在偶数层直接用reverse()反转。

/*
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>> ret;
        if (!pRoot) return ret;
        queue<TreeNode*> q;
        q.push(pRoot);
        int level = 0;
 
        while (!q.empty()) {
            int sz = q.size();
            vector<int> ans;
            while (sz--) {
                TreeNode *node = q.front();
                q.pop();
                ans.push_back(node->val);
 
                if (node->left) q.push(node->left);
                if (node->right) q.push(node->right);
            }
            ++level;
            if (!(level%2==1)) // 偶数层 反转一下
                reverse(ans.begin(), ans.end());
            ret.push_back(ans);
        }
        return ret;
    }
};