Leetcode 103. Binary Tree Zigzag Level Order Traversal 双端队列使用，以及一些巧妙技巧 还有更简单方法

• 双端队列，两头都能访问的队列。在连续使用的情况下，能实现一组“数组”取逆序，另一组“数组”取正序的效果。
• 用队列进行层级遍历，巧用size可以划分层级
  • 每完成一个层级的遍历，该层的size也相应固定住，这是可以用一个变量存取，用一个for循环即可遍历该层全部的元素

联想： 双向链表 ： LRU

双端队列+栈

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> zigzagLevelOrder(TreeNode* root) {
        if(!root) return {};
        deque<TreeNode*> dq;
        vector<vector<int>> res;
        bool flag = true;
        dq.push_back(root);
        while(!dq.empty()){
            TreeNode *node;
            vector<int> tmp;
            int len = dq.size(); //获取树每一层的元素
            for(int i=0; i<len; i++){
                if(flag){
                    node = dq.front();
                    dq.pop_front();
                    tmp.push_back(node->val);
                    if(node->left) dq.push_back(node->left);
                    if(node->right) dq.push_back(node->right);
                }else{ //从队列中反着取出，使得存进vec时是反的，放到队列后，再反着拿 "反反得正"，又变会了正的
                    node = dq.back();
                    dq.pop_back();
                    tmp.push_back(node->val);
                    if(node->right) dq.push_front(node->right); //取逆序操作也要求子树调换位置
                    if(node->left) dq.push_front(node->left);
                }
            }
            flag = !flag; //不能用flag=-flag
            res.push_back(tmp);
        }
        return res;
    }
};

队列+栈

中间存在偶数层，栈赋值给vector的过程，所以时间复杂度高(O(Nk))

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> zigzagLevelOrder(TreeNode* root) {
        if(root == NULL) return {};
        queue<pair<TreeNode*,int>> q;
        vector<vector<int>> vec;
        stack<int> stk;
        q.push({root,0});
        while(q.empty()==false){
            TreeNode* tmpNode = q.front().first;
            //cout<<tmpNode->val<<endl;
            int level = q.front().second;
            q.pop();
            if(level == vec.size()) {
                if((level&1)==0 && level>0)
                    while(stk.empty()==false){
                        vec[level-1].push_back(stk.top());
                        stk.pop();
                    }
                vec.push_back({});
            }
            if(level&1){
                stk.push(tmpNode->val);
            }
            else{
                vec[level].push_back(tmpNode->val);
            }
            if(tmpNode->left) q.push({tmpNode->left, level+1});
            if(tmpNode->right) q.push({tmpNode->right, level+1});
        }
        if(stk.empty()==false){
            while(!stk.empty()){
                vec[vec.size()-1].push_back(stk.top());
                stk.pop();
            }
        }
        return vec;
    }
};

dfs

最终得到正常层序遍历结果后，隔一行调整顺序即可。代码简单易懂，速度也不满

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> zigzagLevelOrder(TreeNode* root) {
        dfs(root, 0);
        for(int i=0; i<res.size(); i++){
            if(i&1==1) {
                reverse(res[i].begin(), res[i].end());
            }
        }
        return res;
    }
private:
    vector<vector<int>> res;
    void dfs(TreeNode* root, int level){
        if(root==NULL) return ;
        if(level==res.size()) res.push_back({});
        res[level].push_back(root->val);
        dfs(root->left, level+1);
        dfs(root->right, level+1);
    }
};

BFS

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> zigzagLevelOrder(TreeNode* root) {
        if(root == NULL) return {};
        queue<TreeNode*> q;
        q.push(root);
        int  index = -1;
        vector<vector<int>> res;
        while(q.size() != 0){
            index ++;
            vector<int> tmp;
            int len = q.size();
            for(int i = 0; i < len; i ++){
                auto t = q.front();
                q.pop();
                tmp.push_back(t -> val);
                if(t -> left) q.push(t -> left);
                if(t -> right) q.push(t -> right);
            }
            if(index % 2 != 0)
                reverse(tmp.begin(), tmp.end());
            res.push_back(tmp);
        }
        return res;
    }
};