二叉树的实现、键的最大值、最小值、Rank（）、select（）、get（）、put（）方法实现

package Tree;

//定义二叉树是具有键、值的，key要继承Comparable接口
public class BinarySearchTree <Key extends Comparable<Key>,Value>  {
    private class Node
    {
        //定义键，定义值
        private Key key;
        private Value val;
        //定义左右节点
        private Node left,right;
        //以该节点为根节点的子树中的个数
        private int N;

        public Node(Key key,Value val,int N)
        {
            this.key=key;
            this.val=val;
            this.N=N;
        }
    }
    private Node root;

    private int size(Node x)
    {
        if(x==null) return 0;
        else return x.N;
    }

    public int size()
    {
        return size(root);
    }

    //get方法
    public Value get(Key key)
    {
        return get(root,key);
    }
    private Value get(Node x,Key key)
    {
        //在以x为节点的字数中查找并返回key所对应的值
        //如果找不到则返回null
        if(x ==null) return null;
        int cmp =key.compareTo(x.key);
        if( cmp <0) return get(x.left,key);
        else if(cmp>0) return get(x.right,key);
        else return x.val;
    }

    //put 方法(插入方法）
    public void put(Key key,Value val)
    {
        //查找key，找到则更新它的值，否则它创建一个新的结点
        root =put(root,key,val);
    }
    private Node put(Node x,Key key,Value val)
    {
        //如果Key存在于以x为根节点的字数中则更新它的值
        //否则将以Key和val为键值对的新节点插入到该字树中
        if(x ==null) return new Node(key,val,1);
        int cmp=key.compareTo(x.key);
        if (cmp<0) x.left=put(x.left,key,val);
        else if (cmp>0) x.right=put(x.right,key,val);
        else x.val=val;
        x.N=size(x.left)+size(x.right)+1;
        return x;
    }


    //min（）方法 最小键方法
    public Key min()
    {
        return min(root).key;
    }
    private Node min(Node x)
    {
        //如果左子节点没有的话，那么最小元素就是根元素
        if(x.left==null) return x;
        return min(x.left);
    }

    //max() 最大键方法
    public Key max()
    {
        return max(root).key;
    }
    private Node max(Node x)
    {
        if(x.right ==null) return x;
        return max(x.right);
    }

    //select() 想找到排名第几的方法
/*
 * 如果排名是k的话，左子数的节点数t大于k，我们就在左边找
 * 左子数的节点数t等于K的话，那就是根节点
 * 如果左子数的节点数t小于k的话，那就需要在右子数去查找
 * 
 */

    public Key select(int k)
    {
        return select(root,k).key;
    }
    public Node select(Node x,int k)
    {
        if( x==null) return null;
        int t=size(x.left);
        if (t>k) return select(x.left,k);
        else if(t<k) return select(x.right,k-t-1);
        else return x;
    }


    //放回键的排名
    public int rank(Key key)
    {
        return rank(key,root);
    }
    private int rank(Key key,Node x)
    {
        //返回以x为根节点的子树中小于x.key的键的数量
        if(x ==null) return 0;
        int cmp=key.compareTo(x.key);
        if(cmp<0) return rank(key,x.left);
        else if(cmp>0) return 1+size(x.left)+rank(key,x.right);
        else           return size(x.left);


    }
}