python 如何遍历树

在Python中，可以通过递归遍历、迭代遍历、深度优先搜索（DFS）和广度优先搜索（BFS）等多种方式来遍历树。递归遍历是最常用的方式，因为它简单且直观，但对于非常深的树，可能导致栈溢出。在特定场景中，选择合适的遍历方法尤为重要。例如，在处理需要大量节点访问的情况下，广度优先搜索可能更为适合。

一、递归遍历

递归遍历是一种直接且常用的方法，通常用于实现树的前序、中序和后序遍历。递归方法通过函数的自调用来遍历树的节点，代码简洁且易于理解。

1. 前序遍历

前序遍历按照“根节点-左子树-右子树”的顺序进行。其特点是首先访问根节点，然后递归地访问左子树和右子树。

class TreeNode:
    def __init__(self, value):
        self.value = value
        self.left = None
        self.right = None
def preorder_traversal(node):
    if node:
        print(node.value)  # 访问根节点
        preorder_traversal(node.left)  # 递归访问左子树
        preorder_traversal(node.right)  # 递归访问右子树

2. 中序遍历

中序遍历按照“左子树-根节点-右子树”的顺序进行。它在处理二叉搜索树时特别有用，因为结果是排序的。

def inorder_traversal(node):
    if node:
        inorder_traversal(node.left)  # 递归访问左子树
        print(node.value)  # 访问根节点
        inorder_traversal(node.right)  # 递归访问右子树

3. 后序遍历

后序遍历按照“左子树-右子树-根节点”的顺序进行。它常用于删除树或释放内存，因为可以确保在处理父节点之前处理所有子节点。

def postorder_traversal(node):
    if node:
        postorder_traversal(node.left)  # 递归访问左子树
        postorder_traversal(node.right)  # 递归访问右子树
        print(node.value)  # 访问根节点

二、迭代遍历

迭代遍历使用栈或队列来替代递归，适合处理深度较大的树，从而避免递归调用带来的栈溢出问题。

1. 前序遍历（迭代）

通过栈模拟递归过程，首先将根节点压入栈中，然后弹出栈顶节点，访问其值，并将其右子节点和左子节点依次压入栈中。

def iterative_preorder(node):
    if not node:
        return
    stack = [node]
    while stack:
        current = stack.pop()
        print(current.value)  # 访问根节点
        if current.right:
            stack.append(current.right)  # 右子节点入栈
        if current.left:
            stack.append(current.left)  # 左子节点入栈

2. 中序遍历（迭代）

对于中序遍历，使用栈模拟递归，首先沿着左子树不断下探，同时将节点压入栈中。到达最左节点后，弹出栈顶节点，访问其值，然后转向右子树。

def iterative_inorder(node):
    stack = []
    current = node
    while stack or current:
        while current:
            stack.append(current)  # 左子节点入栈
            current = current.left
        current = stack.pop()  # 弹出栈顶节点
        print(current.value)  # 访问根节点
        current = current.right  # 转向右子树

3. 后序遍历（迭代）

后序遍历的迭代实现较为复杂，需要使用两个栈来帮助记录节点的访问顺序。

def iterative_postorder(node):
    if not node:
        return
    stack1, stack2 = [node], []
    while stack1:
        current = stack1.pop()
        stack2.append(current)
        if current.left:
            stack1.append(current.left)
        if current.right:
            stack1.append(current.right)
    while stack2:
        print(stack2.pop().value)  # 访问节点

三、深度优先搜索（DFS）

DFS是一种系统地遍历树的算法，常用于查找某一特定节点或路径。DFS可以通过递归实现，也可以使用栈来进行迭代实现。

1. 递归实现

递归实现DFS类似于前序遍历，但可以在访问节点时进行条件判断，以决定是否继续递归。

def dfs_recursive(node, target):
    if not node:
        return False
    if node.value == target:
        return True  # 找到目标节点
    return dfs_recursive(node.left, target) or dfs_recursive(node.right, target)

2. 迭代实现

使用栈来实现DFS，沿着某一方向不断深入，直到找到目标节点或遍历完所有节点。

def dfs_iterative(node, target):
    if not node:
        return False
    stack = [node]
    while stack:
        current = stack.pop()
        if current.value == target:
            return True  # 找到目标节点
        if current.right:
            stack.append(current.right)
        if current.left:
            stack.append(current.left)
    return False

四、广度优先搜索（BFS）

BFS使用队列来进行层次遍历，从根节点开始，逐层向下进行遍历，适用于查找最短路径等问题。

1. BFS 实现

在树的层次遍历过程中，通过队列依次将每一层的节点访问完毕，再将下一层的节点依次入队。

from collections import deque
def bfs(node, target):
    if not node:
        return False
    queue = deque([node])
    while queue:
        current = queue.popleft()
        if current.value == target:
            return True  # 找到目标节点
        if current.left:
            queue.append(current.left)
        if current.right:
            queue.append(current.right)
    return False