BinarySortTree二叉树

public class BinarySortTree<E extends Comparable<E>> {
    //根节点
    private Node root;
    private int size;  //0

    //添加操作
    public boolean add(E e){
        //判断root是否为null,若为null,则让新元素封装为节点称为root
        if (root==null){
            root = new Node(e);
            return true;
        }
        //若root不为null,尝试将新元素添加到root节点的左/右子树上
        return root.append(e);
    }

    //根据元素对象查找元素对应的节点对象
    public Node get(E e){
        //判断root是否为null,若为null,直接返回null
        if (root==null)
            return null;
        //若root不为null,则从root节点开始依次判断目标节点是否为要找的节点
        return root.get(e);
    }

    @Override
    public String toString() {
        //判断root是否为null,若为null,返回[]
        if (root==null)
            return "[]";
        //若root不为null,则对二叉排序树进行中序遍历,将元素拼接成字符串返回,元素之间用,分割
        StringBuilder builder = new StringBuilder("[");
        //对二叉排序树进行中序遍历
        builder = root.midOrder(builder); //[1,2,3,4]
        //将builder最后的,去掉
        return builder.deleteCharAt(builder.length()-1).append("]").toString();
    }

    //创建内部类 表示节点对象
    private  class Node{
        private E data;
        private Node left;
        private Node right;

        Node(E e){
            data = e;
        }

        //向该节点添加元素,成为其左/右子树
        public boolean append(E e) {
            //判断e是否和当前节点元素值相等,若相等,添加失败,返回false
            if (e.compareTo(data)==0)
                return false;
                //若不相等,则判断是大于,还是小于
            else if (e.compareTo(data)>0){
                //添加到右子树
                if (right==null) {
                    right = new Node(e);
                    return true;
                }
                return right.append(e);
            }else{  //e小于节点的元素,向左子树添加
                if (left==null){
                    left = new Node(e);
                    return true;
                }else {
                    return left.append(e);
                }
            }
        }

        //中序遍历,将遍历到的元素拼接到builder对象中
        public StringBuilder midOrder(StringBuilder builder) {
            //遍历左子树
            if (left!=null)
                left.midOrder(builder);
            //取到根节点元素的值并拼接
            builder.append(data).append(",");
            //遍历右子树
            if (right!=null)
                right.midOrder(builder);
            return builder;
        }

        //该用于用于判断目标节点是否为要找的节点
        public Node get(E e) {
            //判断当前节点的元素是否与e相同,若相同,则返回当前节点
            if (e.compareTo(data)==0)
                return this;
                //若不相等,则判断大小
            else  if (e.compareTo(data)>0){
                //到右子树去找
                if (right==null)
                    return null;
                return right.get(e);
            }else {  //e小于当前节点,到左子树去查找
                if (left==null)
                    return null;
                return left.get(e);
            }
        }

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