두 갈래 나무의 선착순 (귀속과 비귀속), 중착순 (귀속과 비귀속), 후착순 (비귀속) 및 차원 자바 구현

    public List preorderTraversal(TreeNode root)   
    { // 
        List list = new ArrayList();
        PreOrderTraversal(root,list);
        return list;
    }
    public void PreOrderTraversal(TreeNode root,List list)
    {
        if(root == null)
            return;
        list.add(root.val);
        if(root.left != null)
            PreOrderTraversal(root.left,list);
        if(root.right != null)
            PreOrderTraversal(root.right,list);
    }

    public static List PreOrderTree(TreeNode root)
    {
        List list = new ArrayList();
        if(root == null)
            return list;
        Stack stack = new Stack<>();
        TreeNode pCur = root;
        while(pCur != null || !stack.isEmpty())
        {
            list.add(pCur.val);
            stack.push(pCur);
            pCur = pCur.left;
            while(pCur == null && !stack.isEmpty())
            {
                pCur = stack.pop();
                pCur = pCur.right;
            }
        }
        return list;
    }

    public List inorderTraversal(TreeNode root)
    {
        Stack stack = new Stack();
        List list = new ArrayList();
        inOrderTraversal(root,stack,list);
        return list;
    }
    public void inOrderTraversal(TreeNode root,Stack stack,List list)
    {
        if(root == null)
            return;
        stack.push(root);   // 
        if(root.left != null)
            inOrderTraversal(root.left,stack,list);       // 
        list.add(stack.pop().val);      // ， ， list 
        if(root.right != null)                         // 
            inOrderTraversal(root.right,stack,list);
    }

    public static List InOrderTree(TreeNode root)
    {
        List list = new ArrayList<>();
        if(root == null)
            return list;
        Stack stack = new Stack<>();
        TreeNode pCur = root;
        while(pCur != null || !stack.isEmpty())
        {
            stack.push(pCur);
            pCur = pCur.left;
            while(pCur == null && !stack.isEmpty())
            {
                pCur = stack.peek().right;
                list.add(stack.pop().val);
            }
        }
        return list;
    }

    public static List PostOrderTree(TreeNode root)
    {
        List list = new ArrayList<>();
        if(root == null)
            return list;
        Stack stack = new Stack<>();
        Boolean flag = false; // 
        TreeNode pCur = root;
        TreeNode temp = null; 
        while(pCur != null)
        {
            stack.add(pCur);
            pCur = pCur.left;
            if(pCur == null)
            {
                flag = true;
                temp = null;
                while(!stack.isEmpty() && flag == true)
                {
                    pCur = stack.peek();
                    if(pCur.right == temp || pCur.right == null)
                    {
                        list.add(pCur.val);
                        temp = stack.pop();
                    }
                    else
                    {
                        pCur = pCur.right;
                        flag = false;
                    }
                }
                if(stack.isEmpty())
                    return list;
            }
        }
        return list;
    }

    public ArrayList> levelOrder(Node root)   // 
    {
        ArrayList> list = new ArrayList<>();
        if(root == null)
            return list;
        Queue queue = new LinkedList<>();
        queue.add(root);
        while (!queue.isEmpty())
        {
            int levelNum = queue.size();
            ArrayList levelList = new ArrayList<>();
            for(int i = 0; i < levelNum; i++)
            {
                Node temp = queue.poll();
                levelList.add(temp.val);
                if(temp.children != null)
                    for(Node ele : temp.children)
                        queue.add(ele);
            }
            list.add(levelList);
        }
        return list;
    }