门| GATE CS 1996 |问题1

这道题是1996年的计算机科学门考试（GATE）的问题1，涉及到程序设计和数据结构。问题如下：

给定一个正整数序列，维护以下操作：

• 插入一个数
• 删除所有指定的数
• 查询序列中最小的数

具体要求如下：

• 所有操作的时间复杂度为O(log n)，其中n是序列的长度
• 序列中的数互不相同

为了支持以上操作，我们需要使用一种数据结构来存储序列。本题最优的解决方案是使用二叉搜索树（Binary Search Tree，BST）。

二叉搜索树

二叉搜索树是一种二叉树，它满足以下性质：

• 左子树的所有节点的值小于根节点的值
• 右子树的所有节点的值大于根节点的值
• 左右子树都是二叉搜索树

因此，在二叉搜索树中：

• 查询最小值：从根节点开始，一直沿着左子树走即可
• 插入：从根节点开始，与要插入的值进行比较，如果大于根节点就继续遍历右子树，否则遍历左子树，直到遇到空节点后插入新节点即可
• 删除：需要分两种情况考虑。如果删除的节点没有子节点，直接删除即可。如果删除的节点有一个子节点，将其子节点与该节点所在的位置进行交换即可。如果删除的节点有两个子节点，则需要找到其右子树中最小的节点，将其值赋给该节点，并删除该最小节点。

代码实现

基于以上操作，我们可以实现一个类来实现给定的操作。下面是基于Python语言实现的代码片段：

class BSTNode:
    def __init__(self, value):
        self.value = value
        self.left = None
        self.right = None

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

    def insert(self, value):
        if not self.root:
            self.root = BSTNode(value)
        else:
            node = self.root
            while node:
                if value < node.value:
                    if not node.left:
                        node.left = BSTNode(value)
                        break
                    else:
                        node = node.left
                elif value > node.value:
                    if not node.right:
                        node.right = BSTNode(value)
                        break
                    else:
                        node = node.right

    def delete(self, value):
        node = self.root  # 待删除的节点
        parent = None    # 待删除节点的父节点
        is_left_child = False  # 待删除节点是否为父节点的左子节点

        while node:
            if value == node.value:
                if not node.left and not node.right:  # 待删除节点没有子节点
                    if not parent:  # 待删除节点是根节点
                        self.root = None
                    else:
                        if is_left_child:
                            parent.left = None
                        else:
                            parent.right = None
                elif node.left and not node.right:   # 待删除节点只有左子节点
                    if not parent:  # 待删除节点是根节点
                        self.root = node.left
                    else:
                        if is_left_child:
                            parent.left = node.left
                        else:
                            parent.right = node.left
                elif not node.left and node.right:  # 待删除节点只有右子节点
                    if not parent:  # 待删除节点是根节点
                        self.root = node.right
                    else:
                        if is_left_child:
                            parent.left = node.right
                        else:
                            parent.right = node.right
                else:   # 待删除节点有两个子节点
                    smallest_parent, smallest_node = node, node.right
                    while smallest_node.left:
                        smallest_parent, smallest_node = smallest_node, smallest_node.left

                    node.value = smallest_node.value
                    if smallest_parent.left == smallest_node:
                        smallest_parent.left = smallest_node.right
                    else:
                        smallest_parent.right = smallest_node.right
                break
            elif value < node.value:
                parent = node
                node = node.left
                is_left_child = True
            else:
                parent = node
                node = node.right
                is_left_child = False

    def find_min(self):
        node = self.root
        while node.left:
            node = node.left
        return node.value

以上就是本题的详细介绍和代码实现。