对于一颗二叉树，先从左往右一层遍历完成之后，下一次从右往左遍历，返回遍历结果。

相较于普通 BFS ，这里我们使用双端队列，从左往右遍历的时候取出队列的头部，然后因为下一层要从右往左遍历，所以先把左儿子插入，再把右儿子插入。从右往左遍历的时候就从队列的尾部开始，取出尾部，插入头部，正好与第一次操作相反。

#include<vector>
#include<algorithm>
#include<deque>
using namespace std;

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */

struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

struct Node
{
    TreeNode * tree;
    int depth;
    Node(){}
    Node(TreeNode * a,int b)
    {
        tree=a;
        depth=b;
    }
};
vector<vector<int> > BFS(TreeNode *root)
{

    vector<vector<int> > res;
    if(root==NULL)
        return res;
    Node r(root,0);
    deque<Node> q;
    q.push_back(r);
    int dir=0;// 0 右 先放左孩子(pop_front,push_back) 1 左 先放右孩子(pop_back)
    int level=0;
    vector<int> aaa;
    res.push_back(aaa);
    while(!q.empty())
    {
        if(!dir)
        {
            Node n = q.front();
            q.pop_front();
            res[level].push_back(n.tree->val);
            if(n.tree->left!=NULL)
                q.push_back(Node(n.tree->left,n.depth+1));
            if(n.tree->right!=NULL)
                q.push_back(Node(n.tree->right,n.depth+1));
            if(!q.empty())
            {
                if(q.front().depth%2!=dir)
                {
                    vector<int> a;
                    res.push_back(a);
                    level++;
                    dir=!dir;
                }
            }
        }else
        {
            Node n = q.back();
            q.pop_back();
            res[level].push_back(n.tree->val);
            if(n.tree->right!=NULL)
                q.push_front(Node(n.tree->right,n.depth+1));
            if(n.tree->left!=NULL)
                q.push_front(Node(n.tree->left,n.depth+1));
            if(!q.empty())
            {
                if(q.back().depth%2!=dir)
                {
                    vector<int> a;
                    res.push_back(a);
                    level++;
                    dir=!dir;
                }
            }
        }
    }
}
class Solution {
public:
    vector<vector<int> > zigzagLevelOrder(TreeNode *root) {

        return BFS(root);
    }
};