洋钱罐高频编程考题：对称二叉树（简单）

题目描述

给你一个二叉树的根节点 root ， 检查它是否轴对称。

示例 1：

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

示例 2：

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

提示：

• 树中节点数目在范围 [1, 1000] 内
• -100 <= Node.val <= 100

进阶：你可以运用递归和迭代两种方法解决这个问题吗？

解题思路

要检查一个二叉树是否是轴对称的，我们可以使用递归或迭代的方法。这里提供了两种方法的解题思路和复杂度分析。

1. 递归方法

递归检查子树：我们需要检查左右子树是否对称。对称的定义是：

• 左子树的左子树与右子树的右子树对称。
• 左子树的右子树与右子树的左子树对称。

步骤：

1. 基本情况：如果两个子树都为空，则它们是对称的；如果一个子树为空而另一个子树不为空，则它们不是对称的。
2. 递归条件：检查当前两个节点的值是否相等；递归检查左子树的左子树与右子树的右子树；递归检查左子树的右子树与右子树的左子树。

2. 迭代方法

使用队列：可以使用队列来模拟递归检查过程，通过层次遍历来比较每层的节点对称性。步骤：

1. 使用一个队列来存储节点对。
2. 初始时将根节点的左右子节点加入队列。
3. 循环处理队列中的节点对：
   • 从队列中取出一对节点。
   • 如果两个节点都为空，继续下一对节点。
   • 如果一个节点为空而另一个不为空，返回 false。
   • 如果两个节点的值不相等，返回 false。
   • 将节点对的子节点按照对称的方式加入队列。

复杂度分析

1.递归方法

• 时间复杂度：O(n)，其中 n 是树中的节点数。每个节点都被访问一次。
• 空间复杂度：O(h)，其中 h 是树的高度。递归调用的栈深度最大为树的高度。

2. 迭代方法

• 时间复杂度：O(n)，与递归方法相同，每个节点都被访问一次。
• 空间复杂度：O(n)，在最坏情况下，队列中可能存储所有节点，特别是树完全时。

代码实现

package org.zyf.javabasic.letcode.hot100.tree;

import org.zyf.javabasic.letcode.tree.base.TreeNode;

import java.util.LinkedList;
import java.util.Queue;

/**
 * @program: zyfboot-javabasic
 * @description: 对称二叉树（简单）
 * @author: zhangyanfeng
 * @create: 2024-08-22 11:15
 **/
public class IsSymmetricSolution {

    public boolean isSymmetric1(TreeNode root) {
        if (root == null) {
            return true;
        }
        return isMirror(root.left, root.right);
    }

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

    public boolean isSymmetric2(TreeNode root) {
        if (root == null) {
            return true;
        }

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

        while (!queue.isEmpty()) {
            TreeNode t1 = queue.poll();
            TreeNode t2 = queue.poll();

            if (t1 == null && t2 == null) {
                continue;
            }
            if (t1 == null || t2 == null) {
                return false;
            }
            if (t1.val != t2.val) {
                return false;
            }

            queue.offer(t1.left);
            queue.offer(t2.right);
            queue.offer(t1.right);
            queue.offer(t2.left);
        }

        return true;
    }

    public static void main(String[] args) {
        IsSymmetricSolution solution = new IsSymmetricSolution();

        // 示例 1: 对称的二叉树
        TreeNode root1 = new TreeNode(1);
        root1.left = new TreeNode(2);
        root1.right = new TreeNode(2);
        root1.left.left = new TreeNode(3);
        root1.left.right = new TreeNode(4);
        root1.right.left = new TreeNode(4);
        root1.right.right = new TreeNode(3);

        System.out.println("Example 1: " + solution.isSymmetric1(root1)); // 输出: true

        // 示例 2: 不对称的二叉树
        TreeNode root2 = new TreeNode(1);
        root2.left = new TreeNode(2);
        root2.right = new TreeNode(2);
        root2.left.right = new TreeNode(3);
        root2.right.right = new TreeNode(3);

        System.out.println("Example 2: " + solution.isSymmetric2(root2)); // 输出: false

        // 示例 3: 空树
        TreeNode root3 = null;

        System.out.println("Example 3: " + solution.isSymmetric2(root3)); // 输出: true
    }
}

  具体可见：LeetCode 热题 100 回顾_leetcode热题100-CSDN博客