二叉树遍历：前序、中序与后序的节点关系与应用

1. 二叉树遍历基础与节点关系解析

第一次在项目中实现二叉树遍历时，我犯了个典型错误——用同一套逻辑处理前中后序，结果节点关系完全错乱。实际上，这三种遍历方式对节点访问顺序的差异，直接影响着我们对树结构的理解和操作。先看这个最简单的二叉树结构：

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

前序遍历（Pre-order）的访问顺序是"根-左-右"，就像我们深度优先探索地图时先标记当前位置再向两侧延伸。中序遍历（In-order）的"左-根-右"顺序特别适合二叉搜索树，能自然输出有序序列。而后序遍历（Post-order）的"左-右-根"模式，则是处理子树后再处理根节点的典型场景，比如计算目录大小。

关键区别：前序的根节点最先访问，适合构建树结构；中序的根节点在中间，适合有序输出；后序的根节点最后访问，适合汇总子树信息。

2. 递归实现中的节点关系处理

递归是最直观的遍历实现方式，但每种遍历的递归调用栈中节点关系截然不同。以前序遍历为例：

python复制def preorder(root):
    if not root:
        return []
    return [root.val] + preorder(root.left) + preorder(root.right)

这时递归栈帧中的节点关系形成父子链：当前节点处理时，其左右子节点作为参数压入栈中。而中序遍历的递归：

python复制def inorder(root):
    if not root:
        return []
    return inorder(root.left) + [root.val] + inorder(root.right)

会产生"左子节点->父节点->右子节点"的栈帧关系。这种差异在调试时尤为明显——前序的断点会在访问节点值时立即触发，而中序的断点会在左子树完全处理后才触发。

调试技巧：在递归函数开始处打印当前节点值和调用深度，可以清晰看到不同遍历方式的调用栈变化。

3. 迭代实现时的显式关系管理

当用显式栈实现迭代遍历时，我们需要手动维护节点关系。以前序迭代为例：

python复制def preorder_iterative(root):
    stack, res = [root], []
    while stack:
        node = stack.pop()
        if node:
            res.append(node.val)
            stack.append(node.right)  # 右子先入后出
            stack.append(node.left)   # 左子后入先出

这里栈顶元素始终是当前要处理的节点，其子节点按相反顺序入栈以保证处理顺序。对比中序迭代实现：

python复制def inorder_iterative(root):
    stack, res = [], []
    curr = root
    while curr or stack:
        while curr:  # 深入左子树
            stack.append(curr)
            curr = curr.left
        curr = stack.pop()
        res.append(curr.val)
        curr = curr.right

此时栈中保存的是待处理的父节点链，curr指针则负责探索左边界。这种实现明显更复杂，因为访问顺序与处理顺序不再一致。

4. 节点关系的实际应用场景

理解遍历中的节点关系，能解决许多实际问题。例如：

场景1：构造二叉树

• 前序+中序：前序确定根节点，中序划分左右子树

python复制def buildTree(preorder, inorder):
    if not preorder:
        return None
    root_val = preorder[0]
    root = TreeNode(root_val)
    idx = inorder.index(root_val)
    root.left = buildTree(preorder[1:idx+1], inorder[:idx])
    root.right = buildTree(preorder[idx+1:], inorder[idx+1:])
    return root

场景2：序列化二叉树

• 前序序列化最能保持结构关系：

python复制def serialize(root):
    if not root:
        return '#'
    return f"{root.val},{serialize(root.left)},{serialize(root.right)}"

场景3：最近公共祖先(LCA)

• 后序遍历天然适合自底向上查找：

python复制def lowestCommonAncestor(root, p, q):
    if not root or root == p or root == q:
        return root
    left = lowestCommonAncestor(root.left, p, q)
    right = lowestCommonAncestor(root.right, p, q)
    if left and right:
        return root
    return left or right

5. 遍历中的特殊节点关系处理

某些情况下需要特别关注节点关系：

案例1：判断完全二叉树

• 层序遍历中遇到空节点后不应再有非空节点

python复制def isCompleteTree(root):
    queue = deque([root])
    seen_null = False
    while queue:
        node = queue.popleft()
        if not node:
            seen_null = True
        else:
            if seen_null:
                return False
            queue.append(node.left)
            queue.append(node.right)
    return True

案例2：寻找前驱后继节点

• 中序遍历时维护前一个节点：

python复制def inorderSuccessor(root, p):
    stack, prev, curr = [], None, root
    while stack or curr:
        while curr:
            stack.append(curr)
            curr = curr.left
        curr = stack.pop()
        if prev == p:
            return curr
        prev = curr
        curr = curr.right
    return None

案例3：验证二叉搜索树

• 中序遍历结果应严格递增：

python复制def isValidBST(root):
    stack, prev = [], None
    while stack or root:
        while root:
            stack.append(root)
            root = root.left
        root = stack.pop()
        if prev and root.val <= prev.val:
            return False
        prev = root
        root = root.right
    return True

6. 非递归遍历的统一写法

Morris遍历通过修改树结构临时建立节点关系，实现O(1)空间复杂度：

python复制def inorderMorris(root):
    curr = root
    while curr:
        if not curr.left:
            print(curr.val)
            curr = curr.right
        else:
            pre = curr.left
            while pre.right and pre.right != curr:
                pre = pre.right
            if not pre.right:
                pre.right = curr  # 建立临时链接
                curr = curr.left
            else:
                pre.right = None  # 恢复树结构
                print(curr.val)
                curr = curr.right

这种算法利用叶子节点的空指针存储临时信息，在遍历后恢复原结构。虽然节省了空间，但会改变树的临时状态，在并发环境下需要特别注意。

7. 多节点关系的复杂处理

当需要同时处理多个节点关系时，遍历逻辑会更复杂：

子树匹配问题

python复制def isSubtree(s, t):
    def serialize(root):
        if not root:
            return '#'
        return f"^{root.val}{serialize(root.left)}{serialize(root.right)}"
    return serialize(t) in serialize(s)

路径总和III（前缀和技巧）

python复制def pathSum(root, target):
    from collections import defaultdict
    prefix = defaultdict(int)
    prefix[0] = 1
    def dfs(node, curr_sum):
        if not node:
            return 0
        curr_sum += node.val
        res = prefix[curr_sum - target]
        prefix[curr_sum] += 1
        res += dfs(node.left, curr_sum)
        res += dfs(node.right, curr_sum)
        prefix[curr_sum] -= 1
        return res
    return dfs(root, 0)

这类问题需要在遍历时维护额外的状态信息，记录节点间的多种关系。实际操作中，我常用哈希表来保存中间状态，但要注意回溯时的状态恢复。

8. 性能优化与注意事项

1. 避免递归栈溢出：对于深度很大的树，递归实现可能导致栈溢出。Python默认递归深度约1000层，可以用sys.setrecursionlimit()调整，但更好的方式是改用迭代

2. Morris遍历的陷阱：虽然空间复杂度优秀，但会修改树结构，不适合多线程环境。我曾在一个生产环境中因此引发过难以追踪的bug

3. 缓存遍历结果：当需要多次访问遍历结果时，可以缓存首次遍历结果。但要注意树结构变化时需要及时更新缓存

4. 迭代实现的优化：对于前序遍历，以下写法更简洁：

python复制def preorder(root):
    stack, res = [root], []
    while stack:
        node = stack.pop()
        if node:
            res.append(node.val)
            stack += [node.right, node.left]  # 利用列表拼接
    return res

5. 处理空树的边界条件：总是先检查root是否为None，这在处理用户输入时尤为重要。我曾在面试中因忽略这点而错失机会

最后分享一个实用技巧：当需要同时获取节点深度信息时，可以用元组保存节点和深度：

python复制def levelOrder(root):
    if not root:
        return []
    queue = deque([(root, 0)])
    res = []
    while queue:
        node, depth = queue.popleft()
        if len(res) == depth:
            res.append([])
        res[depth].append(node.val)
        if node.left:
            queue.append((node.left, depth+1))
        if node.right:
            queue.append((node.right, depth+1))
    return res