二叉树层次遍历：由顶层向底/由底层到顶层/z型

1.给定一个二叉树，返回该二叉树由顶层向底的层序遍历，（从左向右，从叶子节点到根节点，一层一层的遍历）

思路分析：

1.定义一个队列，根节点入队，判断左右子树

2.sublist存放同一层结点的值

3.list存放所有层节点的值

import java.util.*;
/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 * }
 */
public class Solution {
    /**
     *
     * @param root TreeNode类
     * @return int整型ArrayList<ArrayList<>>
     */
    public ArrayList<ArrayList<Integer>> levelOrderBottom (TreeNode root) {
       ArrayList<ArrayList<Integer>>list=new ArrayList<>();//记录节点顺序
        if(root==null){
            return list;
        }
        LinkedList<TreeNode>q=new LinkedList<>();
//队列(放的结点),LinkedList中可以使用offer（），offerFirst（），ArrayList不能用offer（）
        q.offer(root);//入队
        while(!q.isEmpty()){
            ArrayList<Integer>sublist=new ArrayList<>();//sublist存放同一层结点的值
            int size=q.size();
            for(int i=0;i<size;i++){
                TreeNode cur=q.poll();
                sublist.add(cur.val);
                //判断左右结点，不空入队
                if(cur.left!=null) q.offer(cur.left);
                if(cur.right!=null) q.offer(cur.right);
            }
            //遍历完一层，插入到list中
            list.add(sublist);
        }
        return list;
    }
}

2.给定一个二叉树，返回该二叉树由底层到顶层的层序遍历，（从左向右，从叶子节点到根节点，一层一层的遍历）

思路分析：

1.定义一个队列，根节点入队，判断左右子树

2.sublist存放同一层结点的值

3.list存放所有层节点的值

4. Collections.reverse（）倒置

Offerfirst():将指定的元素插入LinkedList的开头。失败返回false,

import java.util.*;
/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 * }
 */
public class Solution {
    /**
     *
     * @param root TreeNode类
     * @return int整型ArrayList<ArrayList<>>
     */
    public ArrayList<ArrayList<Integer>> levelOrderBottom (TreeNode root) {
       ArrayList<ArrayList<Integer>>list=new ArrayList<>();//记录节点顺序
        if(root==null){
            return list;
        }
        LinkedList<TreeNode>q=new LinkedList<>();
//队列(放的结点),LinkedList中可以使用offer（），offerFirst（），ArrayList不能用offer（）
        q.offer(root);//入队
        while(!q.isEmpty()){
            ArrayList<Integer>sublist=new ArrayList<>();//sublist存放同一层结点的值
            int size=q.size();
            for(int i=0;i<size;i++){
                TreeNode cur=q.poll();
                sublist.add(cur.val);
                //判断左右结点，不空入队
                if(cur.left!=null) q.offer(cur.left);
                if(cur.right!=null) q.offer(cur.right);
            }
            //遍历完一层，插入到list中
            list.add(sublist);
        }
       //倒置list
        Collections.reverse(list);
        return list;
    }
}

3.给定一个二叉树，返回该二叉树的之字形层序遍历，（从左向右，下一层从右向左，一直这样交替）

解题思路：

1.建立一个队列，根节点入队

2.当队列不空，出队节点，出队左节点不空入队，出队右节点不空入队。

3.flag:true为奇正常加入sublist.add(cur.val)，false为偶,头插入sublist.add(0,cur.val)

4.一层结束以后，将sublist加入到结果值list中，flag取反。

import java.util.*;
/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 * }
 */
public class Solution {
    /**
     *
     * @param root TreeNode类
     * @return int整型ArrayList<ArrayList<>>
     */
    public ArrayList<ArrayList<Integer>> zigzagLevelOrder (TreeNode root) {
        ArrayList<ArrayList<Integer>> list=new ArrayList<>();//存放结果
        if(root==null) return list;
        LinkedList<TreeNode> queue=new LinkedList<>();//队列
        queue.offer(root);
        boolean flag=true;
        while(!queue.isEmpty()){
            ArrayList<Integer>sublist=new ArrayList<>();
            int size=queue.size();
            for(int i=0;i<size;i++){
                TreeNode cur=queue.poll();
                if(cur.left!=null) queue.offer(cur.left);
                if(cur.right!=null) queue.offer(cur.right);
                 //偶翻奇不翻
                if(flag==true) sublist.add(cur.val);
                else sublist.add(0,cur.val);
            }
            list.add(sublist);
            flag=!flag;
            
        }
        return list;
    }
}