对二叉平衡树进行四种操作： 1 D K 表示插入一个新数据，数据为D用于输出，关键值为K用于排序； 2 输出当前树中最大关键值所带的数据，并删除该数据，如果没有这个关键值，则输出0； 3 输出当前树中最小关键值所带的数据，并删除该数据，如果没有这个关键值，则输出0； 4 K 输出关键值为 K 的数据，并删除该数据，如果没有这个关键值，则输出0。 要求必须实现平衡树，不可以使用各类库函数

好的，我了解你的要求。这是一个经典的平衡树问题，可以使用 AVL 树实现。AVL树是一种自平衡的二叉搜索树，它的每个节点都满足平衡因子的绝对值不超过1。为了实现这个问题，我们需要在每个节点上记录数据和关键值，同时还需要维护平衡因子。以下是基本的 AVL 树实现：

class Node:
    def __init__(self, data, key):
        self.left = None
        self.right = None
        self.data = data
        self.key = key
        self.height = 1

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

    def insert(self, data, key):
        self.root = self._insert(self.root, data, key)

    def _insert(self, node, data, key):
        if not node:
            return Node(data, key)
        elif key < node.key:
            node.left = self._insert(node.left, data, key)
        else:
            node.right = self._insert(node.right, data, key)

        # 更新节点高度
        node.height = 1 + max(self.get_height(node.left), self.get_height(node.right))

        # 计算平衡因子
        balance = self.get_balance(node)

        # 如果不平衡，进行旋转
        if balance > 1 and key < node.left.key:
            return self.right_rotate(node)

        if balance < -1 and key > node.right.key:
            return self.left_rotate(node)

        if balance > 1 and key > node.left.key:
            node.left = self.left_rotate(node.left)
            return self.right_rotate(node)

        if balance < -1 and key < node.right.key:
            node.right = self.right_rotate(node.right)
            return self.left_rotate(node)

        return node

    def delete(self, key):
        self.root = self._delete(self.root, key)

    def _delete(self, node, key):
        if not node:
            return node
        elif key < node.key:
            node.left = self._delete(node.left, key)
        elif key > node.key:
            node.right = self._delete(node.right, key)
        else:
            # 找到要删除的节点
            if not node.left and not node.right:
                node = None
            elif node.left and not node.right:
                node = node.left
            elif not node.left and node.right:
                node = node.right
            else:
                min_node = self.get_min(node.right)
                node.key = min_node.key
                node.data = min_node.data
                node.right = self._delete(node.right, min_node.key)

        if not node:
            return node

        # 更新节点高度
        node.height = 1 + max(self.get_height(node.left), self.get_height(node.right))

        # 计算平衡因子
        balance = self.get_balance(node)

        # 如果不平衡，进行旋转
        if balance > 1 and self.get_balance(node.left) >= 0:
            return self.right_rotate(node)

        if balance < -1 and self.get_balance(node.right) <= 0:
            return self.left_rotate(node)

        if balance > 1 and self.get_balance(node.left) < 0:
            node.left = self.left_rotate(node.left)
            return self.right_rotate(node)

        if balance < -1 and self.get_balance(node.right) > 0:
            node.right = self.right_rotate(node.right)
            return self.left_rotate(node)

        return node

    def get_max(self, node):
        if not node:
            return None
        elif not node.right:
            return node
        else:
            return self.get_max(node.right)

    def get_min(self, node):
        if not node:
            return None
        elif not node.left:
            return node
        else:
            return self.get_min(node.left)

    def get_height(self, node):
        if not node:
            return 0
        else:
            return node.height

    def get_balance(self, node):
        if not node:
            return 0
        else:
            return self.get_height(node.left) - self.get_height(node.right)

    def left_rotate(self, node):
        new_root = node.right
        node.right = new_root.left
        new_root.left = node

        # 更新节点高度
        node.height = 1 + max(self.get_height(node.left), self.get_height(node.right))
        new_root.height = 1 + max(self.get_height(new_root.left), self.get_height(new_root.right))

        return new_root

    def right_rotate(self, node):
        new_root = node.left
        node.left = new_root.right
        new_root.right = node

        # 更新节点高度
        node.height = 1 + max(self.get_height(node.left), self.get_height(node.right))
        new_root.height = 1 + max(self.get_height(new_root.left), self.get_height(new_root.right))

        return new_root

    def search(self, key):
        node = self._search(self.root, key)
        if not node:
            return 0
        else:
            data = node.data
            self.root = self._delete(self.root, key)
            return data

    def _search(self, node, key):
        if not node:
            return None
        elif key < node.key:
            return self._search(node.left, key)
        elif key > node.key:
            return self._search(node.right, key)
        else:
            return node

其中，insert 方法用于插入数据，delete 方法用于删除数据，search 方法用于搜索并删除数据，get_max 和 get_min 方法用于查找最大和最小值。这里假设关键值是唯一的，如果不唯一，可以在节点上使用一个列表来存储多个数据。你可以在代码中添加你需要的操作。

例如，如果你想要实现一个可以接收用户输入的程序，可以按照如下方式编写：

tree = AVLTree()

while True:
    command = input()
    params = command.split()

    if params[0] == '1':
        tree.insert(params[1], int(params[2]))
        print(params[1])
    elif params[0] == '2':
        node = tree.get_max(tree.root)
        if node:
            print(node.data)
            tree.delete(node.key)
        else:
            print(0)
    elif params[0] == '3':
        node = tree.get_min(tree.root)
        if node:
            print(node.data)
            tree.delete(node.key)
        else:
            print(0)
    elif params[0] == '4':
        data = tree.search(int(params[1]))
        print(data)
    else:
        break

这里我们使用输入的方式来模拟用户对平衡树的操作。对于每个命令，我们都解析出对应的参数，并调用相应的方法执行操作。