二叉搜索树：效率至上的数据结构

2023-12-08 13:08:17

二叉搜索树的原理

二叉搜索树是一种二叉树，它满足以下性质：

每个节点最多有两个子节点，分别称为左子节点和右子节点。
左子节点上的值小于父节点上的值。
右子节点上的值大于父节点上的值。

这种性质使得二叉搜索树具有高效的查找、插入和删除操作。

二叉搜索树的实现

二叉搜索树的实现通常使用递归算法。以下是用Python实现的二叉搜索树的代码示例：

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

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

    def insert(self, val):
        new_node = Node(val)
        self._insert(new_node, self.root)

    def _insert(self, new_node, current_node):
        if current_node is None:
            self.root = new_node
        elif new_node.val < current_node.val:
            if current_node.left is None:
                current_node.left = new_node
            else:
                self._insert(new_node, current_node.left)
        else:
            if current_node.right is None:
                current_node.right = new_node
            else:
                self._insert(new_node, current_node.right)

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

    def _search(self, val, current_node):
        if current_node is None:
            return False
        elif current_node.val == val:
            return True
        elif val < current_node.val:
            return self._search(val, current_node.left)
        else:
            return self._search(val, current_node.right)

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

    def _delete(self, val, current_node):
        if current_node is None:
            return
        elif val < current_node.val:
            self._delete(val, current_node.left)
        elif val > current_node.val:
            self._delete(val, current_node.right)
        else:
            if current_node.left is None:
                current_node = current_node.right
            elif current_node.right is None:
                current_node = current_node.left
            else:
                min_node = self._min_node(current_node.right)
                current_node.val = min_node.val
                self._delete(min_node.val, current_node.right)

    def _min_node(self, current_node):
        while current_node.left is not None:
            current_node = current_node.left
        return current_node

    def print_tree(self):
        self._print_tree(self.root)

    def _print_tree(self, current_node):
        if current_node is None:
            return
        print(current_node.val)
        self._print_tree(current_node.left)
        self._print_tree(current_node.right)