[牛客网-Leetcode] #树更难binary-tree-zigzag-level-order-traversal

Binary tree zigzag level traversal binary-tree-zigzag-level-order-traversal

Title description

Given a binary tree, return the zigzag level ordertraversal of its nodes’ values. (ie, from left to right, then right to left for the next level and alternate between).

For example:
Given binary tree{3,9,20,#,#,15,7},

return its zigzag level order traversal as:

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

Problem-solving ideas

• On the basis of level traversal, set level to record the current level number (starting from 1)
• Use cur array to save the number of nodes in each layer
  • If level is an odd layer, directly save cur into the result
  • If level is an even-numbered layer, first flip cur, and then store the result

/**
 * struct TreeNode {
 *	int val;
 *	struct TreeNode *left;
 *	struct TreeNode *right;
 * };
 */

class Solution {
    
    
public:
    vector<vector<int> > zigzagLevelOrder(TreeNode* root) {
    
    
        vector<vector<int> > res;
        if(root == NULL) return res;
        queue<TreeNode*> myque;
        myque.push(root);
        //奇数层从左往右，偶数层从右往左
        int level(1);   
        
        while(!myque.empty()) {
    
    
            int size = myque.size();  //每一层节点数
            vector<int> cur;   //保存当前层节点
            for(int i = 0; i < size; i ++) {
    
    
                TreeNode* temp = myque.front();
                myque.pop();
                cur.push_back(temp -> val);
                if(temp -> left) myque.push(temp -> left);
                if(temp -> right) myque.push(temp -> right);
            }
            //如果是偶数层，需要翻转cur数组
            if(!(level & 0x01)) {
    
    
                reverse(cur.begin(), cur.end());
            }
            level ++;   //层次加一
            res.push_back(cur);   //将当前层添加进结果
        }
        return res;
    }
};

---

• Improvement: instead of flipping, use the deque's entry and dequeue to make changes when operating on each layer, so as to achieve the purpose of flipping.
• The usage of deque deque:
  • dq.push_back(a): Insert element a at the end
  • dq.push_front(a): Insert element a in the head
  • dq.pop_back(): Pop-up tail element
  • dq.pop_front(): Pop-up header element
  • dq.front(): Take out the head element
  • dq.back(): Remove the tail element

/**
 * struct TreeNode {
 *	int val;
 *	struct TreeNode *left;
 *	struct TreeNode *right;
 * };
 */

class Solution {
    
    
public:
    vector<vector<int> > zigzagLevelOrder(TreeNode* root) {
    
    
        vector<vector<int> > res;
        if(root == NULL) return res;
        deque<TreeNode*> myque;
        myque.push_back(root);
        //奇数层从左往右，偶数层从右往左
        int level(1);   
        
        while(!myque.empty()) {
    
    
            int size = myque.size();  //每一层节点数
            vector<int> cur;   //保存当前层节点
            for(int i = 0; i < size; i ++) {
    
    
                //如果是奇数层，则按照常规层次遍历来
                if(level & 0x01) {
    
      
                    //前端弹出
                    TreeNode* temp = myque.front();
                    myque.pop_front();
                    cur.push_back(temp -> val);
                    //后端插入
                    if(temp -> left) myque.push_back(temp -> left);
                    if(temp -> right) myque.push_back(temp -> right);
                    
                } else {
    
       
                    //如果是偶数层，则利用deque的特性实现翻转的目的，从后往前遍历
                    //后端弹出
                    TreeNode* temp = myque.back();
                    myque.pop_back();
                    cur.push_back(temp -> val);
                    //前端插入
                    if(temp -> right) myque.push_front(temp -> right);
                    if(temp -> left) myque.push_front(temp -> left);
                }
            }
            level ++;   //层次加一
            res.push_back(cur);   //将当前层添加进结果
        }
        return res;
    }
};