门 | GATE CS 2013 |问题15

这是GATE计算机科学2013年的问题15，题目要求使用具有锁定功能的二叉查找树（BST）实现一个字典结构以支持以下操作：

• insert(x) - 向字典中插入x
• delete(x) - 从字典中删除x
• get_ith(i) - 返回第i个最小元素
• rank(x) - 返回x的排名（即在字典中出现的次序）

实现思路

我们需要利用二叉查找树的结构特性进行实现。具体来说，我们要在BST的每个节点上添加额外的计数器：

• 记录子树中节点的数量（size）
• 记录节点被访问的次数（count）

在插入、删除、查询等操作中，我们需要利用这些计数器进行相关的计算。

插入

插入一个元素时，首先进行BST的基本插入操作。然后，从插入点开始，递归更新每个节点的size计数器。

删除

删除一个元素时，首先进行BST的基本删除操作。然后，从删除点开始，递归更新每个节点的size和count计数器。

查询

查询第i个最小元素时，从根节点开始向下遍历：

• 如果左子树的size大于等于i，则在左子树中查询第i个最小元素
• 如果左子树的size加上本节点的count等于i，则返回本节点的键值
• 否则，在右子树中查询第i-(左子树的size+本节点的count)个最小元素

查询元素排名时，也是从根节点开始向下遍历：

• 如果x小于本节点的键值，则在左子树中查询x的排名rank(x)
• 如果x等于本节点的键值，则返回左子树的size+本节点的count
• 否则，在右子树中查询x的排名rank(x)+左子树的size+本节点的count

代码实现

以下是Python语言的代码实现（不包含输入输出部分），代码中的BSTNode类表示BST的一个节点，size和count为额外的计数器：

class BSTNode:
    def __init__(self, key):
        self.key = key
        self.left = None
        self.right = None
        self.size = 1
        self.count = 1

class BST:
    def __init__(self):
        self.root = None

    def size(self, node):
        return node.size if node else 0

    def count(self, node):
        return node.count if node else 0

    def insert(self, key):
        def _insert(node, key):
            if not node:
                return BSTNode(key)
            if key < node.key:
                node.left = _insert(node.left, key)
            elif key > node.key:
                node.right = _insert(node.right, key)
            else:
                node.count += 1
            node.size = self.size(node.left) + self.size(node.right) + node.count
            return node

        self.root = _insert(self.root, key)

    def delete(self, key):
        def _delete(node, key):
            if not node:
                return None
            if key < node.key:
                node.left = _delete(node.left, key)
            elif key > node.key:
                node.right = _delete(node.right, key)
            else:
                if node.count > 1:
                    node.count -= 1
                else:
                    if not node.left:
                        return node.right
                    if not node.right:
                        return node.left
                    t = node
                    node = self.get_min_node(t.right)
                    node.right = self.delete_min_node(t.right)
                    node.left = t.left
                    t = None
            node.size = self.size(node.left) + self.size(node.right) + node.count
            return node

        self.root = _delete(self.root, key)

    def get_min_node(self, node):
        while node.left:
            node = node.left
        return node

    def delete_min_node(self, node):
        if not node.left:
            return node.right
        node.left = self.delete_min_node(node.left)
        node.size = self.size(node.left) + self.size(node.right) + node.count
        return node

    def get_ith(self, i):
        def _get_ith(node, i):
            if not node:
                return None
            if self.size(node.left) >= i:
                return _get_ith(node.left, i)
            if self.size(node.left) + node.count == i:
                return node.key
            return _get_ith(node.right, i - self.size(node.left) - node.count)

        return _get_ith(self.root, i)

    def rank(self, key):
        def _rank(node, key):
            if not node:
                return 0
            if key < node.key:
                return _rank(node.left, key)
            elif key == node.key:
                return self.size(node.left) + node.count
            else:
                return self.size(node.left) + node.count + _rank(node.right, key)

        return _rank(self.root, key)

以上代码实现了插入、删除、查询第i个最小值、查询元素的排名操作。