树种结点的输入顺序：层序创建–>按树的从上至下从左右的顺序输入，各层的空结，点输入数值0。在构造二叉树过程中，需要一个队列暂时存储各结点的地址。
创建过程：

1）输入第一个数据：

若为0，表示是此树为空，将空指针赋值给根指针，树构       造完毕。

若不为0，动态分配一个结点单元，并存入数据，同时将该结点地址放入队列。

2）若队列不为空，从队列中取出一个结点地址，并建立该结点的左孩子：

从输入序列中读入下一数据：

若读入的数据为0，将出队结点的左孩子指针置空；否则，分配一个结点单元，存入所读数值，并将其置为出队结点的左孩子，同时将此孩子地址入队；

接着再从输入序列中读入下一个数据：

若读入的数据为0，将出队结点的右孩子指针置空；否则分配一个结点单元，存入所读数值，并将其置为出队结点的右孩子，同时将此孩子地址入队。

3）重复  2）过程，直到队列为空，再无结点出队，构造过程到此结束。

4）返回根结点地址

#include <iostream>
using namespace std;

typedef struct TNode *Position;
typedef Position BinTree;//新定义二叉树类型
typedef ElementType int;
//用0表示没有结点
#define NoInfo 0 

struct TNode{
    ElementType data;
    BinTree left;
    BinTree Right;
};

BinTree CreateBinTree(){
    ElementType data;
    BinTree BT, T;//BT用来创建新的结点， T用来接收出队结点
    Queue Q = CreateQueue();//创建空队列
    
    //建立第一个结点，即根结点
    scanf("%d", &data);
    
    if(data != NoInfo){
        //分配根结点单元，并将结点地址入队
        BT = (BinTree)malloc(sizeof(struct TNode));
        BT->data = data;
        BT->left = BT->Right = NULL;
        
        AddQ(Q, BT);
    }
    else
        return NULL;//若第一个数据是0，就返回空树
    
    while(!IsEmpty(Q)){//队列不空时，循坏
        T = Delete(Q);//从队列中取出一结点地址
        scanf("%d", &data);//读取T的左孩子
        if(data == NoInfo) 
            T->left = NULL;
        else{//分配新结点，出队结点的最孩子；新结点入队
            T->left = (BinTree)malloc(sizeof(struct TNode));
            T->left->data = data;
            T->left->left = T->left->right = NULL;
            AddQ(Q, T->left);
        }
        
         scanf("%d", &data);//读取T的右孩子
        if(data == NoInfo) 
            T->right = NULL;
        else{//分配新结点，出队结点的最孩子；新结点入队
            T->right = (BinTree)malloc(sizeof(struct TNode));
            T->right->data = data;
            T->right->left = T->right->right = NULL;
            AddQ(Q, T->right);
        }
        
    }
    
    return BT;//返回头结点地址
    
}

public class Tree {
//头节点
private  Nodehead;
public NodegetHead() {
return head;
}
public void setHead(Node head) {
this.head = head;
}
/**
* 层遍历
* @param head   头节点
*/
public  void  floorPrint(Node  head){
//创建一个队列
List queue=new LinkedList();
queue.add(head);
//队列不是空的，就一直循环
while(!queue.isEmpty()){
Node  n = ((LinkedList)queue).pop();
//打印元素值
System.out.println(n.getValue());
if(Objects.nonNull(n.getLeft())){
queue.add(n.getLeft());
}
if(Objects.nonNull(n.getRight())){
queue.add(n.getRight());
}
}
}
public static  void main(String[]  args){
Node  head =new Node("a");
Node  son1 =new Node("b");
Node  son2 =new Node("c");
head.setLeft(son1);
head.setRight(son2);
Node  son3 =new Node("d");
Node  son4 =new Node("e");
son1.setLeft(son3);
son1.setRight(son4);
Node  son5 =new Node("f");
Node  son6 =new Node("g");
son2.setLeft(son5);
son2.setRight(son6);
Tree  t =new Tree();
t.floorPrint(head);
}
}

103. 二叉树的锯齿形层次遍历
给定一个二叉树，返回其节点值的锯齿形层次遍历。（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。
示例： 给定二叉树 [3,9,20,null,null,15,7],
    3
   / 
  9  20
    /  
   15   7
返回锯齿形层次遍历如下：
[
  [3],
  [20,9],
  [15,7]
]
作者：力扣 (LeetCode) 链接：https://leetcode-cn.com/leetbook/read/data-structure-binary-tree/xefh1i/ 来源：力扣（LeetCode） 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
题解：
本题还是基于层序遍历的框架，题目所说的锯齿遍历，就是一行是正序，一行是反序，这种情况设置一个count变量，来隔行判断本行应该正序还是反序存储。
具体代码如下：
class Solution {
    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
        List<List<Integer>> result = new LinkedList<>();
        if (root == null) {
            return result;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        int count = 0;

        while (!queue.isEmpty()) {
            LinkedList<Integer> temp = new LinkedList<>();
            int len = queue.size();
            for (int i = 0; i < len; i++) {
                TreeNode node = queue.poll();
                if (count % 2 != 0) {
                    //头插元素，即逆序
                    temp.add(0, node.val);
                } else {
                    temp.add(node.val);
                }
                if (node.left != null) {
                    queue.add(node.left);
                }
                if (node.right != null) {
                    queue.add(node.right);
                }
            }
            count++;
            result.add(temp);
        }
        return result;
    }
}

前两天说过二叉树的前序遍历、中序遍历、后续遍历，把剩下的也都说了吧，二叉树遍历系列四，层次遍历。
题目链接：
二叉树的层次遍历 - 力扣（LeetCode）​leetcode-cn.com
题目描述：
给定一个二叉树，返回其按层次遍历的节点值。 （即逐层地，从左到右访问所有节点）。
例如:
给定二叉树: [3,9,20,null,null,15,7],
    3
   / 
  9  20
    /  
   15   7
返回其层次遍历结果：
[
  [3],
  [9,20],
  [15,7]
]
解题思路：
不同于之前前中后序使用栈的方法，层序遍历我们使用队列。如果一个节点有左右孩子，就把它的左右孩子 push 到队列中。
代码如下：
class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        if(!root) return {};
        vector<vector<int>> res;
        queue<TreeNode*> q;
        q.push(root);
        while (!q.empty()){
            vector<int> v;
            int size = q.size();
            for(int i = 0; i < size; ++i){
                TreeNode* p = q.front();
                v.push_back(p->val);
                if(p->left) q.push(p->left);
                if(p->right) q.push(p->right);
                q.pop();
            }
            res.push_back(v);
        }
        return res;
    }
};
leetcode 里还有俩题也是关于二叉树的层次遍历的，一是二叉树的层次遍历 II，是把二叉树的元素按层次的顺序自底向上输出一遍，其实就是把本题最后的结果倒序一下就行了。二是二叉树的锯齿形层次遍历，就是先从左到右，再从右到左，注意按照奇偶性，倒序每一行的元素就行，其他部分和本题完全一致，所以就不单独写一篇了。
如果有任何疑问，欢迎提出。如果有更好的解法，也欢迎告知。