帮我写一个红黑树

红黑树是一种自平衡的二叉搜索树，它在维护二叉搜索树的基础上，通过一些特定的规则来保证树的平衡性。这里给出一个简单的红黑树的实现：

class Node:
    def __init__(self, key, value):
        self.key = key
        self.value = value
        self.left = None
        self.right = None
        self.color = 1  # 红色为1，黑色为0


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

    def insert(self, key, value):
        node = Node(key, value)
        if self.root is None:
            self.root = node
            node.color = 0
        else:
            self._insert_helper(node, self.root)

    def _insert_helper(self, node, parent):
        if node.key < parent.key:
            if parent.left is None:
                parent.left = node
                node.parent = parent
            else:
                self._insert_helper(node, parent.left)
        else:
            if parent.right is None:
                parent.right = node
                node.parent = parent
            else:
                self._insert_helper(node, parent.right)
        self._balance(node)

    def _balance(self, node):
        while node.parent.color == 1:
            if node.parent == node.parent.parent.right:
                uncle = node.parent.parent.left
                if uncle is not None and uncle.color == 1:
                    node.parent.color = 0
                    uncle.color = 0
                    node.parent.parent.color = 1
                    node = node.parent.parent
                else:
                    if node == node.parent.left:
                        node = node.parent
                        self._right_rotate(node)
                    node.parent.color = 0
                    node.parent.parent.color = 1
                    self._left_rotate(node.parent.parent)
            else:
                uncle = node.parent.parent.right
                if uncle is not None and uncle.color == 1:
                    node.parent.color = 0
                    uncle.color = 0
                    node.parent.parent.color = 1
                    node = node.parent.parent
                else:
                    if node == node.parent.right:
                        node = node.parent
                        self._left_rotate(node)
                    node.parent.color = 0
                    node.parent.parent.color = 1
                    self._right_rotate(node.parent.parent)
            if node == self.root:
                break
        self.root.color = 0

    def _left_rotate(self, node):
        y = node.right
        node.right = y.left
        if y.left is not None:
            y.left.parent = node
        y.parent = node.parent
        if node.parent is None:
            self.root = y
        elif node == node.parent.left:
            node.parent.left = y
        else:
            node.parent.right = y
        y.left = node
        node.parent = y

    def _right_rotate(self, node):
        y = node.left
        node.left = y.right
        if y.right is not None:
            y.right.parent = node
        y.parent = node.parent
        if node.parent is None:
            self.root = y
        elif node == node.parent.right:
            node.parent.right = y
        else:
            node.parent.left = y
        y.right = node
        node.parent = y

    def search(self, key):
        return self._search_helper(self.root, key)

    def _search_helper(self, node, key):
        if node is None:
            return None
        elif node.key == key:
            return node.value
        elif node.key < key:
            return self._search_helper(node.right, key)
        else:
            return self._search_helper(node.left, key)

在这个实现中，我们用 `Node` 类来表示红黑树的节点，包含了键值对、左右子节点以及颜色（红色为1，黑色为0）信息。红黑树类 `RedBlackTree` 包含了插入、平衡和查找操作，其中 `_balance` 方法用于保持红黑树的平衡性。