二叉搜索树的构建与遍历算法

发表于

二叉搜索树的构建与遍历算法

介绍

二叉搜索树（Binary Search Tree，BST）是一种常见的数据结构，它具有良好的查找、插入和删除性能。在二叉搜索树中，每个节点都包含一个键值，且具备以下性质：

  1. 左子树中所有节点的键值小于根节点的键值。
  2. 右子树中所有节点的键值大于根节点的键值。
  3. 左右子树本身也是二叉搜索树。

image-20240421021007689

构建二叉搜索树

构建二叉搜索树的过程可以通过递归或迭代来完成。下面我们将介绍两种方法。

递归方法

递归方法是一种直观且常用的构建二叉搜索树的方法。算法如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
kotlin复制代码class TreeNode:
    def __init__(self, val):
        self.val = val
        self.left = None
        self.right = None

def insert(root, val):
    if not root:
        return TreeNode(val)
    if val < root.val:
        root.left = insert(root.left, val)
    else:
        root.right = insert(root.right, val)
    return root

迭代方法

迭代方法利用循环和栈来构建二叉搜索树，算法如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
kotlin复制代码def insert(root, val):
    if not root:
        return TreeNode(val)
    
    current = root
    while True:
        if val < current.val:
            if current.left is None:
                current.left = TreeNode(val)
                break
            else:
                current = current.left
        else:
            if current.right is None:
                current.right = TreeNode(val)
                break
            else:
                current = current.right
    return root

二叉搜索树的遍历

二叉搜索树的遍历包括三种常见方式：中序遍历、前序遍历和后序遍历。

中序遍历

中序遍历按照节点的键值从小到大的顺序遍历二叉搜索树。算法如下：

1
2
3
4
5
scss复制代码def inorder_traversal(root):
    if root:
        inorder_traversal(root.left)
        print(root.val)
        inorder_traversal(root.right)

前序遍历

前序遍历先访问根节点，然后按照左子树、右子树的顺序遍历。算法如下：

1
2
3
4
5
scss复制代码def preorder_traversal(root):
    if root:
        print(root.val)
        preorder_traversal(root.left)
        preorder_traversal(root.right)

后序遍历

后序遍历先遍历左子树，然后遍历右子树，最后访问根节点。算法如下：

1
2
3
4
5
scss复制代码def postorder_traversal(root):
    if root:
        postorder_traversal(root.left)
        postorder_traversal(root.right)
        print(root.val)

代码示例：二叉搜索树的查找算法

image-20240421021020666

除了构建和遍历二叉搜索树，查找是另一个重要的操作。在二叉搜索树中，查找操作可以在平均情况下以 O(log n) 的时间复杂度完成。

1
2
3
4
5
6
7
kotlin复制代码def search(root, val):
    if not root or root.val == val:
        return root
    if val < root.val:
        return search(root.left, val)
    else:
        return search(root.right, val)

在这个示例中，我们实现了一个简单的递归查找算法。如果当前节点为空或者节点的值等于目标值，则返回当前节点；否则，根据目标值的大小递归地在左子树或右子树中查找。

示例代码说明

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
perl复制代码# 创建一个二叉搜索树
root = None
keys = [8, 3, 10, 1, 6, 14, 4, 7, 13]
for key in keys:
    root = insert(root, key)

# 中序遍历打印二叉搜索树
print("Inorder traversal:")
inorder_traversal(root)

# 查找节点值为 6 的节点
search_result = search(root, 6)
if search_result:
    print("\nFound node with value 6:", search_result.val)
else:
    print("\nNode with value 6 not found.")

在这个示例中，我们首先创建了一个包含一组键值的二叉搜索树，然后使用中序遍历打印树的节点，最后查找节点值为 6 的节点并输出结果。

通过这个代码示例，我们展示了如何利用二叉搜索树进行查找操作，同时展示了如何将查找操作与其他操作结合使用，从而更好地理解和应用二叉搜索树。

image-20240421021034793

代码示例：二叉搜索树的删除操作

除了插入和查找，删除操作也是二叉搜索树中的重要操作之一。删除操作涉及到几种情况：删除叶子节点、删除只有一个子节点的节点以及删除有两个子节点的节点。下面我们来实现一个删除节点的函数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
kotlin复制代码def delete(root, val):
    if not root:
        return root
    
    if val < root.val:
        root.left = delete(root.left, val)
    elif val > root.val:
        root.right = delete(root.right, val)
    else:
        if not root.left:
            return root.right
        elif not root.right:
            return root.left
        
        # 如果被删除节点有两个子节点，则找到右子树中的最小节点替代
        temp = find_min(root.right)
        root.val = temp.val
        root.right = delete(root.right, temp.val)
    
    return root

def find_min(node):
    current = node
    while current.left:
        current = current.left
    return current

在这个示例中，我们实现了一个删除节点的函数。如果待删除的节点是叶子节点或者只有一个子节点，则直接删除；如果待删除的节点有两个子节点，则找到右子树中的最小节点替代被删除节点，然后递归地删除右子树中的最小节点。

示例代码说明

1
2
3
4
5
6
7
8
9
10
11
12
13
14
ini复制代码# 创建一个二叉搜索树
root = None
keys = [8, 3, 10, 1, 6, 14, 4, 7, 13]
for key in keys:
    root = insert(root, key)

# 中序遍历打印二叉搜索树
print("Inorder traversal:")
inorder_traversal(root)

# 删除节点值为 6 的节点
root = delete(root, 6)
print("\nAfter deleting node with value 6:")
inorder_traversal(root)

在这个示例中，我们首先创建了一个包含一组键值的二叉搜索树，然后使用中序遍历打印树的节点。接着，我们删除了节点值为 6 的节点，并再次使用中序遍历打印树的节点，以展示删除操作的效果。

通过这个代码示例，我们展示了如何利用二叉搜索树进行删除操作，同时展示了删除操作的几种情况和处理方式，有助于更好地理解和应用二叉搜索树。

image-20240421021103562

代码示例：二叉搜索树的验证

在处理二叉搜索树时，有时我们需要验证一个给定的树是否是二叉搜索树。这涉及到检查每个节点是否满足二叉搜索树的性质：左子树的所有节点值小于当前节点的值，右子树的所有节点值大于当前节点的值。下面我们来实现一个验证函数。

1
2
3
4
5
6
7
8
9
10
11
12
kotlin复制代码def is_bst(root):
    return is_bst_util(root, float('-inf'), float('inf'))

def is_bst_util(node, min_val, max_val):
    if not node:
        return True
    
    if node.val <= min_val or node.val >= max_val:
        return False
    
    return (is_bst_util(node.left, min_val, node.val) and
            is_bst_util(node.right, node.val, max_val))

在这个示例中，我们定义了一个递归的辅助函数 is_bst_util，它检查当前节点是否在给定的最小值和最大值范围内，并递归地检查左子树和右子树。如果当前节点满足二叉搜索树的性质，并且左右子树也满足，则返回 True，否则返回 False。

示例代码说明

1
2
3
4
5
6
7
8
9
10
11
perl复制代码# 创建一个二叉搜索树
root = None
keys = [8, 3, 10, 1, 6, 14, 4, 7, 13]
for key in keys:
    root = insert(root, key)

# 验证二叉搜索树
if is_bst(root):
    print("The tree is a binary search tree.")
else:
    print("The tree is not a binary search tree.")

在这个示例中，我们首先创建了一个包含一组键值的二叉搜索树，然后使用验证函数 is_bst 来验证该树是否是二叉搜索树。

通过这个代码示例，我们展示了如何利用递归函数来验证二叉搜索树的性质，有助于我们在实际应用中进行二叉搜索树的正确性检查。

代码示例：二叉搜索树的层次遍历

层次遍历是一种按照树的层级顺序逐层访问节点的方式。在二叉搜索树中，我们可以利用队列实现层次遍历。下面是一个层次遍历的示例代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
c复制代码from collections import deque

def level_order_traversal(root):
    if not root:
        return
    
    queue = deque([root])
    while queue:
        node = queue.popleft()
        print(node.val)
        if node.left:
            queue.append(node.left)
        if node.right:
            queue.append(node.right)

在这个示例中，我们利用 collections 模块中的 deque 实现了一个队列，用于存储待访问的节点。我们首先将根节点入队，然后循环遍历队列中的节点，依次输出节点的值，并将其左右子节点入队。这样就能够按照层次顺序逐层访问二叉搜索树的节点。

image-20240421021115678

示例代码说明

1
2
3
4
5
6
7
8
9
ini复制代码# 创建一个二叉搜索树
root = None
keys = [8, 3, 10, 1, 6, 14, 4, 7, 13]
for key in keys:
    root = insert(root, key)

# 层次遍历打印二叉搜索树
print("Level order traversal:")
level_order_traversal(root)

在这个示例中，我们首先创建了一个包含一组键值的二叉搜索树，然后使用层次遍历函数 level_order_traversal 来按照树的层次顺序打印树的节点。

通过这个代码示例，我们展示了如何利用队列实现层次遍历算法，以及如何应用层次遍历算法来逐层访问二叉搜索树的节点。

平衡二叉搜索树

在实际应用中，为了避免二叉搜索树在极端情况下出现不平衡的情况，进而导致性能下降，可以使用平衡二叉搜索树（Balanced Binary Search Tree）。其中，最常见的平衡二叉搜索树是 AVL 树和红黑树。

AVL 树

AVL 树是一种严格的平衡二叉搜索树，它保证了任何节点的左右子树的高度差不超过 1。在插入或删除节点时，AVL 树会通过旋转操作来保持平衡。由于 AVL 树的严格平衡性，其插入、删除和查找操作的时间复杂度均为 O(log n)。

红黑树

红黑树是一种非严格平衡的平衡二叉搜索树，相较于 AVL 树，它对平衡条件的要求更加宽松，从而降低了维护平衡的成本。红黑树通过颜色标记和旋转操作来维持平衡，其插入、删除和查找操作的时间复杂度也为 O(log n)。

image-20240421021131352

应用场景

二叉搜索树及其变种在计算机科学中有着广泛的应用，例如：

  • 数据库索引：许多数据库系统使用二叉搜索树来实现索引，以加速数据检索操作。
  • 字典：许多编程语言中的字典数据结构（如 Python 中的字典）采用哈希表或平衡二叉搜索树来实现。
  • 路由表：路由器使用二叉搜索树来存储路由表，以便快速查找最佳路径。
  • 编译器：编译器使用符号表（Symbol Table）来存储变量和函数等符号信息，通常采用二叉搜索树或哈希表来实现。

总结

本文深入探讨了二叉搜索树（BST）的构建、遍历、删除、验证和层次遍历等关键操作。首先介绍了二叉搜索树的定义和性质，包括节点值的大小关系和子树的结构。然后，详细讨论了二叉搜索树的构建方法，包括递归和迭代两种方式。接着，介绍了三种常见的遍历方式：中序遍历、前序遍历和后序遍历，以及层次遍历的实现方法。随后，讨论了二叉搜索树的删除操作，包括删除叶子节点、只有一个子节点的节点和有两个子节点的节点。在此基础上，展示了二叉搜索树的验证方法，验证树是否满足二叉搜索树的性质。最后，通过代码示例展示了每个操作的具体实现和应用场景，帮助读者更深入地理解和应用二叉搜索树。

通过本文的学习，读者可以掌握二叉搜索树的基本概念、常见操作和应用技巧，从而在实际问题中更加灵活地运用二叉搜索树来解决各种数据管理和查找的需求。同时，本文还展示了如何利用递归、迭代和队列等技术实现二叉搜索树的各种操作，有助于读者深入理解数据结构和算法的原理与实现。

本文转载自: 掘金

开发者博客 – 和开发相关的 这里全都有

0%