1、N 叉树的层序遍历 - 力扣（LeetCode）

思路：

1. 每次遍历一层节点的时候就把当前节点的值添加到列表中
2. 再将当前层的节点的子节点添加到队列中
3. 每次遍历完一层之后就添加到总表中
4. 代码：

   public List<List<Integer>> levelOrder(Node root) {
           List<List<Integer>> ret = new ArrayList<>();
           if(root == null){
               return ret;
           }
           Queue<Node> q = new LinkedList<>();
           q.offer(root);
           while(!q.isEmpty()){
               //存储每一层的节点值
               List<Integer> tmp = new ArrayList<>();
               int n = q.size();
               for(int i = 0; i < n; i++){
                   Node t = q.poll();
                   tmp.add(t.val);
                   //让孩子节点入队
                   for(Node child : t.children){
                       if(child != null){
                           q.offer(child);
                       }
                   }
               }
               ret.add(tmp);
           }
           return ret;
       }

 2、二叉树的锯齿形层序遍历 - 力扣（LeetCode）

思路：

1. 只需创建一个标记位，偶数行的时候逆序节点的值即可，逻辑和层序遍历一致
2. 代码：

   public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
           List<List<Integer>> ret = new ArrayList<>();
           if(root == null){
               return ret;
           }
           Queue<TreeNode> q = new LinkedList<>();
           q.offer(root);
           int dev = 1;
           while(!q.isEmpty()){
               List<Integer> tmp = new ArrayList<>();
               //每一层的节点个数，遍历的次数
               int n = q.size();
               for(int i = 0; i < n; i++){
                   TreeNode t = q.poll();
                   tmp.add(t.val);
                   if(t.left != null){
                      q.offer(t.left);
                   }
                   if(t.right != null){
                       q.offer(t.right);
                   }
               }
               if(dev % 2 == 0){
                   Collections.reverse(tmp);
               }
               ret.add(tmp);
               dev++;
           }
           return ret;
       }

 3、二叉树最大宽度 - 力扣（LeetCode）

思路：

1. 将每个节点的下标都表示出来，最大宽度就是一头一尾相减
2. 
3. 使用数组表示队列
4. 代码：

   public int widthOfBinaryTree(TreeNode root) {
           //数组模拟队列
           List<Pair<TreeNode,Integer>> q = new ArrayList<>();
           //添加到表中，还有节点下标
           q.add(new Pair<TreeNode,Integer>(root,1));
           //记录最终结果
           int ret = 0;
   
           while(!q.isEmpty()){
               //更新一下这一层的宽度
               Pair<TreeNode,Integer> t1 = q.get(0);
               Pair<TreeNode,Integer> t2 = q.get(q.size() - 1);
               ret = Math.max(ret,t2.getValue() - t1.getValue() + 1);
   
               //下一层进队,新建一个表，然后再覆盖原表，模拟出队操作
               List<Pair<TreeNode,Integer>> tmp = new ArrayList<>();
               for(Pair<TreeNode,Integer> t : q){
                   //当前节点的值
                   TreeNode node = t.getKey();
                   //当前节点下标
                   int index = t.getValue();
                   if(node.left != null){
                       tmp.add(new Pair<TreeNode,Integer>(node.left, index * 2));
                   }
                   if(node.right != null){
                       tmp.add(new Pair<TreeNode,Integer>(node.right, index * 2 + 1));
                   }
               }
               q = tmp;
           }
           return ret;
       }

4、在每个树行中找最大值 - 力扣（LeetCode）

思路：

1. 只需在每次层序遍历的时候，找出每一层的最大值即可
2. 代码：

   public List<Integer> largestValues(TreeNode root) {
           List<Integer> ret = new ArrayList<>();
           if(root == null){
               return ret;
           }
           Queue<TreeNode> q = new LinkedList<>();
           q.offer(root);
           while(!q.isEmpty()){
               int tmp = Integer.MIN_VALUE;
               //当前层数节点的个数
               int n = q.size();
               //遍历该层的每一个节点，并将其子节点添加到队列中
               for(int i = 0; i < n; i++){
                   TreeNode t = q.poll();
                   //更新最大值
                   tmp = Math.max(tmp, t.val);
                   if(t.left != null){
                       q.offer(t.left);
                   }
                   if(t.right != null){
                       q.offer(t.right);
                   }
               }
               ret.add(tmp);
           }
           return ret;
       }