java 简易二叉树的实现类

接口

/**
 * 二叉树
 * @param <T>
 */
public interface BinTree<T extends Comparable<? super T>> {
    /**
     * 先序遍历
     */
    int FRONT_TRAVERSE = 1;
    /**
     * 后续遍历
     */
    int BACK_TRAVERSE = 1<<1;
    /**
     * 中序遍历
     */
    int MID_TRAVERSE = 1<<2;
    /**
     * 向二叉树中插入元素
     * @param t 待插入的元素 不可为空
     */
    void insert(T t);

    /**
     * 删除指定元素
     * @param t 待删除的元素
     */
    void remove(T t);

    /**
     * 检查给定元素是否存在
     * @param t 待检测元素
     * @return true存在 false不存在
     */
    boolean contains(T t);

    /**
     * 返回树中最小元素
     * @return 树中最小元素 树为空时返回null
     */
    T findMin();

    /**
     * 返回树中最大元素
     * @return 树中最大元素 树为空时返回null
     */
    T findMax();

    /**
     * 返回树中节点数量
     * @return 树中节点数量
     */
    int size();

    /**
     * 树是否没有元素
     * @return true树为空树 false树不为空树
     */
    boolean isEmpty();

    /**
     * 清空树
     * @return
     */
    void clear();

    /**
     * 遍历输出
     * @param traverseType 遍历方式
     * @throws OperationNotSupportedException 默认不支持此项操作
     */
    default List<T> toList(int traverseType) throws OperationNotSupportedException{
        throw new OperationNotSupportedException("this tree impl do not support print");
    };
}

实现

/**
 * 简单二叉树
 */
public class MySimpleBindTree<T extends Comparable<? super T>> implements BinTree<T>{



    private BinTreeNode<T> root;

    private int size;

    public MySimpleBindTree(){

    }

    @Override
    public void insert(T t) {
        Objects.requireNonNull(t,"MySimpleBinTree's insert do not allow null value");
        root = insert_0(root,t);
    }

    private BinTreeNode<T> insert_0(BinTreeNode<T> currRoot , T value){
        if(currRoot==null){
            currRoot = new BinTreeNode<T>(value,null,null);
            size++;
        }else if(value.compareTo(currRoot.value)==0){
            return currRoot;
        }else {
            if(value.compareTo(currRoot.value)<0){
                currRoot.left = insert_0(currRoot.left,value);
            }else if(value.compareTo(currRoot.value)>0){
                currRoot.right = insert_0(currRoot.right,value);
            }
        }
        return currRoot;
    }

    @Override
    public void remove(T t) {
        Objects.requireNonNull(t,"MySimpleBinTree's remove do not allow null value");
        if(isEmpty())return;
        root = remove(root,t);
    }

    private BinTreeNode<T> remove(BinTreeNode<T> currRoot , T value){
        if(currRoot==null)return null;

        if(value.compareTo(currRoot.value)<0){
            currRoot.left = remove(currRoot.left,value);
        }
        else if(value.compareTo(currRoot.value)>0){
            currRoot.right = remove(currRoot.right,value);
        }
        else {

            if (currRoot.left == null) {
                return currRoot.right;
            } else if (currRoot.right == null) {
                return currRoot.left;
            } else {
                //这里是复用了minNodeOfRight这个节点，也可将该节点的值赋给当前节点，效果一样
                BinTreeNode<T> minNodeOfRight = findMinNode(currRoot.right);
                currRoot.right = remove(currRoot.right, minNodeOfRight.value);
                minNodeOfRight.left = currRoot.left;
                minNodeOfRight.right = currRoot.right;
                return minNodeOfRight;
            }

        }
        return currRoot;
    }

    @Override
    public boolean contains(T t) {
        Objects.requireNonNull(t,"MySimpleBinTree's contains do not allow null value");
        return contains_0(root,t);
    }

    private boolean contains_0(BinTreeNode<T> currRoot,T value){
        if(currRoot==null){
            return false;
        }else {
            if(currRoot.value.compareTo(value)==0){
                return true;
            }else if(value.compareTo(currRoot.value)<0){
                return contains_0(currRoot.left,value);
            }else {
                return contains_0(currRoot.right,value);
            }
        }
    }

    @Override
    public T findMin() {
        if(isEmpty()){
            return null;
        }
        BinTreeNode<T> currRoot = root;
        while (true){
            if(currRoot.left!=null){
                currRoot = currRoot.left;
            }else {
                return currRoot.value;
            }
        }
    }

    private BinTreeNode<T> findMinNode(BinTreeNode<T> currRoot){
        if(currRoot==null)return null;
        if(currRoot.left==null)return currRoot;
        return findMinNode(currRoot.left);
    }

    @Override
    public T findMax() {
        if(isEmpty()){
            return null;
        }
        BinTreeNode<T> currRoot = root;
        while (true){
            if(currRoot.right!=null){
                currRoot = currRoot.right;
            }else {
                return currRoot.value;
            }
        }
    }

    @Override
    public int size() {
        return size;
    }

    @Override
    public boolean isEmpty() {
        return size==0;
    }

    @Override
    public void clear() {
        root = null;
    }


    private static class BinTreeNode<E extends Comparable<? super E>>{
        E value;
        BinTreeNode<E> left;
        BinTreeNode<E> right;
        BinTreeNode(){

        }
        BinTreeNode(E value , BinTreeNode<E> left , BinTreeNode<E> right){
            this.value = value;
            this.left = left;
            this.right = right;
        }
    }


}