偷懒方法

public void delete(Key key) {
    insert(key, null);
}

这种方法就是将key对应的值覆盖成null，当读取该键值的时候将会返回null。

这是一种偷懒的办法，但是在严肃的实际应用中肯定不能这样，一方面会造成内存浪费，另一方面性能会越来越慢。

正规方法

先从简单的问题开始吧，如何删掉BST中最小的键呢？

先找到最小的键，然后将右子节点挂在父节点上。

代码：

public void deleteMin() {
    root = deleteMin(root);
}
 
private Node deleteMin(Node node) {
    if(node.left != null) {
        node.left = deleteMin(node.left);
        node.count -= 1;
        return node;
    } else {
        return node.right;
    }
}

删除任意节点

删除任意节点的时候有三种情况可以考虑：

• 删除一个没有子节点的节点非常简单了，只要返回null即可

• 删除一个只有一个子节点的节点需要返回它唯一的一个子节点

• 最难的问题在于删除一个有两个子节点的节点。这时候就要将右子树中最小的节点分离出来，放在该节点原本的位置。这就是Hibbard删除法。

但是Hibbard删除法在使用一段时间后发现，整个树变得越来越不平衡。因此Hibbard删除法的平均复杂度是sqrtN。有人提出删除的时候随机取出左侧或右侧的继承节点。

代码：

public void delete(Key key) {
    root = delete(root, key);
}
 
private Node delete(Node node, Key key) {
    // 先定位到需要删除的点
    if(node == null) return null;
    int compare = key.compareTo(node.key);
    if(compare < 0) {
        node.left = delete(node.left, key);
        updateCount(node);
        return node;
    } else if(compare > 0) {
        node.right = delete(node.right, key);
        updateCount(node);
        return node;
    }
 
    // 已定位到对应的节点，开始删除。以下是没有子节点或只有1个子节点的情况
    if(node.left == null) return node.right;
    if(node.right == null) return node.left;
 
    // 有两个子节点时，采用Hibbard删除法，取出右侧最小的节点取代被删除的节点
    Node minNode = minNode(node.right);
    node.right = deleteMin(node.right);
    minNode.left = node.left;
    minNode.right = node.right;
    updateCount(minNode);
    return minNode;
}
 
private void updateCount(Node node) {
    node.count = 1+size(node.left)+size(node.right);
}
 
private Node minNode(Node root) {
    if(root == null) return null;
 
    Node node = root;
    while(node.left != null) {
        node = node.left;
    }
    return node;
}

后续章节将会介绍红黑树，它能保证所有的操作都能保证logN复杂度。