LeetCode 101. 对称二叉树

题目描述

给定一个二叉树，检查它是否是镜像对称的。

示例 1：

输入：root = [1,2,2,3,4,4,3]
输出：true

示例 2：

输入：root = [1,2,2,null,3,null,3]
输出：false

示例 3：

输入：root = [1,2,2,1,1,1,1]
输出：true

示例 4：

输入：root = []
输出：true

提示：

• 树中节点数目范围在 [0, 1000] 内
• -100 <= Node.val <= 100
• 题目保证 TreeNode.val 为 int 范围内的值

Java 实现解法

方法一：递归

/**
 * Definition for a binary tree node.
 * public 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;
        return isMirror(root.left, root.right);
    }

    private boolean isMirror(TreeNode left, TreeNode right) {
        if (left == null && right == null) return true;
        if (left == null || right == null) return false;
        return left.val == right.val && isMirror(left.left, right.right) && isMirror(left.right, right.left);
    }
}

方法二：迭代

/**
 * Definition for a binary tree node.
 * public 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> queue = new LinkedList<>();
        queue.offer(root.left);
        queue.offer(root.right);

        while (!queue.isEmpty()) {
            TreeNode left = queue.poll();
            TreeNode right = queue.poll();

            if (left == null && right == null) continue;
            if (left == null || right == null) return false;
            if (left.val != right.val) return false;

            queue.offer(left.left);
            queue.offer(right.right);
            queue.offer(left.right);
            queue.offer(right.left);
        }
        return true;
    }
}

解题思路

方法一：

• 递归方法：
  • 如果两个子节点都为空，说明当前节点是对称的。
  • 如果一个子节点为空而另一个不为空，或者两个子节点的值不相等，则当前节点不是对称的。
  • 递归地检查当前节点的左右子树是否互为镜像。

这种方法的时间复杂度是 O(n)，其中 n 是树中节点的数量，因为每个节点恰好被访问一次。空间复杂度是 O(h)，其中 h 是树的高度，这取决于递归调用的栈空间，在最坏情况下（树完全不平衡，如链状结构），空间复杂度为 O(n)。

方法二：

• 层次遍历（广度优先搜索）：
  • 使用一个队列来存储每一层的节点。
  • 如果根节点为空，直接返回 true。
  • 初始化一个队列并将根节点的左右子节点加入队列，然后开始遍历。
  • 在每次迭代中，取出队列中的两个节点，检查它们是否相等。
  • 如果两个节点都不为空，将它们的子节点加入队列，但要交叉加入，即左节点的左孩子与右节点的右孩子一组，右节点的左孩子与左节点的右孩子一组。
  • 如果在任何时候发现不相等的节点或一个节点为空而另一个不为空，则返回 false。
  • 如果遍历完所有节点都没有发现不对称的情况，则返回 true。

这种方法的时间复杂度是 O(n)，其中 n 是树中节点的数量，因为每个节点恰好被访问一次。空间复杂度是 O(m)，其中 m 是队列中存储的最大节点数，即树的最大宽度。在最坏情况下，如果树完全不平衡，空间复杂度为 O(n)。

注：题目来源leetcode网站