Java实现二叉搜索树

Java实现二叉搜索树

具体细节不再介绍，原理以及性能分析直接参见《算法》，个人感觉精髓之处在于递归返回过程中向上更新结点的步骤。打个比方，要删除一个结点，发现要删的结点小于当前结点，于是需要进入当前结点左子树进行递归删除，删除结束则返回一个新的左子树给当前结点，在修正该结点的子树结点数。

代码如下：

package main;


public class BSTree<Key extends Comparable<Key>,Value extends Comparable<Value>>{
    private class Node {
        private Key key;
        private Value value;
        private Node left;
        private Node right;
        private Integer N;
        public Node(Key key,Value value,Integer N) {
            this.key = key;
            this.value = value;
            this.N = N;
        }
    }

    private Node root;

    public Key getroot() {
        if(root==null) return null;
        else return root.key;
    }

    public Integer size(Node x) {
        if(x==null) return 0;
        else return x.N;
    }
    public Value get(Key key) {
        return get(root, key);
    }
    public Value get(Node x,Key key) {
        if(x==null) return null;
        int temp = key.compareTo(x.key);
        if(temp<0) return get(x.left, key);
        else if(temp>0) return get(x.right, key);
        else return x.value;
    }

    public void put(Key key,Value value) {
        root = put(root, key, value);
    }
    public Node put(Node x,Key key,Value value) {
        if(x==null) return new Node(key,value,1);
        int temp = key.compareTo(x.key);
        if(temp<0) x.left = put(x.left, key, value);
        else if(temp>0) x.right = put(x.right, key, value);
        else x.value = value;
        x.N = size(x.left) + size(x.right) + 1;
        return x;
    }

    public Key select(Integer k) {
        if(select(root, k) == null)
            return null;
        else
            return select(root, k).key;
    }
    public Node select(Node x,Integer 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 Integer rank(Key key) {
        return rank(root, key);
    }
    public Integer rank(Node x,Key key) {
        if(x==null) return 0;
        int temp = key.compareTo(x.key);
        if(temp<0) return rank(x.left,key);
        else if(temp>0) return size(x.left)+1+rank(x.right, key);
        else return size(x.left);
    }
    public Node min(Node x) {
        if(x.left == null) return x;
        else return min(x.left);
    }
    public Node deleteMin(Node x) {
        if(x.left==null) return x.right;
        x.left = deleteMin(x.left);
        x.N = size(x.left) + size(x.right) + 1;
        return x;
    }

    public void delete(Key key) {
        root = delete(root, key);
    }
    public Node delete(Node x,Key key) {
        if(x==null) return null;
        int temp = key.compareTo(x.key);
        if(temp<0) x.left = delete(x.left, key);
        else if(temp>0) x.right = delete(x.right, key);
        else {
            if(x.left == null) return x.right;
            else if(x.right == null) return x.left;
            Node t = x;
            x = min(x.right);
            x.right = deleteMin(t.right);
            x.left = t.left;
        }
        x.N = size(x.left) + size(x.right) + 1;
        return x;
    }
}