103. 二叉树的锯齿形层序遍历（Java）

/**
 * @Author: DiTian
 * @Description: 二叉树的锯齿形层次遍历
 * @Date: Created in 16:08 2021/7/28
 */
@SuppressWarnings("unused")
public class ZigzagLevelTraversal {
    //树节点类
    static class TreeNode{
        Integer val;
        TreeNode left;
        TreeNode right;

        public TreeNode() {
        }
        public TreeNode(Integer val, TreeNode left, TreeNode right) {
            this.val = val;
            this.left = left;
            this.right = right;
        }

        public Integer getVal() {
            return val;
        }

        public void setVal(Integer val) {
            this.val = val;
        }

        public TreeNode getLeft() {
            return left;
        }

        public void setLeft(TreeNode left) {
            this.left = left;
        }

        public TreeNode getRight() {
            return right;
        }

        public void setRight(TreeNode right) {
            this.right = right;
        }
    }
    //递归先序创建普通二叉树，以输入的值是否为0确定其是否有孩子节点
    public static TreeNode preCreate(TreeNode treeNode){
        Scanner scanner = new Scanner(System.in);
        System.out.println("输入节点的值：");
        int val = scanner.nextInt();
        if (val!=0){
            treeNode = new TreeNode();
            treeNode.setVal(val);
            treeNode.setLeft(preCreate(treeNode.getLeft()));
            treeNode.setRight(preCreate(treeNode.getRight()));
        }else{
            treeNode = null;
        }
        return treeNode;
    }
    //先序遍历以及访问处理
    public static void visit(TreeNode btnode){
        if(btnode!=null)
            System.out.print(btnode.getVal() + " ,");
    }
    public static  void preorder(TreeNode btnode) {
        if(btnode!=null){
            visit(btnode);
            preorder(btnode.getLeft());
            preorder(btnode.getRight());
        }
    }

    //二叉树的锯齿形层序遍历
    public static List<List<Integer>> zigzagLevelOrder(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>(); // 定义结果变量
        Queue<TreeNode> queue = new LinkedList<>();  // 定义队列
        if (root != null) {                          // 根节点不为空先加入队列
            queue.offer(root);
        }
        List<Integer> list ;                         // 定义列表存放每一层节点的数组
        while (!queue.isEmpty()) {                   // 队列不为空时循环
            int size = queue.size();                 // 统计当前层的元素数量
            list = new ArrayList<>();                // 初始化列表为空
            for (int i = 0; i < size; i++) {         // 遍历队列中的前 size 个节点
                TreeNode node = queue.poll();        // 按顺序弹出队列元素，加入集合
                list.add(node.val);
                if (node.left != null) {
                    queue.offer(node.left);          // 当前元素的左子树入队，即把下一层的元素加入队列
                }
                if (node.right != null) {
                    queue.offer(node.right);         // 当前元素的右子树入队，即把下一层的元素加入队列
                }
            }
            if (res.size() % 2 == 1) {      // 用结果集中已经存在的数组数判断当前层时奇数层还是偶数层
                Collections.reverse(list);  // 结果集中有奇数个结果集了，说明当前层是偶数层，要翻转加入
            }
            res.add(list);
        }
        return res;
    }
    //测试
    public static void main(String[] args) {
        TreeNode treeNode = new TreeNode();
        treeNode = preCreate(treeNode);
        preorder(treeNode);
        System.out.println(zigzagLevelOrder(treeNode));
    }
}