tree traversal implemented in Java(recursive and non-recursive)

recursive pre-order traversal

public class main{

    private class TreeNode{
        int value;
        TreeNode left, right;
    
        TreeNode(int value){
            this.value = value;
        }
    }

    public static void main(String[] args){
       TreeNode root = new TreeNode(1);
       root.left = new TreeNode(2);
       root.right = new TreeNode(3);
       root.left.left = new TreeNode(4);
       root.left.right = new TreeNode(5);
       root.right.right = new TreeNode(6);

       preTraversal(root);
    }

    protected static void preTraversal(TreeNode root){
        if(root == null) return;
        System.out.printf("%d ", root.value);
        preTraversal(root.left);
        preTraversal(root.right);
    }
}

non-recursive pre-order traversal

    //non-recursive pre-order traversal
    protected static List<Integer> nonRecursivePreOrder(TreeNode root){
        Stack<TreeNode> st = new Stack<TreeNode>();
        List<Integer> result = new ArrayList<Integer>();
        if(root == null) return result;

        TreeNode p = root;
        while(!st.isEmpty() || p != null){
            if(p != null){
                result.add(p.value);
                if(p.left != null){
                    st.push(p);
                    p=p.left;
                }else{
                    p = p.right;
                }
            }else{
                p = st.pop().right;
            }
        }
        return result;
    }

non-recursive in-order traversal

    //non-recursive in-order traversal
    protected static List<Integer> nonRecursiveInOrder(TreeNode root){
        Stack<TreeNode> st = new Stack<TreeNode>();
        List<Integer> result = new ArrayList<Integer>();
        if(root == null) return result;

        TreeNode p = root;
        while(!st.isEmpty() || p!=null){
            if(p!=null){
                if(p.left!=null){
                    st.push(p);
                    p = p.left;
                }else{
                    result.add(p.value);
                    p = p.right;
                }
            }else{
                p = st.pop();
                result.add(p.value);
                p = p.right;
            }
        }
        return result;
    }

non-recursive post-order traversal(two stacks)

    //non-recursive post-order traversal
    protected static List<Integer> nonRecursivePostOrder(TreeNode root){
        Stack<TreeNode> s1 = new Stack<TreeNode>();
        Stack<TreeNode> s2 = new Stack<TreeNode>();
        List<Integer> result = new ArrayList<Integer>();
        if(root == null) return result;
        
        TreeNode p = root;
        while(!s2.isEmpty() || p!=null){
            while(p != null){
                s1.push(p);
                s2.push(p);
                p = p.right;
            }
    
            while(!s2.isEmpty()){
                p = s2.pop();
                p = p.left;
                if(p != null)break;
            }
        }

        while(!s1.isEmpty()){
            result.add(s1.pop().value);
        }
        return result;
    }