删除超出指定范围的BST密钥

在二叉搜索树中，我们可以通过比较节点值大小来决定要前往左子树还是右子树进行搜索或插入操作。这也就是二叉搜索树的基本性质。在某些情况下，我们可能需要删除超出指定范围的节点，以减少树的大小，提高树搜索的效率。在本文中，我们将介绍如何实现删除超出指定范围的BST密钥。

算法流程

1. 初始化空节点 root

2. 对于每个密钥 key:

   a. 如果 key 大于等于下界 low，小于等于上界 high，则将其插入到 root 中。

   b. 如果 key 小于 low，则递归地将其插入 root 的左子树中。

   c. 如果 key 大于 high，则递归地将其插入 root 的右子树中。

3. 删除超出指定范围的节点。

   a. 如果节点的值小于下界 low，则将其删除，并删除左子树中所有小于 low 的节点。

   b. 如果节点的值大于上界 high，则将其删除，并删除右子树中所有大于 high 的节点。

4. 返回更新后的 root。

代码实现

Java 代码

class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;

    public TreeNode(int val) {
        this.val = val;
        this.left = null;
        this.right = null;
    }
}

class Solution {
    public TreeNode trimBST(TreeNode root, int low, int high) {
        if (root == null) {
            return null;
        }

        // 处理根节点
        if (root.val >= low && root.val <= high) {
            root.left = trimBST(root.left, low, high);
            root.right = trimBST(root.right, low, high);
            return root;
        }

        // 处理左子树
        if (root.val < low) {
            return trimBST(root.right, low, high);
        }

        // 处理右子树
        if (root.val > high) {
            return trimBST(root.left, low, high);
        }

        return null;
    }
}

Python 代码

class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

class Solution:
    def trimBST(self, root: TreeNode, low: int, high: int) -> TreeNode:
        if not root:
            return None

        # 处理根节点
        if low <= root.val <= high:
            root.left = self.trimBST(root.left, low, high)
            root.right = self.trimBST(root.right, low, high)
            return root

        # 处理左子树
        if root.val < low:
            return self.trimBST(root.right, low, high)

        # 处理右子树
        if root.val > high:
            return self.trimBST(root.left, low, high)

        return None

复杂度分析

在最坏情况下，我们需要遍历整棵树，因此时间复杂度为 O(n)，其中 n 是树的节点数。由于我们使用递归来实现算法，因此空间复杂度为 O(h)，其中 h 是树的高度。在最坏情况下，树可能退化为链表，此时 h=n，空间复杂度为 O(n)，而在平均情况下，树的高度为 logn，空间复杂度为 O(logn)。