二叉搜索树：一种更高效的数据结构

人工智能

2023-04-23 09:30:37

深入理解二叉搜索树：高效查找和检索的利器

什么是二叉搜索树？

想像一棵二叉树，其中每个节点都持有某个数据。现在，让我们给这棵树添加一个特殊规则：节点的值必须大于其左子树中所有节点的值，而小于其右子树中所有节点的值。这样，我们就得到了一棵二叉搜索树（BST）。

这棵树就像一本经过精心排列的字典，使查找和检索数据变得超级容易。我们可以通过比较节点的值，轻松确定要查找的元素是否位于树的左侧或右侧。

二叉搜索树的特性

BST 拥有以下一些关键特性：

每个节点最多有 0 个、1 个或 2 个子节点。
左子节点的值 < 父节点的值。
右子节点的值 > 父节点的值。
可以用来查找、插入和删除元素。
平均时间复杂度为 O(log n)，其中 n 是树中的节点数。

如何使用二叉搜索树

创建一个 BST 对象，然后使用 insert() 方法插入元素，使用 search() 方法查找元素，使用 delete() 方法删除元素。

代码示例：

class BSTNode:
    def __init__(self, value):
        self.value = value
        self.left = None
        self.right = None

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

    def insert(self, value):
        if self.root is None:
            self.root = BSTNode(value)
        else:
            self._insert(value, self.root)

    def _insert(self, value, node):
        if value < node.value:
            if node.left is None:
                node.left = BSTNode(value)
            else:
                self._insert(value, node.left)
        else:
            if node.right is None:
                node.right = BSTNode(value)
            else:
                self._insert(value, node.right)

    def search(self, value):
        if self.root is None:
            return None

        node = self.root
        while node is not None:
            if value == node.value:
                return node
            elif value < node.value:
                node = node.left
            else:
                node = node.right

        return None

    def delete(self, value):
        if self.root is None:
            return

        node = self.root
        prev = None
        while node is not None:
            if value == node.value:
                if prev is None:
                    self.root = self._delete(node)
                else:
                    if node == prev.left:
                        prev.left = self._delete(node)
                    else:
                        prev.right = self._delete(node)
                return

            elif value < node.value:
                prev = node
                node = node.left
            else:
                prev = node
                node = node.right

    def _delete(self, node):
        if node.left is None:
            return node.right

        if node.right is None:
            return node.left

        # 找到左子树的最大值，它将替代要删除的节点
        max_node = node.left
        prev = None
        while max_node.right is not None:
            prev = max_node
            max_node = max_node.right

        # 用最大值替换要删除的节点的值
        node.value = max_node.value

        # 删除最大值
        if prev is None:
            node.left = self._delete(max_node)
        else:
            prev.right = self._delete(max_node)

        return node