使用级别顺序遍历检查两棵树是否相互镜像

在数据结构中，树是一种非常重要的数据结构。在树的基础上，我们可以学习更高级别的算法和数据结构。其中，二叉树是一种重要的树形结构。在二叉树中，每个节点最多只有两个子节点。这种树形结构在计算机科学中有广泛应用，例如在搜索算法、排序算法、图形处理等领域。

在二叉树中，如果两个树是相互镜像的，那么它们的形状非常相似，但是子节点的位置互相对称。例如，下面的两棵树就是相互镜像的：

     1             1
   /   \         /   \
  2     3       3     2
 / \   / \     / \   / \
4   5 6   7   7   6 5   4

在这篇教程中，我们将介绍如何使用级别顺序遍历来检查两棵树是否相互镜像。

级别顺序遍历

在二叉树中，有三种常见的遍历方式：前序遍历、中序遍历和后序遍历。这三种遍历方式都是深度优先遍历（Depth First Traversal）的形式。深度优先遍历的方式是，从根节点开始，沿着一条路径一直走到最深的节点，然后返回到上一个分支点，继续走其它的分支，直到遍历完整棵树。

另一种遍历方式是广度优先遍历（Breadth First Traversal），也叫做层级遍历（Level Order Traversal）。层级遍历是从根节点开始，按层级顺序遍历所有节点的一种遍历方式。在二叉树中，我们使用队列（Queue）这个数据结构来实现层级遍历。具体步骤如下：

1. 将根节点加入队列；
2. 如果队列不为空，说明还有节点未遍历，继续执行步骤3~5；
3. 取出队列首部的节点；
4. 将该节点的左子节点和右子节点加入队列；
5. 重复执行2~4。

使用层级遍历来检查两棵树是否相互镜像的步骤如下：

1. 分别对两棵树进行层级遍历，并在遍历时保存每一层的节点到一个数组中；
2. 对比两棵树的每一层节点是否互为镜像，如果全部满足，则这两棵树是相互镜像的；否则，这两棵树不相互镜像。

下面是使用Java语言实现的代码：

import java.util.*;

class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode(int x) { val = x; }
}

class Solution {
    public boolean isSymmetric(TreeNode root) {
        if (root == null) {
            return true;
        }

        Queue<TreeNode> q1 = new LinkedList<>();
        Queue<TreeNode> q2 = new LinkedList<>();
        q1.offer(root.left);
        q2.offer(root.right);

        while (!q1.isEmpty() && !q2.isEmpty()) {
            int len = q1.size();
            if (len != q2.size()) {
                return false;
            }

            List<TreeNode> list1 = new ArrayList<>();
            List<TreeNode> list2 = new ArrayList<>();
            for (int i = 0; i < len; i++) {
                TreeNode node1 = q1.poll();
                TreeNode node2 = q2.poll();
                list1.add(node1);
                list2.add(node2);

                if (node1 == null && node2 == null) {
                    continue;
                } else if (node1 != null && node2 != null && node1.val == node2.val) {
                    q1.offer(node1.left);
                    q1.offer(node1.right);
                    q2.offer(node2.right);
                    q2.offer(node2.left);
                } else {
                    return false;
                }
            }

            int size1 = list1.size();
            int size2 = list2.size();
            for (int i = 0; i < size1/2; i++) {
                if (list1.get(i) == null && list1.get(size1-i-1) == null) {
                    continue;
                } else if (list1.get(i) != null && list1.get(size1-i-1) != null && list1.get(i).val == list1.get(size1-i-1).val) {
                    continue;
                } else {
                    return false;
                }
            }
            for (int i = 0; i < size2/2; i++) {
                if (list2.get(i) == null && list2.get(size2-i-1) == null) {
                    continue;
                } else if (list2.get(i) != null && list2.get(size2-i-1) != null && list2.get(i).val == list2.get(size2-i-1).val) {
                    continue;
                } else {
                    return false;
                }
            }
        }

        return true;
    }
}

在这个代码中，我们使用了两个队列 q1 和 q2 来分别保存两棵树的节点。在每一层遍历时，我们使用了两个 List list1 和 list2 分别保存两棵树的每一层节点。在对比两棵树的每一层节点时，我们使用了对称性检查的方法，从而判断两棵树是否相互镜像。如果两棵树相互镜像，则这个算法可以在 O(n) 的时间内完成。