定义不再叙述，看程序
应该是这本书，我看的第二版
https://book.douban.com/subject/10530466/
下面是二叉查找树，我认为比较好的一点是在插入的时候返回修改的子树，代替了c里面的指针，这是我看c数据结构想改写为java时所没有想到的。
还有一点，用户在插入时是不知道root的，而插入函数需要root，所以要有两个插入函数,一个是外部的，只传入值;一个是内部的，传入值和子树的根。书上直接写成了函数重载。

package copy_from_book;

import java.lang.reflect.UndeclaredThrowableException;

public class BinarySearchTree<AnyType extends Comparable<?super AnyType>> {

//内部类
    //.定义在别的类内部、函数内部的类。
    //.内部类能直接访问外部的全部资源。
    //.外部是函数时，只能访问那个函数里 final的变量。
    private static class BinaryNode<AnyType>
    {
        BinaryNode(AnyType theElement)
        {this(theElement,null,null);}
        
        BinaryNode(AnyType theElement,BinaryNode<AnyType> lt,
                BinaryNode<AnyType> rt)
        {element=theElement;left=lt;right=rt;}
        
        AnyType element;
        BinaryNode<AnyType> left;
        BinaryNode<AnyType> right;
    }
    
    private BinaryNode<AnyType>  root;
    
    public BinarySearchTree()
    {root=null;}
    
    public void makeEmpty()
    {root=null;}
    
    public boolean isEmpty()
    {return root==null;}
    
    //下面很多函数重载,是因为
    //从外部使用函数public,是不知道root
    //而调用这些函数（很多次递归，又要用到子树的root）
    //所以public去调用private的重载函数
    public boolean contains(AnyType x)
    {return contains(x,root);}
    
    public AnyType findMin()
    {
        
        if(isEmpty())  throw new UndeclaredThrowableException(null);
        return findMin(root).element;
    }
    
    public AnyType findMax()
    {
        if(isEmpty())  throw new UndeclaredThrowableException(null);
        return findMax(root).element;
    }
    
    
    public void insert(AnyType x)
    {root=insert(x,root);}
    
    public void remove(AnyType x)
    {root=remove(x,root);}
    
    
    
    
    private boolean contains(AnyType x,BinaryNode<AnyType>t)
    {
        if(t==null)
            return false;
        int compareResult=x.compareTo(t.element);
        //返回x-t.element的符号函数
        if(compareResult<0)
            return contains(x,t.left);
        else if(compareResult>0)
            return contains(x,t.right);
        else
            return true;
    }
    
    
    private BinaryNode<AnyType> findMin(BinaryNode<AnyType>t)
    {
        if(t==null)
            return null;
        else if(t.left==null)
            return t;
        else
            return findMin(t.left);
    }
    
    
    
    private BinaryNode<AnyType> findMax(BinaryNode<AnyType>t)
    {
        if(t!=null) 
        {
            while(t.right!=null)
                t=t.right;	
        }
        
        
        return t;
    }
    
    
    
    
    
    private BinaryNode<AnyType> insert(AnyType x,BinaryNode<AnyType>t)
    {
        //return the new root of the subtree这个方法太好了
        //用了这个就可以避免C里面实现时需要传入指针来改变参数
        
        /* * @param x the item to insert * @param t the node that roots the subtree * @return the new root of the subtree */
        if(t==null)
            return new BinaryNode<AnyType>(x,null,null);
        int compareResult=x.compareTo(t.element);
        //返回x-t.element的符号函数
        if(compareResult<0)
            t.left=insert(x,t.left);
        else if(compareResult>0)
            t.right=insert(x,t.right);
        else
            ;//Duplicate; do nothing
        return t;
    }
    
    
    
    
    private BinaryNode<AnyType> remove(AnyType x,BinaryNode<AnyType>t)
    {
        /* *@param x the item to remove *@param t the node that roots the subtree *@return the new root of the subtree */
        
        //如果删除的次数不多，可以采用“懒惰删除”:
        //当一个元素要被删除时，保留元素在树里
        //只是标记为删除。在有重复项时常用。
        if(t==null)
            return t;//not found;do nothing
        
        int compareResult=x.compareTo(t.element);
        
        if(compareResult<0)
            t.left=remove(x,t.left);
        else if(compareResult>0)
            t.right=remove(x,t.right);
        else if(t.left!=null&&t.right!=null)
        {
            //两趟搜索查找和删除，效率不高，
            //可以调整。
            
            
            //替换t的元素为右子树最小元素
            //删除右子树的最小元素
            t.element=findMin(t.right).element;
            t.right=remove(t.element,t.right);
        }
        
        else
            t=(t.left!=null)?t.left:t.right;
        
        return t;
        
        
    }
    
    
    public static void main(String []args)
    {
        int m[]=new int[] {1,25,6,8,5,4,2};
        BinarySearchTree<Integer> b=new BinarySearchTree<Integer>();
        for(int i=0;i<m.length;i++)
        {
            b.insert(m[i]);
        }
        System.out.println();
    }}

AVL树
书上写的不全，我又补充了一些。(原来写错了，我又改正了)

package df;

public class Avl<AnyType extends Comparable<?super AnyType>> {
    
    
    
    
    private static class AvlNode<AnyType> 
    {
        AvlNode(AnyType theElement)
        {this(theElement,null,null);}//调用下面的构造器
        
        
        AvlNode(AnyType theElement,AvlNode<AnyType>lt,
                AvlNode<AnyType>rt)
        {element=theElement;
        left=lt;
        right=rt;}
        
        AnyType element;
        AvlNode<AnyType>  left;
        AvlNode<AnyType>  right;
        int height;
    }
    
    private AvlNode<AnyType> root;
    
    private int height(AvlNode<AnyType> t)
    {
        return t==null?-1:t.height;
    }
    
    
    public void insert(AnyType x)
    {
        root=insert(x,root);
    }
    
    
    private AvlNode<AnyType> insert(AnyType x,AvlNode<AnyType>t)
    {
        /* * @param x the item to insert * @param t the node that roots the subtree * @return the new root of the subtree */
        if(t==null)
            return new AvlNode<AnyType>(x,null,null);
        
        int compareResult=x.compareTo(t.element);
        if(compareResult<0)
        {
            t.left=insert(x,t.left);
            if(height(t.left)-height(t.right)==2)
                if(x.compareTo(t.left.element)<0)
                    t=rotateWithLeftChild(t);
                else
                    t=doubleWithLeftChild(t);
        }
        else if(compareResult>0)
        {
            t.right=insert(x,t.right);
            if(height(t.right)-height(t.left)==2)
                if(x.compareTo(t.right.element)>0)
                    t=rotateWithRightChild(t);
                else
                    t=doubleWithRightChild(t);
        }
        
        else;//do nothing
        t.height=Math.max(height(t.left), height(t.right))+1;
        return t;
    }


    private AvlNode<AnyType> rotateWithLeftChild(AvlNode<AnyType>k2)
    {//插在左子树的左边
        AvlNode<AnyType>k1=k2.left;
        k2.left=k1.right;
        k1.right=k2;
        k2.height=Math.max(height(k2.left), height(k2.right))+1;
        k1.height=Math.max(height(k1.left), k2.height)+1;

        return k1;
    }
    
    
    private AvlNode<AnyType> rotateWithRightChild(AvlNode<AnyType>k2)
    {//插在右子树的右边
        AvlNode<AnyType>k1=k2.right;
        k2.right=k1.left;
        k1.left=k2;
        k2.height=Math.max(height(k2.left), height(k2.right))+1;
        k1.height=Math.max(height(k1.right), k2.height)+1;

        return k1;
    }
    

    private AvlNode<AnyType>  doubleWithLeftChild(AvlNode<AnyType> k3)
    {//插在左子树右边
        k3.left=rotateWithRightChild(k3.left);
        return rotateWithLeftChild(k3); 
    }
    
    
    
    private AvlNode<AnyType>  doubleWithRightChild(AvlNode<AnyType> k3)
    {//插在右子树左边
        k3.right=rotateWithLeftChild(k3.right);
        return rotateWithRightChild(k3); 
    }

    public static void main(String args[])
    {
        int a[]=new int[] {3,2,1,4,5,6,7,16,15,14,13,12,11,10,8,9};
        Avl<Integer>avl=new Avl<Integer>();
        for(int i=0;i<a.length;i++)
            avl.insert(a[i]);
        System.out.println();
        System.out.println();
    }

}