二进制搜索树Python，实现删除

我试图在python中实现一个二进制搜索树，但找不到删除的解决方案。如果项目位于叶中，这很简单，但是如果我要删除的项目有两个子项，并且还有其他子项，那么该怎么办？如何才能在找到它的继任者后，让我来取代它？有简单的递归解决方案吗

class Node:

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


class BinarySearchTree:


    def __init__(self, root=None):
        self.root = Node(root)


    def add(self, data, node):

        if node == None:
            node = Node(data)
            return True

        if data < node.data:
            if node.left == None:
                node.left = Node(data)
                return True
            else:
                self.add(data, node.left)
        elif data > node.data:
            if node.right == None:
                node.right = Node(data)
                return True
            else:
                self.add(data, node.right)


    def preorder(self, node):
        if node != None:
            print(node.data)
            self.preorder(node.left)
            self.preorder(node.right)

    def inorder(self, node):
        if node != None:
            self.inorder(node.left)
            print(node.data)
            self.inorder(node.right)

    def postorder(self, node):
        if node != None:
            self.postorder(node.left)
            self.postorder(node.right)
            print(node.data)


    def retreive(self,item):

        node = self.root

        while node != None:
            if node.data == item:
                break
            elif item < node.data:
                if node.left != None:
                    if node.left.data == item:
                        node.left = None
                        return True
                node = node.left
            else:
                if node.right != None:
                    if node.right.data == item:
                        node.right= None
                        return True
                node = node.right

        if node == None:                
            return False

tree = BinarySearchTree()
root=Node(3)
tree.add(55,root)
tree.add(5,root)
tree.add(13,root)
tree.add(2,root)
tree.add(3,root)
tree.preorder(root)
tree.postorder(root)
tree.inorder(root)

类节点：
定义初始化（self，data=None，left=None，right=None）：
self.data=数据
self.left=左
self.right=right
类二进制搜索树：
定义初始化（self，root=None）：
self.root=节点（根）
def添加（自身、数据、节点）：
如果节点==无：
节点=节点（数据）
返回真值
如果数据<节点数据：
如果node.left==无：
node.left=节点（数据）
返回真值
其他：
添加（数据，节点，左）
elif data>node.data：
如果node.right==无：
node.right=节点（数据）
返回真值
其他：
添加（数据，节点。右侧）
def预订单（自身、节点）：
如果节点！=无：
打印（节点数据）
self.preorder（节点左）
self.preorder（node.right）
def索引器（自身，节点）：
如果节点！=无：
self.inoder（node.left）
打印（节点数据）
self.inoder（node.right）
def后订单（自身、节点）：
如果节点！=无：
self.postorder（节点左）
self.postorder（node.right）
打印（节点数据）
def回收（自身，项目）：
node=self.root
while节点！=无：
如果node.data==项：
打破
elif项

---

另外，如果你对我目前写的东西有任何建议，我将非常感谢。提前谢谢

如果这不是家庭作业，您可以使用以下方法之一：

两者都实现删除。两者都能很好地处理已排序或未排序的输入

红黑树模块有一个RedBlackTree继承自的BinaryTree类。

对这里使用的方法有很好的解释。