按之字形顺序打印二叉树 java

请实现一个函数按照之字形打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右至左的顺序打印，第三行按照从左到右的顺序打印，其他行以此类推。

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;

/*
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

    public TreeNode(int val) {
        this.val = val;

    }

}
*/
public class Solution {
    /**
     * 请实现一个函数按照之字形打印二叉树，即第一行按照从左到右的顺序打印，
     * 第二层按照从右至左的顺序打印，第三行按照从左到右的顺序打印，其他行以此类推。
     * 还是先复制下来这个二叉树，让复制下来的二叉树有一个层次的属性
     *
     *
     * */
    public ArrayList<ArrayList<Integer> > Print(TreeNode pRoot) {
        ArrayList<ArrayList<Integer>> arrayLists = new ArrayList<>();
        if (pRoot==null) {
            return arrayLists;
        }
        Stack<Integer> integerStack = new Stack<>();
        ArrayList<Integer> temp = null;
        // 拷贝二叉树
        LeverTreeNode copyRoot = copyTreeNode(pRoot);
        Queue<LeverTreeNode> q = new LinkedList<>();
        copyRoot.lever = 1;
        q.add(copyRoot);
        while(!q.isEmpty()) {
            LeverTreeNode nowNode = q.peek();
            q.poll();
            if (arrayLists.size()>=nowNode.lever) {
                // 如果是已经存在的层次
                temp = arrayLists.get(nowNode.lever-1);
                temp.add(nowNode.val);
            } else {
                // 如果是新的层次
                temp = new ArrayList<>();
                temp.add(nowNode.val);
                arrayLists.add(temp);
            }
            if (nowNode.left!=null) {
                nowNode.left.lever = nowNode.lever+1;
                q.add(nowNode.left);
            }
            if (nowNode.right!=null) {
                nowNode.right.lever = nowNode.lever+1;
                q.add(nowNode.right);
            }
        }
        // 进行反转
        for (int i=1; i<arrayLists.size(); i+=2) {
            ArrayList<Integer> midTemp = arrayLists.get(i);
            for (int j=0; j<midTemp.size(); ++j) {
                integerStack.push(midTemp.get(j));
            }
            midTemp.clear();
            while(!integerStack.isEmpty()) {
                Integer ele = integerStack.peek();
                integerStack.pop();
                midTemp.add(ele);
            }
            arrayLists.set(i, midTemp);
        }
        return arrayLists;

    }
    public LeverTreeNode copyTreeNode(TreeNode root) {
        LeverTreeNode copyRoot = null;
        if (root != null) {
            copyRoot = new LeverTreeNode(root.val);

            copyRoot.left = copyTreeNode(root.left);

            copyRoot.right = copyTreeNode(root.right);
        }
        return copyRoot;
    }

}

class LeverTreeNode {
    int val = 0;
    int lever = 0;
    LeverTreeNode left = null;
    LeverTreeNode right = null;

    public LeverTreeNode(int val) {
        this.val = val;
    }
}