二叉搜索树 python

二叉搜索树是一种有序的二叉树，其中每个节点的值都大于其左子树中任何节点的值，小于其右子树中任何节点的值。

以下是一个简单的二叉搜索树的 Python 实现：

class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

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

    def insert(self, val):
        """
        向二叉搜索树中插入一个节点
        """
        if not self.root:
            self.root = TreeNode(val)
        else:
            self._insert(val, self.root)

    def _insert(self, val, node):
        """
        递归插入节点
        """
        if val < node.val:
            if not node.left:
                node.left = TreeNode(val)
            else:
                self._insert(val, node.left)
        else:
            if not node.right:
                node.right = TreeNode(val)
            else:
                self._insert(val, node.right)

    def search(self, val):
        """
        在二叉搜索树中查找一个节点
        """
        return self._search(val, self.root)

    def _search(self, val, node):
        """
        递归查找节点
        """
        if not node:
            return False
        elif node.val == val:
            return True
        elif val < node.val:
            return self._search(val, node.left)
        else:
            return self._search(val, node.right)

    def delete(self, val):
        """
        在二叉搜索树中删除一个节点
        """
        self.root = self._delete(val, self.root)

    def _delete(self, val, node):
        """
        递归删除节点
        """
        if not node:
            return None
        elif val < node.val:
            node.left = self._delete(val, node.left)
        elif val > node.val:
            node.right = self._delete(val, node.right)
        else:
            if not node.left:
                return node.right
            elif not node.right:
                return node.left
            else:
                temp = self._find_min(node.right)
                node.val = temp.val
                node.right = self._delete(temp.val, node.right)
        return node

    def _find_min(self, node):
        """
        找到以给定节点为根的子树中的最小节点
        """
        while node.left:
            node = node.left
        return node

这个实现包含了插入、查找和删除操作。其中，插入和查找操作都是使用递归实现的，而删除操作则需要一些额外的处理，因为需要维护二叉搜索树的结构。