检查两棵二叉树的叶子遍历是否相同

问题描述

给定两棵二叉树，判断它们的叶子遍历序列是否相同。

解决方案

叶子遍历的定义

叶子遍历（也叫后序遍历）是指按照“左子树-右子树-根节点”的顺序遍历一棵二叉树，并输出其叶子节点（即没有左右子节点的节点）的值。例如，对于下面的二叉树：

    3
   / \
  9  20
    /  \
   15   7

它的叶子遍历序列是：[9, 15, 7, 20, 3]。

递归算法

检查两棵二叉树的叶子遍历是否相同，可以通过递归实现。具体步骤如下：

1. 如果两棵二叉树都为空，则它们的叶子遍历序列相同，直接返回 True。
2. 如果两棵二叉树中只有一个为空，则它们的叶子遍历序列不相同，直接返回 False。
3. 递归判断两棵二叉树的左子树和右子树的叶子遍历序列是否相同。
4. 如果上一步返回 True，则比较当前节点是否为叶子节点。如果是，则将当前节点的值加入叶子遍历序列中。
5. 返回 True 或 False。

下面是 Python 代码实现：

def leaf_traversal(root):
    """
    计算二叉树的叶子遍历序列
    """
    if not root:
        return []
    if not root.left and not root.right:
        return [root.val]
    return leaf_traversal(root.left) + leaf_traversal(root.right)

def is_same_leaf_traversal(root1, root2):
    """
    判断两棵二叉树的叶子遍历序列是否相同
    """
    if not root1 and not root2:
        return True
    if not root1 or not root2:
        return False
    if is_same_leaf_traversal(root1.left, root2.left) and is_same_leaf_traversal(root1.right, root2.right):
        if not root1.left and not root1.right:
            return root1.val == root2.val
        return leaf_traversal(root1.left) == leaf_traversal(root2.left) and leaf_traversal(root1.right) == leaf_traversal(root2.right)
    return False

迭代算法

上面的算法使用了递归实现。也可以使用非递归的方式实现，即使用栈来遍历二叉树。具体步骤如下：

1. 对于两棵二叉树，分别使用栈来遍历它们的叶子节点。
2. 如果两个栈的长度不相等，则它们的叶子遍历序列不相同，直接返回 False。
3. 依次比较两个栈中的各个叶子节点的值是否相等，如果有不相等的，则它们的叶子遍历序列不相同，直接返回 False。
4. 如果全部叶子节点的值都相等，则它们的叶子遍历序列相同，返回 True。

下面是 Python 代码实现：

def leaf_traversal_iter(root):
    """
    计算二叉树的叶子遍历序列（迭代版本）
    """
    if not root:
        return []
    stack = [root]
    res = []
    while stack:
        node = stack.pop()
        if not node.left and not node.right:
            res.append(node.val)
        if node.right:
            stack.append(node.right)
        if node.left:
            stack.append(node.left)
    return res

def is_same_leaf_traversal_iter(root1, root2):
    """
    判断两棵二叉树的叶子遍历序列是否相同（迭代版本）
    """
    if not root1 and not root2:
        return True
    if not root1 or not root2:
        return False
    stack1 = [root1]
    stack2 = [root2]
    while stack1 and stack2:
        node1 = stack1.pop()
        node2 = stack2.pop()
        if not node1.left and not node1.right:
            if not node2.left and not node2.right:
                if node1.val != node2.val:
                    return False
            else:
                return False
        elif not node2.left and not node2.right:
            return False
        elif node1.left and node2.left:
            stack1.append(node1.left)
            stack2.append(node2.left)
        elif node1.left or node2.left:
            return False
        if node1.right and node2.right:
            stack1.append(node1.right)
            stack2.append(node2.right)
        elif node1.right or node2.right:
            return False
    return len(stack1) == len(stack2) and all(node1.val == node2.val for node1, node2 in zip(stack1, stack2))

总结

本文介绍了如何检查两棵二叉树的叶子遍历是否相同。我们可以使用递归或迭代算法来解决这个问题。递归算法比较简洁，但是可能会消耗大量的栈空间，而迭代算法则比较复杂，但是可以避免栈溢出的问题。具体哪种算法更适合实际应用，需要根据具体情况来决定。