偷懒方法

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;
    }
}

删除随意节点

删除随意节点的时候有三种情况能够考虑：

• 删除一个没有子节点的节点很easy了，仅仅要返回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复杂度。