实现一个二叉排序树

package ErChaShu;

import java.util.ArrayList;
import java.util.Random;

public class BST<E extends Comparable<E>>{
    private class Node{
         private E e;
         private Node left;
         private Node right;

        public Node (E e) {
            this.e=e;
            left=null;
            right=null;
        }
    }
    private Node root;
    int size;
    public BST(){
        root=null;
        size=0;
    }

    //查询有多少元素
    public int getSize(){
        return size;
    }

    //查询根节点的元素
    public E getRoot(){
        return root.e;
    }

    //判断是否为空
    public boolean isEmpty(){
        return size==0;
    }

    //添加元素
    public void add(E e){
       root=add(root,e);
    }
    public Node add(Node node,E e){
        if(node==null){
            size++;
            return new Node(e);
        }
        else if(e.compareTo(node.e)<0){
            node.left=add(node.left,e);
        }
        else{
            node.right=add(node.right,e);}
        return node;
    }

    //判断树中是否包含元素e
    public boolean contain(E e){
        return contain(root,e);
    }
    public boolean contain(Node node,E e){
            if(node!=null){
                return false;}
            if(e.compareTo(node.e)==0){
                return true;}
            else if(e.compareTo(node.e)<0){
                return contain(node.left,e);
            }
            else{
                return contain(node.right,e);}
    }

    //二分搜索树的前序遍历
    public void preprint(){
        preprint(root);
    }
    private void preprint(Node node) {
        if (node == null)
            return;
        System.out.println(node.e);
        preprint(node.left);
        preprint(node.right);
    }

    //二分搜索树的中序遍历
    public void inprint(){
        inprint(root);
    }
    private void inprint(Node node) {
        if (node == null){
            return;}
        inprint(node.left);
        System.out.println(node.e);
        inprint(node.right);
    }

    //二分搜索树的后序遍历
    public void lastprint(){
        lastprint(root);
    }
    private void lastprint(Node node) {
        if (node == null){
            return;}
        lastprint(node.left);
        lastprint(node.right);
        System.out.println(node.e);
    }

    //查找二分搜索树中最小的值
    public E getMin(){
        if(size==0){
            System.out.println("tree is Empty !");
        }
        return getMin(root).e;
    }
    public Node getMin(Node node){
        if(node.left==null){
            return node;
        }
       return getMin(node.left);
    }

    //删除二分搜索树中最小的元素所在的节点
    public E removeMin(){
        if(root==null){
            System.out.println("删除失败，树是空树");
            return null;
        }
        E a=getMin();
        removeMin(root);
        return a;

    }
    //删除二分搜索树中最小的元素所在的节点,返回新的二分搜索树的根
    public Node removeMin(Node node) {
        if(node.left==null){
            Node rightnode=node.right;
            node.right=null;
            size--;
            return rightnode;
        }
        node.left =removeMin(node.left);
        return node;
    }

    //删除二分搜索树中最大的元素所在的节点
    public void removeMax(){
        if(root==null){
            System.out.println("删除失败，树是空树");
            return;
        }
        removeMax(root);
    }
    //删除二分搜索树中最大的元素所在的节点,返回新的二分搜索树的根
    public Node removeMax(Node node) {
        if(node.right==null){
            Node leftnode=node.left;
            node.left=null;
            size--;
            return leftnode;
        }
        node.right =removeMax(node.right);
        return node;
    }

    //删除树中任意一个元素
    public void remove(E e) {
        remove(root,e);
    }
    //删除树中任意一个元素
    public void remove(Node node,E e){
        if(node==null){ return;}
        if(e.compareTo(node.e)==0){
            node.right.left=node.left;
            node=node.right;
        }
        else if(e.compareTo(node.e)<0){
            remove(node.left,e);
        }
        else{
            remove(node.right,e);}
    }

    public static void main(String[] args) {
        BST<Integer> bst=new BST<>();
        Random random=new Random();
        for(int i=1;i<=1000;i++){
            bst.add(random.nextInt(10000));
        }
        ArrayList<Integer> arr=new ArrayList<>();
        while(!bst.isEmpty()){
            arr.add(bst.removeMin());
        }
        for(int j=1;j<arr.size();j++){
            if(arr.get(j)<arr.get(j-1)){
                System.out.println("error!");
            }
        }
        System.out.println("test complete");
    }
}