二叉搜索树 (java递归版)

public class BST<Key extends Comparable<Key>,Value> {
    private class Node
    {
        Node left = null;
        Node right = null;
        int count = 0;
        Key key;
        Value value;
        public Node(Key key,Value value,int n)
        {
            this.key = key;
            this.value = value;
            this.count = n;
        }
    }
    private Node root = null;
    public int size()
    {
        return size(root);
    }
    private int size(Node x)
    {
        if (x == null) return 0;
        else return x.count;
    }
    public void put(Key key,Value value)
    {
        root = put(root,key,value);
    }
    private Node put(Node x,Key key,Value value)
    {
        if (x == null)
            return new Node(key,value,1);
        int cmp = key.compareTo(x.key);
        if (cmp < 0)
            x.left = put(x.left,key,value);
        else if (cmp > 0)
            x.right = put(x.right,key,value);
        else
            x.value = value;
        x.count = size(x.left) + size(x.right) + 1;
        return x;
    }
    public Value get(Key key)
    {
        Node x;
        if ((x = get(root,key)) == null)
            return null;
        else
            return x.value; 
    }
    private Node get(Node x,Key key)
    {
        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;
    }
    public Key max()
    {
        if (root == null)
            return null;
        return max(root).key;
    }
    private Node max(Node x)
    {
        if (x.right == null)
            return x;
        return max(x.right);
    }
    public Key min()
    {
        if (root == null)
            return null;
        return min(root).key;
    }
    private Node min(Node x)
    {
        if (x.left == null)
            return x;
        return min(x.left);
    }
    public Key floor(Key key)
    {
        Node x;
        if ((x = floor(root,key)) == null)
            return null;
        else
            return x.key;
    }
    private Node floor(Node x,Key key)
    {
        if (x == null)
            return null;
        int cmp = key.compareTo(x.key);
        if (cmp == 0)
            return x;
        if (cmp < 0)
            return floor(x.left,key);
        Node t = floor(x.right,key);
        if (t != null)
            return t;
        else
            return x;
    }
    public Key ceiling(Key key)
    {
        Node x;
        if ((x = ceiling(root,key)) == null)
            return null;
        else
            return x.key;
    }
    public Node ceiling(Node x,Key key)
    {
        if (x == null)
            return null;
        int cmp = key.compareTo(x.key);
        if (cmp == 0)
            return x;
        if (cmp > 0)
            return ceiling(x.right,key);
        Node t = ceiling(x.left,key);
        if (t != null)
            return t;
        else
            return x;
    }
    public Key select(int k)
    {
        Node x;
        if ((x = select(root,k)) == null)
            return null;
        else
            return x.key;
    }
    private 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(root,key);
    }
    public int rank(Node x,Key key)
    {
        if (x == null)
            return 0;
        int cmp = key.compareTo(x.key);
        if (cmp < 0)
            return rank(x.right,key);
        else if (cmp > 0)
            return 1 + size(x.left) + rank(x.right,key);
        else
            return size(x.left);
    }
    public void deleteMin()
    {
        if (root == null)
            return;
        root = deleteMin(root);
    }
    private Node deleteMin(Node x)
    {
        if (x.left == null)
            return x.right;
        x.left = deleteMin(x.left);
        x.count = size(x.left) + size(x.right) + 1;
        return x;
    }
    public void deleteMax()
    {
        if (root == null)
            return;
        root = deleteMax(root);
    }
    private Node deleteMax(Node x)
    {
        if (x.right == null)
            return x.left;
        x.right = deleteMax(x.right);
        x.count = size(x.left) + size(x.right) + 1;
        return x;
    }
    public void delete(Key key)
    {
        root = delete(root,key);
    }
    private Node delete(Node x,Key key)
    {
        if (x == null)
            return null;
        int cmp = key.compareTo(x.key);
        if (cmp < 0)
            x.left = delete(x.left,key);
        else if (cmp > 0)
            x.right = delete(x.right,key);
        else
        {
            if (x.right == null) return x.left;
            if (x.left == null) return x.right;
            Node t = x;
            x = min(t.right);
            x.right = deleteMin(t.right);
            x.left = t.left;
        }
        x.count = size(x.left) + size(x.right) + 1;
        return x;
    }
}