leetcode

题目：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]
]

这道题类似Binary Tree Level Order Traversal，链接：http://www.cnblogs.com/laihaiteng/p/3797748.html，不同点在于相邻层次的遍历顺序不同，可以基于前面这道题的算法，增加一个层次号标记，把偶数层的遍历顺序逆序，再添加到vector中即可。我下面的思路稍稍有些不同，是利用栈和层次号来实现当场的zigzag遍历，而不是先正常的BFS，再依据层次号做改变。

个人思路：

1、逐层处理，每层的节点都放入队列A中，并记录层次号

2、当A队列出队时，将出队的节点值存储到相应层次的vector<int>中，并将该节点入栈B

3、当A队列为空时，表明该层的节点已经处理完毕，该处理下一层的节点了，将该层的vector<int>放入总的vector<vector<int> >，然后判断层次号是奇数还是偶数，由于通过栈B将上一层节点逆序了，可以很方便地进行zigzag遍历，按照栈的出栈顺序，奇数就先将出栈节点的左孩子入队，然后右孩子入队，偶数则顺序相反，直到栈为空，此时下一层节点已经按照zigzag的顺序入队列A了，重复2-3的步骤，直到节点全部遍历完

代码：

#include <stddef.h>
#include <stack>
#include <queue>
#include <vector>

using namespace std;

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> > total_result;
        vector<int> level_result;
        queue<TreeNode *> level_treeNode;
        stack<TreeNode *> level_treeNode_bak;

        if (!root)
        {
            return total_result;
        }

        int level_num = 1;
        level_treeNode.push(root);

        while (!level_treeNode.empty())
        {
            TreeNode *current = level_treeNode.front();
            level_treeNode.pop();
            level_treeNode_bak.push(current);
            level_result.push_back(current->val);

            //表明该层遍历完成
            if (level_treeNode.empty())
            {
                total_result.push_back(level_result);
                level_result.clear();
                ++level_num;

                if (level_num % 2)
                {
                    while (!level_treeNode_bak.empty())
                    {
                        current = level_treeNode_bak.top();
                        level_treeNode_bak.pop();
                        if (current->left)
                        {
                            level_treeNode.push(current->left);
                        }
                        if (current->right)
                        {
                            level_treeNode.push(current->right);
                        }
                    }
                }
                else
                {
                    while (!level_treeNode_bak.empty())
                    {
                        current = level_treeNode_bak.top();
                        level_treeNode_bak.pop();
                        if (current->right)
                        {
                            level_treeNode.push(current->right);
                        }
                        if (current->left)
                        {
                            level_treeNode.push(current->left);
                        }
                    }
                }
            }
        }

        return total_result;
    }
};

看了一下网上的几篇文章，思路差不多，都是基于BFS算法，然后按照层次号奇偶来进行遍历顺序的逆反