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 or node.val == val:
            return node
        elif val < node.val:
            return self._search(val, node.left)
        else:
            return self._search(val, node.right)

    def delete(self, val):
        self._delete(val, self.root)

    def _delete(self, val, node):
        if not node:
            return node
        if 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:
                temp = node.right
                node = None
                return temp
            elif not node.right:
                temp = node.left
                node = None
                return temp
            temp = self._get_min_value(node.right)
            node.val = temp.val
            node.right = self._delete(temp.val, node.right)
        return node

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

    def inorder_traversal(self):
        traversal = []
        self._inorder_traversal(self.root, traversal)
        return traversal

    def _inorder_traversal(self, node, traversal):
        if node:
            self._inorder_traversal(node.left, traversal)
            traversal.append(node.val)
            self._inorder_traversal(node.right, traversal)

在上面的代码中，我们定义了一个`TreeNode`类来表示二叉树的节点，以及一个`BST`类来表示二叉搜索树。`BST`类具有以下方法：

- `__init__()`：构造函数，用于初始化根节点为`None`。
- `insert(val)`：插入一个值为`val`的节点到二叉搜索树中。
- `_insert(val, node)`：递归执行插入操作的辅助函数。
- `search(val)`：在二叉搜索树中查找值为`val`的节点。如果找到了，则返回该节点；否则返回`None`。
- `_search(val, node)`：递归执行查找操作的辅助函数。
- `delete(val)`：从二叉搜索树中删除值为`val`的节点。
- `_delete(val, node)`：递归执行删除操作的辅助函数。
- `_get_min_value(node)`：获取以`node`为根节点的子树中最小的节点。
- `inorder_traversal()`：对二叉搜索树进行中序遍历，返回遍历结果。
- `_inorder_traversal(node, traversal)`：递归执行中序遍历操作的辅助函数。

以上就是Python中实现二叉搜索树的代码。