Leetcode_binary-tree-zigzag-level-order-traversal (updated c++ and python version)

地址：http://oj.leetcode.com/problems/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.

思路：

跟上一题很像，基本数据结构模拟题。之字形层次遍历，那么设置一个游标bool量flag，对存入vector的值隔一次翻转一次。

请对比和上一题代码异同: http://blog.csdn.net/flyupliu/article/details/21483317

参考代码：

/** * 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> >res;        bool flag = true;        if(!root)        {            return res;        }        else        {            queue<TreeNode*>q;            q.push(root);            while(!q.empty())            {                int size = q.size();                vector<int> vec;                while(vec.size() < size)                {                    TreeNode* root = q.front();                    q.pop();                    vec.push_back(root->val);                    if(root->left)                    {                        q.push(root->left);                    }                    if(root->right)                    {                        q.push(root->right);                    }                }                flag = !flag;                if(flag)                {                    reverse(vec.begin(), vec.end());                }                res.push_back(vec);            }        }        return res;    }};

//SECOND TRAIL
class Solution {
public:
    vector<vector<int> > zigzagLevelOrder(TreeNode *root) {
        vector<vector<int> >ans;
        if(!root)
            return ans;
        queue<TreeNode*>treeq;
        treeq.push(root);
        TreeNode* cur = NULL;
        bool flag = true;
        while(!treeq.empty())
        {
            int sz = (int)treeq.size();
            vector<int>vec;
            while(sz--)
            {
                cur = treeq.front();
                treeq.pop();
                vec.push_back(cur->val);
                if(cur->left)
                    treeq.push(cur->left);
                if(cur->right)
                    treeq.push(cur->right);
            }
            if(!flag)
                reverse(vec.begin(), vec.end());
                
            ans.push_back(vec);
            flag = !flag;
        }
        return ans;
    }
};

python :

# Definition for a  binary tree node
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    # @param root, a tree node
    # @return a list of lists of integers
    def zigzagLevelOrder(self, root):
        if not root:
            return [];
        ans = []
        q = [root]
        flag = True
        while q:
            sz = len(q)
            level = []
            while sz:
                sz -= 1
                cur = q.pop()
                if cur.left:
                    q.insert(0, cur.left)
                if cur.right:
                    q.insert(0, cur.right)
                level.append(cur.val)
            if flag:
                ans.append(level)
            else:
                ans.append(level[::-1])
            flag = not flag
        return ans