写个二叉排序树

二叉排序树（Binary Search Tree，BST）是一种二叉树，其中每个节点的值都大于其左子树中的任何值，小于其右子树中的任何值。

以下是一个简单的二叉排序树的实现：

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

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 node.left:
                self._insert(val, node.left)
            else:
                node.left = TreeNode(val)
        else:
            if node.right:
                self._insert(val, node.right)
            else:
                node.right = TreeNode(val)

    def search(self, val):
        return self._search(val, self.root)

    def _search(self, val, node):
        if not node:
            return False
        elif val == node.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 node
        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 and not node.right:
                node = None
            elif not node.left:
                node = node.right
            elif not node.right:
                node = node.left
            else:
                min_node = self._find_min(node.right)
                node.val = min_node.val
                node.right = self._delete(min_node.val, node.right)
        return node

    def _find_min(self, node):
        while node.left:
            node = node.left
        return node

这个实现包括了插入、搜索和删除操作。其中插入和搜索操作都是基于递归实现的，而删除操作则需要一些特殊的处理