LeetCode OJ:Binary Tree Zigzag Level Order Traversal

Binary Tree Zigzag Level Order Traversal

 

Given a binary tree, return the zigzag level order traversal 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},

    3
   / \
  9  20
    /  \
   15   7

return its zigzag level order traversal as:

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

confused what "{1,#,2,3}" means? > read more on how binary tree is serialized on OJ.

算法思想：

按照层序遍历思想，根据访问到奇偶数层处理先后问题

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<vector<int> > zigzagLevelOrder(TreeNode *root) {
        vector<vector<int>> result;  
        if(!root)return result;  
        list<list<int>> r;  
        list<int> t;  
        int fang=0;
        int curLev=1;  
        int nextLev=0;  
        queue<TreeNode *> que;  
        que.push(root);  
        while(!que.empty()){  
            TreeNode *cur=que.front();  
            que.pop();  
            if(!fang)
                t.push_back(cur->val);
            else t.push_front(cur->val);
            if(cur->left){  
                nextLev++;  
                que.push(cur->left);  
            }  
            if(cur->right){  
                nextLev++;  
                que.push(cur->right);  
            }  
            if(--curLev==0){  
                r.push_back(t);  
                t.clear();  
                curLev=nextLev;  
                nextLev=0;  
                fang^=1;
            }  
        }  
        for(auto &v:r){  
            vector<int> k;  
            for(int i:v){  
                k.push_back(i);  
            }  
            result.push_back(k);  
        }  
        return result;  
    }
};

递归版

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<vector<int> > zigzagLevelOrder(TreeNode *root) {
        vector<vector<int>> result;
        traverse(root,1,result,true);
        return result;
    }
    void traverse(TreeNode *root,size_t level,vector<vector<int>> &result,bool left_to_right){
        if(!root)return;
        
        if(level>result.size())
            result.push_back(vector<int>());
        
        if(left_to_right)
            result[level-1].push_back(root->val);
        else
            result[level-1].insert(result[level-1].begin(),root->val);
            
        traverse(root->left,level+1,result,!left_to_right);
        traverse(root->right,level+1,result,!left_to_right);
    }
};