【leetcode】103 二叉树的锯齿形层次遍历（二叉树，栈）

题目链接：https://leetcode-cn.com/problems/binary-tree-zigzag-level-order-traversal/

题目描述

给定一个二叉树，返回其节点值的锯齿形层次遍历。（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。

例如：
给定二叉树 [3,9,20,null,null,15,7],

   3
   / \
  9  20
    /  \
   15   7

返回锯齿形层次遍历如下：

[
  [3],
  [20,9],
  [15,7]
]

思路

1 层序遍历+翻转

同层序遍历，注意需要设置变量用来表明当前打印方向

class Solution {
public:
    vector<vector<int>> zigzagLevelOrder(TreeNode* root) {
        vector<vector<int>> ret;
        if(!root) return ret;
        queue<TreeNode *> q;
        q.push(root);
        int currentLayerNodes = 1;  // 当前层待打印节点数
        int nextLayerNodes = 0;     // 下一层待打印节点数
        bool printLeft = true;      // 当前层打印方向
        while (!q.empty()){
            int cnt = 0;            // 当前层已打印节点数
            nextLayerNodes = 0;
            vector<int> currentLayer;
            while(cnt < currentLayerNodes){
                TreeNode *node = q.front();
                q.pop();
                currentLayer.push_back(node->val);
                cnt ++;
                if(node->left) {
                    q.push(node->left);
                    nextLayerNodes++;
                }
                if(node->right) {
                    q.push(node->right);
                    nextLayerNodes++;
                }
            }
            if(!printLeft) 
                reverse(currentLayer.begin(),currentLayer.end());
            ret.push_back(currentLayer);
            printLeft = !printLeft; // 翻转打印方向
            currentLayerNodes = nextLayerNodes;
        }
        return ret;
    }
};

2 层序遍历+双栈不翻转

看到翻转的要求，我们应该想到可以用栈来实现！并且由于是锯齿形，即不断的翻转，我们可以考虑用两个栈来模拟这个过程！
（1）设置两个栈分别存储奇数层和偶数层节点
（2）将一个栈依次弹出的同时，将弹出元素的子节点分别入栈（这里要注意偶数层元素的子节点在入栈的时候需要先右子节点入栈，再左子节点入栈，才不会发生错位的情况）

class Solution {
public:
    vector<vector<int>> zigzagLevelOrder(TreeNode* root) {
        vector<vector<int>> ret;
        if(!root) return ret;
        stack<TreeNode*> s1;    // 奇数层栈 从左往右
        stack<TreeNode*> s2;    // 偶数层栈 从右往左
        s2.push(root);
        while (!s1.empty() || !s2.empty()){
            vector<int> tmp;
            while (!s2.empty()){
                TreeNode* node = s2.top();
                tmp.push_back(node->val);
                s2.pop();
                if(node->left)
                    s1.push(node->left);
                if(node->right)
                    s1.push(node->right);
            }
            if(!tmp.empty()) ret.push_back(tmp);
            tmp.clear();
            while (!s1.empty()){
                TreeNode* node = s1.top();
                tmp.push_back(node->val);
                s1.pop();
                if(node->right)             // 注意需要先入栈右节点，再入栈左节点
                    s2.push(node->right);   // 这样下一轮才满足所有节点从左往右顺序，否则会交错
                if(node->left)
                    s2.push(node->left);
            }
            if(!tmp.empty()) ret.push_back(tmp);
        }
        return ret;
    }
};