Python实现二叉搜索树增删改查
作者：高垚淼
二叉搜索树是一种特殊的二叉树,在本文中,我将介绍如何用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到此这篇关于Python实现二叉搜索树增删改查的文章就介绍到这了,更多相关Python 二叉搜索树增删改查内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！