首页 > 脚本专栏 > python > python实现二叉搜索树算法

python如何实现二叉搜索树算法

2024-10-21 09:14:49 作者：luthane

二叉搜索树（BST）是一种数据结构,用于动态集合操作如搜索、插入、删除等,每个节点的左子树包含小于节点值的所有项,右子树包含大于节点值的所有项,通过中序遍历可得升序序列,插入、搜索和删除都从根节点开始,根据值的大小移动到左或右子树

二叉搜索树算法介绍

二叉搜索树（Binary Search Tree，简称BST）是一种常见的数据结构，它支持一系列的动态集合操作，包括搜索、插入、删除和遍历等。

在二叉搜索树中，对于树中的每个节点X，其左子树中的所有项的值都小于X中的项，而其右子树中的所有项的值都大于X中的项。

1. 二叉搜索树的性质

唯一根节点：非空二叉搜索树有一个根节点。
左子树：对于树中的每个节点X，其左子树中的所有项的值都小于X中的项。
右子树：对于树中的每个节点X，其右子树中的所有项的值都大于X中的项。
中序遍历：对二叉搜索树进行中序遍历（左-根-右）可以得到一个按升序排列的节点值的序列。

2. 基本操作

插入

从根节点开始。
如果要插入的值小于当前节点的值，移动到左子树。
如果要插入的值大于当前节点的值，移动到右子树。
重复步骤2和3，直到找到一个空位置插入新节点。

搜索

从根节点开始。
如果要搜索的值小于当前节点的值，移动到左子树。
如果要搜索的值大于当前节点的值，移动到右子树。
重复步骤2和3，直到找到值相等或到达叶子节点（无子节点）。

删除

删除操作稍微复杂一些，因为它需要处理三种情况：

要删除的节点是叶子节点：直接删除该节点，并修改其父节点的链接。
要删除的节点有一个子节点：用其子节点替换该节点，并修改其父节点的链接。
要删除的节点有两个子节点：找到该节点的右子树中的最小节点（或左子树中的最大节点），用该节点的值替换要删除的节点的值，并删除右子树中的最小节点（或左子树中的最大节点）。

3. 示例代码（Python）

这里仅提供一个非常基本的插入和搜索的示例代码：

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

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

    def insert(self, key):
        if self.root is None:
            self.root = TreeNode(key)
        else:
            self._insert_rec(self.root, key)

    def _insert_rec(self, root, key):
        if key < root.val:
            if root.left is None:
                root.left = TreeNode(key)
            else:
                self._insert_rec(root.left, key)
        elif key > root.val:
            if root.right is None:
                root.right = TreeNode(key)
            else:
                self._insert_rec(root.right, key)

    def search(self, key):
        return self._search_rec(self.root, key)

    def _search_rec(self, root, key):
        if root is None or root.val == key:
            return root is not None
        if key < root.val:
            return self._search_rec(root.left, key)
        return self._search_rec(root.right, key)

# 使用示例
bst = BinarySearchTree()
bst.insert(50)
bst.insert(30)
bst.insert(20)
bst.insert(40)
bst.insert(70)
bst.insert(60)
bst.insert(80)

print(bst.search(40))  # 输出: True
print(bst.search(25))  # 输出: False

请注意：

这个示例代码只实现了插入和搜索功能，并没有实现删除操作。
删除操作需要更多的逻辑来处理不同的情况。

二叉搜索树算法python实现样例

下面是一个简单的 Python 实现二叉搜索树的算法：

# 定义二叉搜索树的节点
class Node:
    def __init__(self, value):
        self.value = value
        self.left = None
        self.right = None

# 定义二叉搜索树
class BinarySearchTree:
    def __init__(self):
        self.root = None

    # 插入节点
    def insert(self, value):
        if self.root is None:
            self.root = Node(value)
        else:
            self._insert_recursive(self.root, value)

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

    # 查找节点
    def find(self, value):
        return self._find_recursive(self.root, value)

    def _find_recursive(self, node, value):
        if node is None or node.value == value:
            return node
        if value < node.value:
            return self._find_recursive(node.left, value)
        return self._find_recursive(node.right, value)

    # 删除节点
    def delete(self, value):
        self.root = self._delete_recursive(self.root, value)

    def _delete_recursive(self, node, value):
        if node is None:
            return node
        if value < node.value:
            node.left = self._delete_recursive(node.left, value)
        elif value > node.value:
            node.right = self._delete_recursive(node.right, value)
        else:
            # 找到要删除的节点
            if node.left is None:
                return node.right
            elif node.right is None:
                return node.left
            else:
                # 找到右子树中的最小节点，替换当前节点
                min_node = self._find_min(node.right)
                node.value = min_node.value
                node.right = self._delete_recursive(node.right, min_node.value)
        return node

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

    # 中序遍历
    def inorder_traversal(self):
        self._inorder_traversal_recursive(self.root)

    def _inorder_traversal_recursive(self, node):
        if node is not None:
            self._inorder_traversal_recursive(node.left)
            print(node.value, end=" ")
            self._inorder_traversal_recursive(node.right)

使用方法：

bst = BinarySearchTree()
bst.insert(8)
bst.insert(3)
bst.insert(10)
bst.insert(1)
bst.insert(6)
bst.insert(14)
bst.insert(4)
bst.insert(7)
bst.insert(13)

bst.inorder_traversal()  # 输出：1 3 4 6 7 8 10 13 14

bst.delete(8)
bst.inorder_traversal()  # 输出：1 3 4 6 7 10 13 14

node = bst.find(6)
print(node.value)  # 输出：6

这是一个基本的二叉搜索树算法实现，包括插入、查找、删除和中序遍历操作。你可以根据需要进一步扩展和优化这个实现。

总结

以上为个人经验，希望能给大家一个参考，也希望大家多多支持脚本之家。