Python中二进制搜索树中的删除问题

我无法删除二进制搜索树的根。Rest所有的节点都可以删除，但是Root有一些问题，如果你能帮我做一些小的修改，那就太好了。我在一些网站上看到，它说以无开始root，然后开始添加数字，但即使这样也不起作用。 它表示不能添加非类型。 这是我的密码

class BST:
    def __init__(self, data):
        self.right = None
        self.left = None
        self.data = data

    def insert(self, root_insert, key):
        if root_insert is None:
            return BST(key)
        else:
            if root_insert.data == key:
                return root_insert
            elif root_insert.data < key:
                root_insert.right = self.insert(root_insert.right, key)
            else:
                root_insert.left = self.insert(root_insert.left, key)
        return root_insert

    def find_val(self, data):
        if data < self.data:
            if self.left is None:
                return str(data) + " Not Found"
            return self.left.find_val(data)
        elif data > self.data:
            if self.right is None:
                return str(data) + " Not Found"
            return self.right.find_val(data)
        else:
            return str(self.data) + " is Found"

    def inorder(self, root_inorder):
        if root_inorder:
            self.inorder(root_inorder.left)
            print(root_inorder.data, end=" ")
            self.inorder(root_inorder.right)

    def postOrder(self, root_postOrder):
        if root_postOrder:
            self.postOrder(root_postOrder.left)
            self.postOrder(root_postOrder.right)
            print(root_postOrder.data, end=" ")

    def preOrder(self, root_preOrder):
        if root_preOrder:
            print(root_preOrder.data, end=" ")
            self.preOrder(root_preOrder.left)
            self.preOrder(root_preOrder.right)

    def deleteNode(self, root_delete, data):
        if root_delete is None:
            return root_delete
        if data < root_delete.data:
            root_delete.left = self.deleteNode(root_delete.left, data)
        elif data > root_delete.data:
            root_delete.right = self.deleteNode(root_delete.right, data)
        else:
            if root_delete.left is None:
                temp = root_delete.right
                return temp

            elif root_delete.right is None:
                temp = root_delete.left
                return temp

            root_delete.data = self.min_value_node(root_delete.right)
            root_delete.right = self.deleteNode(root_delete.right, root_delete.data)
        return root_delete

    def min_value_node(self, node):
        current = node
        while current.left is not None:
            current = current.left
        return current


    root = BST(12)
    root = root.insert(root, 6)
    root = root.insert(root, 14)
    root = root.insert(root, 3)
    root = root.insert(root, 70)
    root = root.insert(root, 15)
    root = root.insert(root, 35)
    root = root.insert(root, 30)
    root = root.insert(root, 31)
    print("********IN ORDER********")
    root.inorder(root)
    print("\n********PRE ORDER********")
    root.preOrder(root)
    print("\n********POST ORDER********")
    root.postOrder(root)
    print("")
    print(root.find_val(7))
    print(root.find_val(14))
    root.deleteNode(root, 6)
    print("********IN ORDER********")
    root.inorder(root)
    root.deleteNode(root, 14)
    print("\n********IN ORDER********")
    root.inorder(root)
    root.deleteNode(root, 3)
    print("\n********IN ORDER********")
    root.inorder(root)
    root.deleteNode(root, 70)
    print("\n********IN ORDER********")
    root.inorder(root)
    root.deleteNode(root, 15)
    print("\n********IN ORDER********")
    root.inorder(root)
    root.deleteNode(root, 30)
    print("\n********IN ORDER********")
    root.inorder(root)
    
    root.deleteNode(root, 31)
    print("\n********IN ORDER********")
    root.inorder(root)
    root.deleteNode(root, 35)
    print("\n********IN ORDER********")
    root.inorder(root)
    root.deleteNode(root, 12)
    print("\n********IN ORDER********")
    root.inorder(root)
    
    root.deleteNode(root, 12)
    print("\n********IN ORDER********")
    root.inorder(root)

BST级：
定义初始化（自身，数据）：
self.right=无
self.left=无
self.data=数据
def插入（自身、根插入、键）：
如果root\u insert为None：
返回BST（键）
其他：
如果root_insert.data==键：
返回根插入
elif root_insert.data<键：
root\u insert.right=self.insert（root\u insert.right，键）
其他：
root\u insert.left=self.insert（root\u insert.left，键）
返回根插入
def查找值（自身、数据）：
如果数据自我数据：
如果self.right为无：
返回str（数据）+“未找到”
返回self.right.find_val（数据）
其他：
返回str（self.data）+“找到”
定义顺序（self，root\u顺序）：
如果根目录的顺序为：
self.inoorder（root\u inoorder.left）
打印（root_inoorder.data，end=”“）
self.inoorder（root\u inoorder.right）
def后序（自、根\后序）：
如果是根目录，则为后序：
self.posterorder（root\u posterorder.left）
self.posterorder（root\u posterorder.right）
打印（root_postOrder.data，end=”“）
def预订单（自、根\预订单）：
如果根_预排序：
打印（root_preOrder.data，end=”“）
self.preOrder（root\u preOrder.left）
self.preOrder（root\u preOrder.right）
def deleteNode（self、root_delete、data）：
如果root_delete为无：
返回root\u delete
如果数据root\u delete.data：
root\u delete.right=self.delete节点（root\u delete.right，数据）
其他：
如果root_delete.left为无：
temp=root\u delete.right
返回温度
elif root_delete.right为无：
temp=root\u delete.left
返回温度
root\u delete.data=self.min\u value\u节点（root\u delete.right）
root\u delete.right=self.delete节点（root\u delete.right，root\u delete.data）
返回root\u delete
def最小值节点（自身，节点）：
当前=节点
当current.left不是None时：
当前=当前。左
回流
根=BST（12）
root=root.insert（root，6）
root=root.insert（root，14）
root=root.insert（root，3）
根=根。插入（根，70）
root=root.insert（root，15）
root=root.insert（root，35）
root=root.insert（root，30）
root=root.insert（root，31）
打印（“*******按顺序*******”）
root.inoorder（root）
打印（“\n*******预订单*******”）
root.preOrder（root）
打印（“\n*******邮购*******”）
root.postOrder（root）
打印（“”）
打印（root.find_val（7））
打印（root.find_val（14））
root.deleteNode（root，6）
打印（“*******按顺序*******”）
root.inoorder（root）
root.deleteNode（root，14）
打印（“\n*******按顺序*******”）
root.inoorder（root）
root.deleteNode（根，3）
打印（“\n*******按顺序*******”）
root.inoorder（root）
root.deleteNode（root，70）
打印（“\n*******按顺序*******”）
root.inoorder（root）
root.deleteNode（root，15）
打印（“\n*******按顺序*******”）
root.inoorder（root）
root.deleteNode（root，30）
打印（“\n*******按顺序*******”）
root.inoorder（root）
root.deleteNode（root，31）
打印（“\n*******按顺序*******”）
root.inoorder（root）
root.deleteNode（root，35）
打印（“\n*******按顺序*******”）
root.inoorder（root）
root.deleteNode（root，12）
打印（“\n*******按顺序*******”）
root.inoorder（root）
root.deleteNode（root，12）
打印（“\n*******按顺序*******”）
root.inoorder（root）