二叉树的遍历

基础内容

二叉树的遍历指的是按照特定的顺序访问二叉树中的每一个节点，确保每个节点都被访问一次。遍历是处理二叉树的基本操作之一，主要用于处理或检索二叉树中的数据。二叉树的遍历方式主要分为四种：前序遍历（Pre-order）、中序遍历（In-order）、后序遍历（Post-order）以及层序遍历（Level-order）。

前序遍历（Pre-order）
前序遍历的顺序是“根节点 -> 左子树 -> 右子树”。算法会首先访问当前节点，然后递归地访问左子树，最后递归地访问右子树。如果树为空，则不做任何操作。

中序遍历（In-order）
中序遍历的顺序是“左子树 -> 根节点 -> 右子树”。这种遍历方式特别适用于二叉查找树（Binary Search Tree），在这种树中，中序遍历的结果是一个递增的有序序列。算法会先递归地访问左子树，然后访问当前节点，最后递归地访问右子树。

后序遍历（Post-order）
后序遍历的顺序是“左子树 -> 右子树 -> 根节点”。算法会先递归地访问左子树，接着递归地访问右子树，最后才访问当前节点。后序遍历常用于删除二叉树的场景，因为需要先删除子节点，然后才能删除父节点。

层序遍历（Level-order）
层序遍历是按照从上到下的层次来访问节点，同一层的节点从左至右访问。通常使用队列来实现，首先将根节点入队，然后反复执行出队并访问节点的操作，同时将当前节点的左右子节点入队（如果存在的话），直到队列为空为止。

示例代码（Python）

下面是一个简单的 Python 代码示例，展示了如何实现二叉树节点的定义以及前序、中序、后序遍历的方法：

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

def preorder_traversal(root):
    if root is None:
        return []
    return [root.val] + preorder_traversal(root.left) + preorder_traversal(root.right)

def inorder_traversal(root):
    if root is None:
        return []
    return inorder_traversal(root.left) + [root.val] + inorder_traversal(root.right)

def postorder_traversal(root):
    if root is None:
        return []
    return postorder_traversal(root.left) + postorder_traversal(root.right) + [root.val]

# 创建一个简单的二叉树
#       1
#      / \
#     2   3
#    / \
#   4   5
root = TreeNode(1)
root.left = TreeNode(2, TreeNode(4), TreeNode(5))
root.right = TreeNode(3)

print("Preorder:", preorder_traversal(root))  # 输出: Preorder: [1, 2, 4, 5, 3]
print("Inorder:", inorder_traversal(root))   # 输出: Inorder: [4, 2, 5, 1, 3]
print("Postorder:", postorder_traversal(root)) # 输出: Postorder: [4, 5, 2, 3, 1]

以上代码定义了一个简单的二叉树，并实现了三种基本的遍历算法。需要注意的是，在实际应用中，还可以使用迭代的方式来实现这些遍历，而不是仅仅依靠递归。

示例案例

为了使例子更具实用性，我们假设有一个表达式树，它代表了数学表达式。我们可以用这个表达式树来计算表达式的值。在这个例子中，我们将创建一个表达式树来表示加法和乘法表达式，并且演示如何通过遍历来计算结果。

表达式树示例

假设我们要计算以下表达式：
[ (3 + 2) * (4 - 1) ]

该表达式的表达式树可以表示为：

    *
   / \
  +   -
 / \ / \
3  2 4  1

我们可以用以下的 Python 类来表示树的节点：

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

接下来，我们定义一个函数来计算表达式的值。这可以通过后序遍历来实现，因为在计算表达式时，我们需要先计算子表达式的值，然后再进行当前节点的运算。

def evaluate_expression(node):
    if node is None:
        return 0
    
    if isinstance(node.value, int):  # 如果是数字节点
        return node.value
    else:  # 如果是运算符节点
        if node.value == '+':
            return evaluate_expression(node.left) + evaluate_expression(node.right)
        elif node.value == '-':
            return evaluate_expression(node.left) - evaluate_expression(node.right)
        elif node.value == '*':
            return evaluate_expression(node.left) * evaluate_expression(node.right)
        elif node.value == '/':
            return evaluate_expression(node.left) / evaluate_expression(node.right)

现在，让我们构造上述表达式的表达式树，并计算其值：

# 构建表达式树
root = ExprNode('*')
root.left = ExprNode('+', ExprNode(3), ExprNode(2))
root.right = ExprNode('-', ExprNode(4), ExprNode(1))

# 计算表达式的值
result = evaluate_expression(root)
print("The result of the expression is:", result)  # 输出: The result of the expression is: 15

这段代码首先定义了一个表达式树节点类 ExprNode，然后通过这个类构建了一个表达式树来代表我们的数学表达式。最后，我们通过 evaluate_expression 函数对这个树进行后序遍历，并计算出了最终的结果。

这样的例子在编译器、计算器应用程序以及其他需要解析和计算表达式的场景中非常有用。

示例扩展

进一步扩展这个例子，包括一些额外的功能，比如打印表达式树的中序、前序和后序遍历形式，这样可以帮助我们更好地理解树的结构。

我们将添加新的函数来输出树的不同遍历形式，并且也会改进 evaluate_expression 函数以处理更多的异常情况，例如除数为零的情况。

以下是更新后的完整代码：

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

def evaluate_expression(node):
    if node is None:
        return 0
    
    if isinstance(node.value, int):  # 如果是数字节点
        return node.value
    else:  # 如果是运算符节点
        if node.value == '+':
            return evaluate_expression(node.left) + evaluate_expression(node.right)
        elif node.value == '-':
            return evaluate_expression(node.left) - evaluate_expression(node.right)
        elif node.value == '*':
            return evaluate_expression(node.left) * evaluate_expression(node.right)
        elif node.value == '/':
            denominator = evaluate_expression(node.right)
            if denominator == 0:
                raise ValueError("Division by zero is not allowed.")
            return evaluate_expression(node.left) / denominator

def print_inorder(node):
    if node:
        print_inorder(node.left)
        print(node.value, end=" ")
        print_inorder(node.right)

def print_preorder(node):
    if node:
        print(node.value, end=" ")
        print_preorder(node.left)
        print_preorder(node.right)

def print_postorder(node):
    if node:
        print_postorder(node.left)
        print_postorder(node.right)
        print(node.value, end=" ")

# 构建表达式树
root = ExprNode('*')
root.left = ExprNode('+', ExprNode(3), ExprNode(2))
root.right = ExprNode('-', ExprNode(4), ExprNode(1))

# 计算表达式的值
try:
    result = evaluate_expression(root)
    print("\nThe result of the expression is:", result)
except Exception as e:
    print(e)

# 打印表达式的中序遍历形式
print("\nInorder traversal:")
print_inorder(root)
print()

# 打印表达式的前序遍历形式
print("Preorder traversal:")
print_preorder(root)
print()

# 打印表达式的后序遍历形式
print("Postorder traversal:")
print_postorder(root)
print()

这段代码中增加了三个新的函数来打印表达式树的不同遍历形式：

• print_inorder：打印表达式的中序遍历形式。
• print_preorder：打印表达式的前序遍历形式。
• print_postorder：打印表达式的后序遍历形式。

输出将会是：

The result of the expression is: 15

Inorder traversal:
3 + 2 * 4 - 1 

Preorder traversal:
* + 3 2 - 4 1 

Postorder traversal:
3 2 + 4 1 - *

这些输出帮助我们验证了树的正确构建以及遍历顺序是否正确。在实际应用中，这样的功能可以帮助开发者调试代码或者更好地理解程序的工作原理。

😍😍 海量H5小游戏、微信小游戏、Web casualgame源码😍😍 😍😍试玩地址： https://www.bojiogame.sg😍😍 😍看上哪一款，需要源码的csdn私信我😍

————————————————

​最后我们放松一下眼睛