递归实现二叉树的API设计

/**
 * 二叉查找树
 */
public class MyTree<Key extends Comparable<Key>, Value> {
    //根节点
    private MyNode root;

    //获取该数的总结点数量
    public int size() {
        return size(root);
    }

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

    //获取key处的值
    public Value get(Key key) {
        return get(root, key);
    }

    private Value get(MyNode x, Key key) {
        if (x == null)
            return null;

        int tmp = key.compareTo(x.key);

        if (tmp < 0)
            return get(x.left, key);
        else if (tmp > 0)
            return get(x.right, key);
        else
            return x.value;
    }

    //在指定键key处插入值value,若没有该键则创建新结点
    public void put(Key key, Value value) {
        root = put(root, key, value);
    }

    private MyNode put(MyNode x, Key key, Value value) {
        if (x == null)
            return new MyNode(key, value, 1);
        int tmp = key.compareTo(x.key);

        if (tmp < 0)
            x.left = put(x.left, key, value);
        else if
        (tmp > 0) x.right = put(x.right, key, value);
        else
            x.value = value;
        x.N = size(x.left) + size(x.right) + 1;
        return x;
    }

    //寻找最小键minKey
    public Key min() {
        return min(root).key;
    }

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

    //寻找最大键maxKey
    public Key max() {
        return max(root).key;
    }

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

    //向上取整
    public Key floor(Key key) {
        MyNode x = floor(root, key);
        if (x == null) return null;
        return x.key;
    }

    private MyNode floor(MyNode x, Key key) {
        if (x == null)
            return null;
        int tmp = key.compareTo(x.key);
        if (tmp == 0)
            return x;
        if (tmp < 0)
            return floor(x.left, key);
        MyNode tNode = floor(x.right, key);
        if (tNode != null)
            return tNode;
        else
            return x;
    }

    //向下取整
    public Key ceiling(Key key) {
        MyNode x = ceiling(root, key);
        if (x == null) return null;
        return x.key;
    }

    private MyNode ceiling(MyNode x, Key key) {
        if (x == null)
            return null;
        int tmp = key.compareTo(x.key);
        if (tmp == 0)
            return x;
        if (tmp > 0)
            return floor(x.right, key);
        MyNode tNode = floor(x.left, key);
        if (tNode != null)
            return tNode;
        else
            return x;
    }

    //构造select方法返回排名为k的结点的键key
    public Key select(int k) {
        return select(root, k).key;
    }

    private MyNode select(MyNode x, int k) {
        if (x == null)
            return null;
        int tmp = size(x.left);
        if (tmp > k)
            return select(x.left, k);
        if (tmp < k)
            return select(x.right, k);
        else return x;
    }

    //构造rank方法返回以为x根结点的子树的键key的数量
    public int rank(Key key) {
        return rank(key, root);
    }

    private int rank(Key key, MyNode x) {
        if (x == null)
            return 0;
        int tmp = key.compareTo(x.key);
        if (tmp < 0)
            return rank(key, x.left);
        else if (tmp > 0)
            return 1 + size(x.left) + rank(key, x.right);
        else
            return size(x.left);
    }

    /*
    删除操作
    */
    //删除最小键minKey
    public void deleteMin() {
        root = deleMin(root);
    }

    private MyNode deleMin(MyNode x) {
        if (x.left == null)
            return x.right;
        x.left = deleMin(x.left);
        x.N = size(x.left) + size(x.right) + 1;
        return x;
    }

    //删除最大键maxKey
    public void deleteMax() {
        root = deleteMax(root);
    }

    private MyNode deleteMax(MyNode x) {
        if (x.right == null)
            return x.left;
        x.right = deleteMax(x.right);
        x.N = size(x.right) + size(x.left) + 1;
        return x;
    }

    //删除指定键key
    public void delete(Key key) {
        root = delete(root, key);
    }

    private MyNode delete(MyNode x, Key key) {
        if (x == null)
            return null;
        int tmp = key.compareTo(x.key);
        if (tmp < 0)
            x.left = delete(x.left, key);
        else if (tmp > 0)
            x.right = delete(x.right, key);
        else {
            if (x.left == null)
                return x.right;
            if (x.right == null)
                return x.left;
            MyNode tNode = x;
            x = min(tNode.left);
            x.right = deleMin(tNode.right);
            x.left = tNode.left;
        }
        x.N = size(x.left) + size(x.right) + 1;
        return x;
    }


    //嵌套定义一个私有类来表示二叉查找树的结点
    //每个结点都含有一个键、一个值、一条左链、一条右链和一个结点计数器
    private class MyNode {
        private Key key;//键
        private Value value;//值
        private MyNode left, right;//指向子树的链接
        private int N;//以该结点为根的子树中的结点总数

        public MyNode(Key key, Value value, int N) {
            this.key = key;
            this.value = value;
            this.N = N;
        }
    }


}