二叉树层次遍历（包含之字形遍历也有称之为锯齿遍历）

树的遍历是一个基础问题，也有很多的实际应用，可以用来找到匹配的字符串、文本分词和文件路径等问题。
数的遍历有两个基本的方法：深度优先遍历 和 广度优先遍历 。
这里的层次遍历就是广度优先遍历

方法一：最简单的
借用一个queue，虽然可以实现层次遍历，但不知道是哪一层次

struct TreeNode {
      int val;
      struct TreeNode *left;
      struct TreeNode *right;
      TreeNode(int x) :
      val(x), left(NULL), right(NULL) {
      }
};
void LevelOrder(TreeNode *root){
      queue node;
      TreeNode *proot;
      node.push(root);
      vector<int> res;
      while(node.size()!=0){
                 proot=node.front();
                 node.pop();
                 res.push_back(proot->val);
                 if(proot->left) node.push(proot->left);
                 if(proot->right) node.push(proot->right);
      }
}

方法二：使用queue的长度来做分隔

struct TreeNode {
      int val;
      struct TreeNode *left;
      struct TreeNode *right;
      TreeNode(int x) :
      val(x), left(NULL), right(NULL) {
      }
};
void LevelOrder(TreeNode * root){
      queue node;
      node.push(root);
      vector<int> res;
      while(node.size()!=0){
            int len=node.size();
            TreeNode* proot;
            while (len>0)
            {
                 proot=node.front();
                 node.pop();
                 res.push_back(proot->val);
                 if(proot->left) node.push(proot->left);
                 if(proot->right) node.push(proot->right);
                 len--;
            }
      }
}

方法三：之字形广度遍历
前两种都是顺序的，那么如何来实现呢？
这里使用了deque，1、从back一个个读后弹出一层同时下一行的节点从头部一个个push回去2、从front一个个读后弹出一整层同时下一行的节点从尾部push回去
1，2不停地循环直到遍历所有节点

struct TreeNode {
      int val;
      struct TreeNode *left;
      struct TreeNode *right;
      TreeNode(int x) :
      val(x), left(NULL), right(NULL) {
      }
};
void LevelOrder(TreeNode * root){
      deque  node;
      node.push_back(s);
      vector<int> res;
      int level=1;
      while(node.size()!=0){
            int len=node.size();
            TreeNode* proot;
            while (len>0)
            {
                 if (level%2==1)
                 {
                       proot=node.front();
                       node.pop_front();
                       res.push_back(proot->val);
                       if(proot->left) node.push_back(proot->left);
                       if(proot->right) node.push_back(proot->right);
                       len--;
                 }else if (level%2==0){
                       proot=node.back();
                       node.pop_back();
                       res.push_back(proot->val);
                       if(proot->right) node.push_front(proot->right);
                       if(proot->left) node.push_front(proot->left);
                       len--;
                 }
            }
            level++;
      }
}