把第一个数作为根结点，比根结点大的数放右边，比根结点小的数放左边

中序排列顺序(左根右):0 3 5 10 10 222
前序排列顺序(根左右):10 3 0 5 222 12
后续排列顺序(左右根):0 5 3 12 222 10

递归实现

首先创建结点类用于排序等功能的实现

public class Node {
    private int data;
    private Node leftNode;
    private Node rightNode;

    public Node(int data) {
        this.data = data;
    }

    @Override
    public String toString() {
        return "Node{" +
                "data=" + data +
                '}';
    }

    //添加结点
    public void add(Node node){
        if(node == null){
            return;
        }
        if(node.data < this.data){
            if(this.leftNode == null){
                this.leftNode = node;
            }else{
                this.leftNode.add(node);
            }
        }else{
            if(this.rightNode == null){
                this.rightNode = node;
            }else{
                this.rightNode.add(node);
            }
        }
    }

    //中序遍历
    public void midSort(){
        //递归向左子树中序遍历
       if(this.leftNode != null){
           this.leftNode.midSort();
       }
        //输出父节点
        System.out.println(this);
        //递归向右子树中序遍历
       if(this.rightNode != null){
           this.rightNode.midSort();
       }
    }

    //前序遍历
    public void preSort(){
        System.out.println(this);//先输出父节点
        //递归向左子树前序遍历
        if(this.leftNode != null){
            this.leftNode.preSort();
        }
        //递归向右子树前序遍历
        if(this.rightNode != null){
            this.rightNode.preSort();
        }
    }

    //后序遍历
    public void postSort(){
        //递归向左子树中序遍历
        if(this.leftNode != null){
            this.leftNode.postSort();
        }
        //递归向右子树中序遍历
        if(this.rightNode != null){
            this.rightNode.postSort();
        }
        //输出父节点
        System.out.println(this);
    }

}

创建二叉树类用于控制结点

public class MyTree {
    private Node root;

    //添加结点
    public void add(Node node){
        if(root == null){
            root = node;
        }else{
            root.add(node);
        }
    }
    //中序
    public void midSort(){
        if(root == null){
            System.out.println("根结点为空");
        }else{
            root.midSort();
        }
    }
    //前序
    public void preSort(){
        if(root == null){
            System.out.println("根结点为空");
        }else{
            root.preSort();
        }
    }
    //后续
    public void postSort(){
        if(root == null){
            System.out.println("根结点为空");
        }else{
            root.postSort();
        }
    }
}

测试类用于检验：

public class Text {
    public static void main(String[] args) {

        int[] arr =new int[]{10,222,3,12,5,0};
        MyTree myTree = new MyTree();
        for(int i=0 ;i < arr.length ;i++){
            myTree.add(new Node(arr[i]));
        }
        myTree.midSort();
        System.out.println("-------------------------");
        myTree.preSort();
        System.out.println("-------------------------");
        myTree.postSort();

    }
}

非递归实现

   //非递归先序遍历
    public void preSort2(Node root){
        if(root == null)
            return;
        Stack<Node> stack = new Stack<>();
        stack.push(root);
        while(!stack.isEmpty()){
            Node node = stack.pop();
            System.out.println(node.data);
            if(node.rightNode != null){
                stack.push(node.rightNode);
            }
            if(node.leftNode != null){
                stack.push(node.leftNode);
            }
        }
    }
    //非递归中序遍历
    public void midSort2(Node root){
        if(root == null)
            return;
        Stack<Node> stack = new Stack<>();
        Node cur = root;
        while(!stack.isEmpty() || cur != null){
            while (cur != null){
                stack.push(cur);
                cur = cur.leftNode;
            }
           Node node = stack.pop();
            System.out.println(node.data);
            if(node.rightNode != null){
                cur = node.rightNode;
            }
        }
    }
    //非递归后续遍历
    public void postSort2(Node root){
        if(root == null)
            return;
        Stack<Node> stack = new Stack<>();
        Stack<Node> stack2 = new Stack<>();
        stack.push(root);
        while(!stack.isEmpty()){
            Node node = stack.pop();
            stack2.push(node);
            if(node.leftNode != null){
                stack.push(node.leftNode);
            }
            if(node.rightNode != null){
                stack.push(node.rightNode);
            }
        }
        while (!stack2.isEmpty()){
            System.out.println(stack2.pop().data);
        }
    }