Zigzag hierarchical traversal of Niuke.com and binary tree

Title description

solution

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) {
    
    
        // write code here
        //按照层序遍历的过程，我们使用队列来实现  
        ArrayList<ArrayList<Integer>> result = new ArrayList<ArrayList<Integer>>();
        if(root==null) return result;
        Queue<TreeNode> q = new LinkedList<TreeNode>();//这里的linkedlist实现了Dqueue接口
        q.add(root);
        int level = 0;//第一层
        while(!q.isEmpty()){
    
    //队列不空
            //一层层的遍历
            ArrayList<Integer> level_res = new ArrayList<>();
            int size = q.size();//当前层的结点数
            for(int i=0;i<size;i++){
    
    
                TreeNode cur = q.poll();
                if(cur.left!=null) q.add(cur.left);
                if(cur.right!=null) q.add(cur.right);
                //判断当前节点应该是哪个方向加入数组：
                if(level%2==0){
    
    
                    //偶数则从左到右，所以是尾插法
                    level_res.add(cur.val);
                }else{
    
    //奇数，头插法
                     level_res.add(0,cur.val);
                }
                
            }//完成一层
            level++;
            result.add(level_res);
        }
        return result;
    }
}

The second is to use the pre-order traversal to add one more variable record layer number, create a corresponding ArrayList according to the number of layers, and then add it to the corresponding result.
reference:

    //简单的解法：前序遍历，按层级从左到右塞到每个list中
    public static void dfs(TreeNode root, int level, ArrayList<ArrayList<Integer>> lists){
    
    
        if(root!=null){
    
    
            //根据层级扩容list
            if(lists.size()<level+1){
    
    
                lists.add(new ArrayList<>());
            }
            lists.get(level).add(root.val);
        }else {
    
    
            return;
        }
        dfs(root.left,level+1,lists);
        dfs(root.right,level+1,lists);
    }

    //下标为偶数的list反转
    public static ArrayList<ArrayList<Integer>> zigzagLevelOrder (TreeNode root) {
    
    
        ArrayList<ArrayList<Integer>> lists=new ArrayList<>();
        dfs(root,0,lists);
        for(int i=0;i<lists.size();i++){
    
    
            if(i%2!=0){
    
    
                Collections.reverse(lists.get(i));
            }
        }
        return lists;
    }