数据结构：二叉搜索树

二叉搜索树（Binary Search Tree，简称 BST）是一种基于二分查找算法的数据结构。它的每个节点最多有两个子节点，分别称为左子节点和右子节点。左子节点的值小于右子节点，且左子树和右子树都是二叉搜索树。

Binary Search Tree

特点

• 二叉搜索树中的每个节点都大于其左子树中的节点，小于其右子树中的节点。
• 二叉搜索树的查找、插入和删除操作的时间复杂度均为 O(log n)，其中 n 是树中节点数。

实现

我们可以使用 Python 语言中的类来实现二叉搜索树。每个节点都有一个值和两个指针（指向左右子节点）。

class Node:
    def __init__(self, value):
        self.value = value
        self.left_child = None
        self.right_child = None

然后，我们可以定义一个 BST 类来实现一些基本操作，如插入、查找和删除。首先，我们来实现插入操作。

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

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

    def _insert(self, current_node, value):
        if value < current_node.value:
            if current_node.left_child is None:
                current_node.left_child = Node(value)
            else:
                self._insert(current_node.left_child, value)
        else:
            if current_node.right_child is None:
                current_node.right_child = Node(value)
            else:
                self._insert(current_node.right_child, value)

这里的 insert 方法是一个对外的接口，它用于向树中插入一个节点。如果当前树为空，则将根节点赋值为待插入节点；如果树非空，则递归地在树中寻找可以插入节点的位置。

接下来，我们实现查找操作。

class BST:
    # ...

    def find(self, value):
        if self.root is None:
            return False
        else:
            return self._find(self.root, value)

    def _find(self, current_node, value):
        if current_node is None:
            return False
        elif current_node.value == value:
            return True
        elif value < current_node.value:
            return self._find(current_node.left_child, value)
        else:
            return self._find(current_node.right_child, value)

这里的 find 方法同样是一个对外的接口，它在树中查找是否存在某个值。在 _find 方法中，如果找到了对应的节点，则返回 True；如果没有找到，则返回 False。

最后，我们实现删除操作。

class BST:
    # ...

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

    def _delete(self, current_node, value):
        if current_node is None:
            return False
        elif current_node.value == value:
            if current_node.left_child is None and current_node.right_child is None:
                current_node = None
            elif current_node.left_child is None:
                current_node = current_node.right_child
            elif current_node.right_child is None:
                current_node = current_node.left_child
            else:
                temp_node = self._find_min(current_node.right_child)
                current_node.value = temp_node.value
                current_node.right_child = self._delete(current_node.right_child, temp_node.value)
            return True
        elif value < current_node.value:
            current_node.left_child = self._delete(current_node.left_child, value)
        else:
            current_node.right_child = self._delete(current_node.right_child, value)

    def _find_min(self, current_node):
        while current_node.left_child is not None:
            current_node = current_node.left_child
        return current_node

这里的 delete 方法同样是一个对外的接口，它用于在树中删除某个值对应的节点。在这个方法中，我们需要考虑各种不同情况下的删除方式：

• 如果待删除节点没有子节点，直接删除即可；
• 如果待删除节点只有一个子节点，将其子节点上移即可；
• 如果待删除节点有两个子节点，则将其右子树中最小的节点移到待删除节点的位置，并删除原位置的节点。

最后，我们实现一个用于打印树形结构的方法。

class BST:
    # ...

    def print_tree(self):
        if self.root is not None:
            self._print_tree(self.root)

    def _print_tree(self, current_node):
        if current_node is not None:
            self._print_tree(current_node.left_child)
            print(str(current_node.value))
            self._print_tree(current_node.right_child)

总结

二叉搜索树是一种高效地数据结构，在实际的开发中经常被使用。它具有以下主要特点：

• 每个节点最多有两个子节点；
• 左子节点的值小于右子节点，并且左子树和右子树都是二叉搜索树；
• 查找、插入和删除操作的时间复杂度为 O(log n)。

在 Python 中，我们可以用类和递归来实现二叉搜索树。同时，我们还需要考虑如何处理各种不同情况下的插入、查找和删除操作，这需要一定的思考和实践。