二叉查找树的java代码实现

package find;

import java.util.ArrayList;
import java.util.List;

public class BST<Key extends Comparable, Value> {
private class Node {
private Key key; // 键
private Value value;// 值
private Node left, right; // 指向子树的链接
private int n; // 以该节点为根的子树中的节点总数

    public Node(Key key, Value val, int n) {
        this.key = key;
        this.value = val;
        this.n = n;
    }
}

private Node root;

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

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

/**
 * 如果树是空的，则查找未命中 如果被查找的键小于根节点，则在左子树中继续查找 如果被查找的键大于根节点，则在右子树中继续查找
 * 如果被查找的键和根节点的键相等，查找命中
 * 
 * @param key
 * @return
 */
public Value get(Key key) {
    return get(root, key);
}

private Value 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.value;
}

/**
 * 二叉查找树的一个很重要的特性就是插入的实现难度和查找差不多。 
 * 当查找到一个不存在与树中的节点（null）时，new 新节点，并将上一路径指向该节点
 * 
 * @param key
 * @param val
 */
public void put(Key key, Value val) {
    root = put(root, key, val);
}

private Node put(Node x, Key key, Value 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.value = val;
    x.n = 1 + size(x.left) + size(x.right); // 要及时更新节点的子树数量
    return x;
}

public Key min() {
    return min(root).key;
}

private Node min(Node x) {
    if (x.left == null)
        return x;
    return min(x.left);
}

public Key max() {
    return max(root).key;
}

private Node max(Node x) {
    if (x.right == null)
        return x;
    return max(x.right);
}

/**
 * 向下取整：找出小于等于该键的最大键
 * 
 * @param key
 * @return
 */
public Key floor(Key key) {
    Node x = floor(root, key);
    if (x == null)
        return null;
    else
        return x.key;
}

/**
 * 如果给定的键key小于二叉查找树的根节点的键，那么小于等于key的最大键一定出现在根节点的左子树中
 * 如果给定的键key大于二叉查找树的根节点，那么只有当根节点右子树中存在大于等于key的节点时，
 * 小于等于key的最大键才会出现在右子树中，否则根节点就是小于等于key的最大键
 * 
 * @param x
 * @param key
 * @return
 */
private Node floor(Node x, Key key) {
    if (x == null)
        return null;
    int cmp = key.compareTo(x.key);
    if (cmp == 0)
        return x;
    else if (cmp < 0)
        return floor(x.left, key);
    else {
        Node t = floor(x.right, key);
        if (t == null)
            return x;
        else
            return t;
    }
}

/**
 * 向上取整：找出大于等于该键的最小键
 * 
 * @param key
 * @return
 */
public Key ceiling(Key key) {
    Node x = ceiling(root, key);
    if (x == null)
        return null;
    else
        return x.key;
}

/**
 * 如果给定的键key大于二叉查找树的根节点的键，那么大于等于key的最小键一定出现在根节点的右子树中
 * 如果给定的键key小于二叉查找树的根节点，那么只有当根节点左子树中存在大于等于key的节点时，
 * 大于等于key的最小键才会出现在左子树中，否则根节点就是大于等于key的最小键
 * 
 * @param x
 * @param key
 * @return
 */
private Node ceiling(Node x, Key key) {
    if (x == null)
        return null;
    int cmp = key.compareTo(x.key);
    if (cmp == 0)
        return x;
    else if (cmp > 0) {
        return ceiling(x.right, key);
    } else {
        Node t = floor(x.left, key);
        if (t == null)
            return x;
        else
            return t;
    }
}

/**
 * 选择排名为k的节点
 * 
 * @param k
 * @return
 */
public Key select(int k) {
    return select(root, k).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;
}

/**
 * 查找给定键值的排名
 * 
 * @param key
 * @return
 */
public int rank(Key key) {
    return rank(key, root);
}

private int rank(Key key, Node x) {
    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);
}
/**
 * 删除最小键值对
 */
public void deleteMin(){
    root = deleteMin(root);
}
/**
 * 不断深入根节点的左子树直到遇见一个空链接，然后将指向该节点的链接指向该结点的右子树
 * 此时已经没有任何链接指向要被删除的结点，因此它会被垃圾收集器清理掉
 * @param x
 * @return
 */
private Node deleteMin(Node x){
    if(x.left == null) return x.right;
    x.left = deleteMin(x.left);
    x.n = 1 + size(x.left)+size(x.right);
    return x;
}

public void deleteMax(){
    root = deleteMax(root);
}
private Node deleteMax(Node x){
    if(x.right == null ) return x.left;
    x.right = deleteMax(x.right);
    x.n = 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;
        /**
         * 如果被删除节点有两个子树，将被删除节点暂记为t
         * 从t的右子树中选取最小的节点x，将这个节点x的左子树设为t的左子树
         * 这个节点x的右子树设为t的右子树中删除了最小节点的子树，这样就成功替换了t的位置
         */
        Node t = x;
        x = min(t.right);
        x.right = deleteMin(t.right);
        x.left = t.left;
    }
    x.n = size(x.left) + size(x.right) +1;
    return x;
}

public String toString(){
    StringBuilder sb = new StringBuilder();
    toString(root,sb);
    sb.deleteCharAt(sb.length()-1);
    return sb.toString();
}
private void toString(Node x, StringBuilder sb){
    if(x == null ) return;
    toString(x.left,sb);
    sb.append("<"+x.key+","+x.value+">,");
    toString(x.right,sb);
}

public List<Key> keys(){
    return keys(min(),max());
}
public List<Key> keys(Key lo, Key hi){
    List<Key> list = new ArrayList<Key>();
    keys(root, list, lo, hi);
    return list;
}
private void keys(Node x, List<Key> list, Key lo, Key hi){
    if(x == null) return;
    int cmplo = lo.compareTo(x.key);
    int cmphi = hi.compareTo(x.key);
    if(cmplo < 0 ) keys(x.left,list,lo,hi);
    if(cmplo <= 0 && cmphi >= 0) list.add(x.key);
    if(cmphi > 0 ) keys(x.right,list,lo,hi);
}
public static void main(String[] args){
    BST<Integer,String> bst = new BST<Integer,String>();
    bst.put(5, "e");
    bst.put(1, "a");
    bst.put(4, "d");
    bst.put(9, "i");
    bst.put(10, "j");
    bst.put(2, "b");
    bst.put(7, "g");
    bst.put(3, "c");
    bst.put(8, "h");
    bst.put(6, "f");        
    List<Integer> keys = bst.keys();
    for(int key : keys){
        System.out.print("<"+key+","+bst.get(key)+">,");
    }
    System.out.println();
    bst.deleteMin();
    System.out.println(bst.toString());
    bst.deleteMax();
    System.out.println(bst.toString());
    bst.delete(7);
    System.out.println(bst.toString());
}

}