Python实现二叉搜索树增删改查

已于 2023-08-10 09:24:14 修改
阅读量548 收藏 6
点赞数 2
分类专栏： python 算法 文章标签： 算法 python 数据结构 二叉搜索树
于 2023-08-10 09:20:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TaloyerG/article/details/132201861
版权

二叉搜索树，可以让你像搜索引擎一样快速地存储和检索数据。本文你将介绍二叉搜索树的基本概念和性质，以及如何用Python代码来实现它的基本操作和应用。

目录

引文 

一、定义节点类

二、定义二叉搜索树类

三、实现插入操作

四、实现查找操作

五、实现删除操作

六、实现遍历操作

七、实现其他操作

引文 

        二叉搜索树（Binary Search Tree，BST）是一种特殊的二叉树，它满足以下性质：

  • 每个节点的值都大于其左子树中的任何值，小于其右子树中的任何值。
  • 每个子树也是一个二叉搜索树。

        二叉搜索树有很多优点，例如：

  • 它可以快速地查找、插入和删除元素。
  • 它可以用来实现排序、范围查询、最大值和最小值等操作。
  • 它可以用来构建平衡树、红黑树等高效的数据结构。

        在本文中，我将介绍如何用Python语言实现一个简单的二叉搜索树，并展示它的基本操作和应用。

一、定义节点类

        要实现一个二叉搜索树，我们首先需要定义一个节点类，用来表示树中的每个元素。一个节点类包含以下属性：

  • value：节点的值，可以是任意类型。
  • left：节点的左子节点，如果没有则为None。
  • right：节点的右子节点，如果没有则为None。

        我们可以用以下代码定义一个节点类：

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

二、定义二叉搜索树类

        接下来，我们需要定义一个二叉搜索树类，用来表示整个树结构。一个二叉搜索树类包含以下属性：

  • root：树的根节点，如果为空则为None。

        我们可以用以下代码定义一个二叉搜索树类：

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

三、实现插入操作

要向二叉搜索树中插入一个元素，我们需要遵循以下步骤：

  • 如果树为空，则创建一个新节点作为根节点，并返回。
  • 如果树不为空，则从根节点开始，比较要插入的值和当前节点的值。
  • 如果要插入的值小于当前节点的值，则递归地在当前节点的左子树中插入。
  • 如果要插入的值大于当前节点的值，则递归地在当前节点的右子树中插入。
  • 如果要插入的值等于当前节点的值，则不做任何操作，并返回。

我们可以用以下代码实现插入操作：

def insert(self, value):
    # 创建一个新节点
    new_node = Node(value)
    # 如果树为空，则将新节点设为根节点
    if self.root is None:
        self.root = new_node
        return
    # 否则从根节点开始遍历
    current = self.root
    while True:
        # 如果要插入的值小于当前节点的值，则向左走
        if value < current.value:
            # 如果左子节点为空，则将新节点设为左子节点
            if current.left is None:
                current.left = new_node
                return
            # 否则继续向左走
            else:
                current = current.left
        # 如果要插入的值大于当前节点的值，则向右走
        elif value > current.value:
            # 如果右子节点为空，则将新节点设为右子节点
            if current.right is None:
                current.right = new_node
                return
            # 否则继续向右走
            else:
                current = current.right
        # 如果要插入的值等于当前节点的值，则不做任何操作，并返回
        else:
            return

四、实现查找操作

要在二叉搜索树中查找一个元素，我们需要遵循以下步骤：

  • 如果树为空，则返回False。
  • 如果树不为空，则从根节点开始，比较要查找的值和当前节点的值。
  • 如果要查找的值小于当前节点的值，则递归地在当前节点的左子树中查找。
  • 如果要查找的值大于当前节点的值，则递归地在当前节点的右子树中查找。
  • 如果要查找的值等于当前节点的值，则返回True。

我们可以用以下代码实现查找操作：

def search(self, value):
    # 如果树为空，则返回False
    if self.root is None:
        return False
    # 否则从根节点开始遍历
    current = self.root
    while current is not None:
        # 如果要查找的值小于当前节点的值，则向左走
        if value < current.value:
            current = current.left
        # 如果要查找的值大于当前节点的值，则向右走
        elif value > current.value:
            current = current.right
        # 如果要查找的值等于当前节点的值，则返回True
        else:
            return True
    # 如果遍历完毕还没有找到，则返回False
    return False

五、实现删除操作

要在二叉搜索树中删除一个元素，我们需要遵循以下步骤：

  • 如果树为空，则返回None。
  • 如果树不为空，则从根节点开始，比较要删除的值和当前节点的值。
  • 如果要删除的值小于当前节点的值，则递归地在当前节点的左子树中删除，并将删除后的左子树设为当前节点的左子节点。
  • 如果要删除的值大于当前节点的值，则递归地在当前节点的右子树中删除，并将删除后的右子树设为当前节点的右子节点。
  • 如果要删除的值等于当前节点的值，则分以下三种情况处理：
    • 如果当前节点没有子节点，则直接删除该节点，并返回None。
    • 如果当前节点只有一个子节点，则直接用该子节点替换该节点，并返回该子节点。
    • 如果当前节点有两个子节点，则先在其右子树中找到最小值（或者在其左子树中找到最大值），然后用该最小（或最大）值替换该节点，并递归地在其右（或左）子树中删除该最小（或最大）值，并将删除后的右（或左）子树设为该节点的右（或左）子节点。

我们可以用以下代码实现删除操作：

def delete(self, value):
    # 如果树为空，则返回None
    if self.root is None:
        return None
    # 否则从根节点开始遍历
    current = self.root
    parent = None
    while current is not None and current.value != value:
        # 记录父节点
        parent = current
        # 如果要删除的值小于当前节点的值，则向左走
        if value < current.value:
            current = current.left
        # 如果要删除的值大于当前节点的值，则向右走
        else:
            current = current.right
    # 如果没有找到要删除的元素，则返回None
    if current is None:
        return None
    
    # 定义一个辅助函数，用来找到一棵树中最小（或最大）元素所在的结点和其父结点，参数是根结点和一个布尔变量，表示是否寻找最小元素，默认为True，如果为False则寻找最大元素
    def find_min_max(node, is_min=True):
        # 初始化最小（或最大）结点和其父结点
        min_max = node
        parent = None
        # 如果寻找最小元素，则一直向左走，否则一直向右走
        if is_min:
            while min_max.left is not None:
                parent = min_max
                min_max = min_max.left
        else:
            while min_max.right is not None:
                parent = min_max
                min_max = min_max.right
        # 返回最小（或最大）结点和其父结点
        return min_max, parent
    
    # 如果当前结点没有子结点，则直接删除该结点，并返回None
    if current.left is None and current.right is None:
        # 如果是根结点，则将根结点设为None
        if parent is None:
            self.root = None
        # 否则判断是父结点的左子结点还是右子结点，并将其设为None
        else:
            if parent.left == current:
                parent.left = None
            else:
                parent.right = None
        return None
    
    # 如果当前结点只有一个子结点，则直接用该子结点替换该结点，并返回该子结点
    if current.left is None or current.right is None:
        # 找到该子结点，可以是左子结点也可以是右子结点
        child = current.left if current.left is not None else current.right
        # 如果是根结点，则将根结点设为该子结点
        if parent is None:
            self.root = child
        # 否则判断是父结点的左子结点还是右子结点，并将其设为该子结点
        else:
            if parent.left == current:
                parent.left = child
            else:
                parent.right = child
        return child
    
    # 如果当前结点有两个子结点，则先在其右子树中找到最小值（或者在其左子树中找到最大值），然后用该最小（或最大）值替换该结点，并递归地在其右（或左）子树中删除该最小（或最大）值，并将删除后的右（或左）子树设为该结点的右（或左）子节点
    # 这里我们选择在右子树中找到最小值，也可以在左子树中找到最大值，只要保证替换后的结点满足二叉搜索树的性质即可
    min_node, min_parent = find_min_max(current.right, is_min=True)
    # 用最小值替换当前结点的值
    current.value = min_node.value
    # 递归地在右子树中删除最小值，并将删除后的右子树设为当前结点的右子节点
    current.right = self.delete(min_node.value)
    return current

六、实现遍历操作

遍历是一种访问树中所有元素的方法，有三种常见的遍历方式：

  • 前序遍历（Pre-order Traversal）：先访问根节点，再访问左子树，最后访问右子树。
  • 中序遍历（In-order Traversal）：先访问左子树，再访问根节点，最后访问右子树。
  • 后序遍历（Post-order Traversal）：先访问左子树，再访问右子树，最后访问根节点。

我们可以用以下代码实现遍历操作：

def pre_order(self, node):
    # 如果结点为空，则返回
    if node is None:
        return
    # 先访问根节点，打印其值
    print(node.value, end=" ")
    # 再访问左子树，递归调用前序遍历函数
    self.pre_order(node.left)
    # 最后访问右子树，递归调用前序遍历函数
    self.pre_order(node.right)

def in_order(self, node):
    # 如果结点为空，则返回
    if node is None:
        return
    # 先访问左子树，递归调用中序遍历函数
    self.in_order(node.left)
    # 再访问根节点，打印其值
    print(node.value, end=" ")
    # 最后访问右子树，递归调用中序遍历函数
    self.in_order(node.right)

def post_order(self, node):
    # 如果结点为空，则返回
    if node is None:
        return
    # 先访问左子树，递归调用后序遍历函数
    self.post_order(node.left)
    # 再访问右子树，递归调用后序遍历函数
    self.post_order(node.right)
    # 最后访问根节点，打印其值
    print(node.value, end=" ")

七、实现其他操作

除了上述基本操作外，二叉搜索树还可以实现一些其他有用的操作，例如：

  • 求树的高度（Height）：从根节点到叶节点的最长路径上的节点数。
  • 求树的大小（Size）：树中所有节点的个数。
  • 求第k小（或第k大）元素：按照中序遍历的顺序，找到第k个元素。
  • 求两个元素的最近公共祖先（Lowest Common Ancestor）：两个元素在树中的最低层次的公共祖先节点。

我们可以用以下代码实现这些操作：

def height(self, node):
    # 如果结点为空，则返回0
    if node is None:
        return 0
    # 否则返回左右子树中较大的高度加1
    return max(self.height(node.left), self.height(node.right)) + 1

def size(self, node):
    # 如果结点为空，则返回0
    if node is None:
        return 0
    # 否则返回左右子树的大小之和加1
    return self.size(node.left) + self.size(node.right) + 1

def kth_smallest(self, node, k):
    # 如果结点为空，则返回None
    if node is None:
        return None
    # 定义一个辅助函数，用来计算一棵树中有多少个小于等于给定值的元素，参数是根结点和给定值
    def count_less_equal(node, value):
        # 如果结点为空，则返回0
        if node is None:
            return 0
        # 如果结点的值小于等于给定值，则返回左子树的个数加右子树中小于等于给定值的个数加1
        if node.value <= value:
            return count_less_equal(node.left, value) + count_less_equal(node.right, value) + 1
        # 如果结点的值大于给定值，则返回左子树中小于等于给定值的个数
        else:
            return count_less_equal(node.left, value)
    
    # 计算当前结点左子树中有多少个元素
    left_count = self.size(node.left)
    # 如果左子树中有k-1个元素，则当前结点就是第k小元素，返回其值
    if left_count == k - 1:
        return node.value
    # 如果左子树中有超过k-1个元素，则第k小元素在左子树中，递归调用函数在左子树中查找
    elif left_count > k - 1:
        return self.kth_smallest(node.left, k)
    # 如果左子树中有少于k-1个元素，则第k小元素在右子树中，递归调用函数在右子树中查找，注意要更新k的值为k-left_count-1，因为已经排除了左子树和当前结点
    else:
        return self.kth_smallest(node.right, k - left_count - 1)

def lowest_common_ancestor(self, node, p, q):
    # 如果结点为空，则返回None
    if node is None:
        return None
    # 如果结点的值等于p或q中的任意一个，则返回该结点，表示找到了其中一个元素
    if node.value == p or node.value == q:
        return node
    # 否则在左右子树中分别查找p和q，得到两个结果
    left_result = self.lowest_common_ancestor(node.left, p, q)
    right_result = self.lowest_common_ancestor(node.right, p, q)
    # 如果两个结果都不为空，则表示p和q分别在当前结点的两侧，那么当前结点就是最近公共祖先，返回该结点
    if left_result is not None and right_result is not None:
        return node
    # 如果两个结果中有一个为空，则表示p和q都在另一个结果所在的子树中，那么返回非空的结果作为最近公共祖先
    if left_result is None:
        return right_result
    else:
        return left_result

Gavana.
关注
  • 2
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
二叉搜索树-增删改查(Python)
qq_43762574的博客
07-08 1013
01 定义 首先定义二叉树结点的数据类型： class TreeNode(): def __init__(self, val, left=None, right=None): self.val = val self.left = left self.right = right 二叉搜索树的定义： 二叉搜索树（BST）是二叉树的一种特殊表示形式，它满足如下特性： 每个节点中的值必须大于（或等于）存储在其左侧子树中的任何值。 每个节点中的值必须小于（或等于）存储在其右子树中的任何值。 下面是一个
python 实现二叉搜索树的方法有哪些？
SiKi学院的博客
04-04 852
​ 树不同于链表或哈希表，是一种非线性数据结构，树分为二叉树、二叉搜索树、B树、B+树、红黑树等等。 树是一种数据结构，它是由n个有限节点组成的一个具有层次关系的集合。用图片来表示的话，可以看到它很像一棵倒挂着的树。因此我们将这类数据结构统称为树，树根在上面，树叶在下面。一般的树具有以下特点： ​
Python 实现二叉树的创建、二叉树的添加、二叉树的删除、二叉树的修改、二叉树的查找、二叉树的的遍历 最详细的二叉树 增 删 改 查
storyfull
12-27 2052
Python 实现二叉树的创建、添加、删除、修改、查找
字典树的创建以及增删改查方法详解（Python实现）
Delusional的博客
10-17 849
《自然语言处理入门》-2.4字典树 学习笔记 字典树的定义 参考博客：https://blog.csdn.net/weixin_39778570/article/details/81990417 这里还有一个映射的概念，图中能表示一个个字符串的集合，除了集合的功能之外，字典树也可以实现映射，只需将相应的值悬挂在键的终点节点上即可，后续的代码实现也是关于字典树的映射的。 字典树节点和树的Python代码实现 class Node(object): def __init__(self,
python学习之二叉树的实现详解
分享型博主
03-24 3890
insert方法用于向二叉树中插入节点，find方法用于查找二叉树中是否存在特定节点，inorder_traversal方法用于对二叉树进行中序遍历。在上述代码中，首先创建了一个根节点root，然后使用insert方法向树中插入节点，最后使用find方法查找节点并使用inorder_traversal方法对二叉树进行中序遍历。除了插入、查找和遍历方法，二叉树还有其他的操作方法，如删除节点、判断是否为二叉搜索树、计算树的深度等。这个示例包含了插入、查找、删除、遍历、判断是否为二叉搜索树和计算树的深度等。
基于Python的数据结构实验——二叉树的构建与遍历（先序、中序、后序、层次遍历，修改、添加节点）（附详细代码和注释）
为人民服务
01-13 2466
（注：我使用的二叉树写入的方法是，一层一层写，有两个规矩，一是确保每一个节点的孩子都必须是写入了数据的节点或#节点，二是确保最后一个#之前不能存在空节点，即对于上述二叉树，其应该表示为ABCDEFGH##IJ#############，分层后是A|BC|DEFG|H##IJ###|##########）创建名为 prac07.py 的文件，在文件中定义两个类，一个是二叉树的结点类，该类 包含结点的相关信息(如结点的值和左、右子树);另一个是二叉树的类，该类包含二叉树的定 义及其基本操作。
用python语言实现数据结构与算法的编程题.zip
01-03
- 列表(List)：Python中最常用的数据结构，支持动态增删改查，可以存储不同类型的元素。例如：`my_list = [1, 'two', 3.14]` - 元组(Tuple)：不可变的序列，常用于数据打包和保护数据不被意外修改。如：`my_tuple ...
CodingNinjas:Python和数据结构课程简介
04-18
1. 列表(List)：Python中最常用的数据结构，可以存储任意类型的元素，支持索引、切片、增删改查等操作。 2. 元组(Tuple)：不可变的序列，一旦创建就不能修改，通常用于保存一组数据。 3. 集合(Set)：无序且不重复的...
Data-Structures-and-Algorithms:主要以python语言
03-13
1. 列表(List)：动态数组，支持增删改查操作，索引从0开始。 2. 元组(Tuple)：不可变序列，适用于不需修改的数据，通常用于返回函数结果或作为字典的键。 3. 集合(Set)：无序不重复元素集，支持集合运算如并、交、差...
二叉查找树
09-15
用python编写的简单二叉查找树，初学者可以借鉴一下
DSA_Problems
03-29
1. 数组和链表的操作：增删改查、反转、查找等。 2. 栈和队列的实例：括号匹配、迷宫求解、任务调度等。 3. 哈希表的应用：查找、去重、最短路径问题等。 4. 树的实现：二叉搜索树、AVL 树、红黑树等，以及遍历、...
DS-ALGO:DS符合我的惯例
04-13
Python中的数组通过`array`模块实现，但更常用的是列表（list），一个动态大小的数组，支持元素的增删改查。 2. **链表**：链表由节点组成，每个节点包含数据和指向下一个节点的引用。Python中没有内置链表，但可以...
算法数据结构——二叉搜索树（Binary Search Tree）精讲及python实现
白话机器学习
06-05 841
二叉搜索树（Binary Search Tree）：也叫做二叉查找树、有序二叉树或者排序二叉树。是指一棵空树或者具有下列性质的二叉树：如果任意节点的左子树不为空，则左子树上所有节点的值均小于它的根节点的值。如果任意节点的右子树不为空，则右子树上所有节点的值均大于它的根节点的值。任意节点的左子树、右子树均为二叉搜索树。如图所示，这 $3$ 棵树都是二叉搜索树。二叉树具有一个特性，即：$左子树的节点值 < 根节点值 < 右子树的节点值$。
Python算法——二叉搜索树
Echo_Wish的博客
11-13 333
二叉搜索树是一种常见的树状数据结构，具有有序性质。在二叉搜索树中，每个节点的值大于其左子树中的任何节点值，小于其右子树中的任何节点值。这种有序性质使得二叉搜索树具有高效的查找、插入和删除操作。在本文中，我们将深入探讨二叉搜索树的原理，并提供Python代码实现。 插入操作 插入操作是将新节点插入到二叉搜索树中的过程。具体步骤如下： 查找操作 查找操作是在二叉搜索树中查找特定值的过程。具体步骤如下： 删除操作 删除操作是从二叉搜索树中删除特定值的节点。具体步骤如下： 示例 创建一个二叉搜索树并演示插入、查找和
Python二叉树用法介绍
weixin_19970108018的博客
10-26 343
每个节点最多有两个子节点每个节点只有一个父节点左子节点是其父节点的左子树，而右子节点是其父节点的右子树按照这个定义，我们可以使用Python中的类来定义一个简单的二叉树：其中，Node类表示二叉树的节点，BinaryTree表示整个树，它的根节点是一个Node类型的节点实例。
python实现二叉树及相关操作
xskxushaokai的博客
12-14 1996
最近秋招差不多结束了，这几个月复习了不少东西，记录一下用python构造二叉树以及相关的操作,与二叉树相关的操作大多数都可以用递归的方法来解决。本文将记录二叉树的前序遍历、中序遍历、后序遍历、层次遍历、二叉树排序、查询、反转，以及笔试中常遇到的二叉树相关操作。
算法014：找到字符串中所有字母异位词
m0_62319039的博客
07-14 433
算法014：找到字符串中所有字母异位词
LC53最大子数组和、lc5最长回文子串、lc283移动零
最新发布
m0_47536537的博客
07-14 202
请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。连续子数组 [4,-1,2,1] 的和最大，为 6。移动到数组的末尾，同时保持非零元素的相对顺序。，必须在不复制数组的情况下原地对数组进行操作。"aba" 同样是符合题意的答案。是数组中的一个连续部分。，编写一个函数将所有。LC53最大子数组和。
树状数组（Binary Indexed Tree, BIT）
qq_73702550的博客
07-12 395
树状数组（Binary Indexed Tree, BIT），也称为 Fenwick Tree，是一种用于高效处理数组前缀和查询和单点更新的数据结构。它能够在 (O(\log n)) 时间内完成单点更新和前缀和查询操作。
python实现二叉搜索树
12-08
以下是Python实现二叉搜索树的代码示例： ```python class TreeNode: def __init__(self, val): self.val = val self.left = None self.right = None class BST: def __init__(self): self.root = None def insert(self, val): if not self.root: self.root = TreeNode(val) return curr = self.root while curr: if val < curr.val: if not curr.left: curr.left = TreeNode(val) return curr = curr.left else: if not curr.right: curr.right = TreeNode(val) return curr = curr.right def search(self, val): curr = self.root while curr: if curr.val == val: return True elif curr.val > val: curr = curr.left else: curr = curr.right return False def delete(self, val): def find_min(node): while node.left: node = node.left return node def delete_node(node, val): if not node: return None if node.val == val: if not node.left and not node.right: return None if not node.left: return node.right if not node.right: return node.left min_node = find_min(node.right) node.val = min_node.val node.right = delete_node(node.right, min_node.val) elif node.val > val: node.left = delete_node(node.left, val) else: node.right = delete_node(node.right, val) return node self.root = delete_node(self.root, val) ``` 以上代码实现了二叉搜索树的插入、查找和删除操作。其中，插入操作按照二叉搜索树的规则插入节点，查找操作也是按照二叉搜索树的规则进行查找，删除操作则需要考虑三种情况：被删除节点没有子节点、被删除节点只有一个子节点、被删除节点有两个子节点。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Gavana.

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值