剑指 Offer 28 -- 对称的二叉树

最新推荐文章于 2021-07-22 22:38:33 发布

xujinshan361

最新推荐文章于 2021-07-22 22:38:33 发布

阅读量100

点赞数

分类专栏：剑指 Offer 文章标签：剑指Offer java 对称的二叉树递归队列

本文链接：https://blog.csdn.net/xu_jin_shan/article/details/115270625

版权

剑指 Offer 专栏收录该内容

37 篇文章 0 订阅

订阅专栏

这篇博客探讨了如何判断一棵二叉树是否对称，提供了两种方法：递归和迭代。递归方法通过比较当前节点的左右子节点来检查对称性；迭代方法利用队列，将根节点入队两次，并逐对比较节点值及其子节点的镜像关系。示例代码展示了这两种方法的实现，并给出了测试用例。

摘要由CSDN通过智能技术生成

剑指 Offer 28. 对称的二叉树

题目：

请实现一个函数，用来判断一棵二叉树是不是对称的。如果一棵二叉树和它的镜像一样，那么它是对称的。

例如，二叉树 [1,2,2,3,4,4,3] 是对称的。

    1
   / \
  2   2
 / \ / \
3  4 4  3
但是下面这个 [1,2,2,null,3,null,3] 则不是镜像对称的:

    1
   / \
  2   2
   \   \
   3    3

示例 1：

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

示例 2：

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

限制：

0 <= 节点个数 <= 1000

代码：

package com.xujinshan.offer.offer28;

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

/**
 * @Author: xujinshan361@163.com
 * 剑指 Offer 28 -- 对称的二叉树
 * 请实现一个函数，用来判断一棵二叉树是不是对称的。如果一棵二叉树和它的镜像一样，
 * 那么它是对称的。
 * <p>
 * 例如，二叉树 [1,2,2,3,4,4,3] 是对称的。
 * 1
 * / \
 * 2   2
 * / \ / \
 * 3  4 4  3
 * 但是下面这个 [1,2,2,null,3,null,3] 则不是镜像对称的:
 * <p>
 * 1
 * / \
 * 2   2
 * \   \
 * 3    3
 * <p>
 * 示例 1：
 * <p>
 * 输入：root = [1,2,2,3,4,4,3]
 * 输出：true
 * <p>
 * 示例 2：
 * <p>
 * 输入：root = [1,2,2,null,3,null,3]
 * 输出：false
 * <p>
 * <p>
 * 限制：
 * <p>
 * 0 <= 节点个数 <= 1000
 */
class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;

    TreeNode() {

    }

    TreeNode(int val) {
        this.val = val;
    }

    TreeNode(int val, TreeNode left, TreeNode right) {
        this.val = val;
        this.left = left;
        this.right = right;
    }
}

/**
 * 递归
 */
class Solution01 {
    public boolean isSymmetric(TreeNode root) {
        return check(root, root);
    }

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

/**
 * 迭代方法
 * 首先引入一个队列，初始化时把根节点入队列俩次。每次提前俩个节点并比较值（队列中每俩个连续的节点应该是
 * 相等的，而且它们的子树互为镜像）然后将两个节点的左右子节点按照相反的顺序插入队列中，当队列为空时，
 * 或者检测到不对称时，算法结束。
 */
class Solution02 {
    public boolean isSymmetric(TreeNode root) {
        return check(root, root);
    }

    private boolean check(TreeNode u, TreeNode v) {
        Queue<TreeNode> q = new LinkedList<>();
        q.offer(u);
        q.offer(v);
        while (!q.isEmpty()) {
            u = q.poll();
            v = q.poll();
            if (u == null && v == null) {
                continue;
            }
            if ((u == null || v == null) || u.val != v.val) {
                return false;
            }

            q.offer(u.left);
            q.offer(v.right);

            q.offer(u.right);
            q.offer(v.left);
        }
        return true;
    }
}


public class Offer28 {
    public static void main(String[] args) {
        System.out.println(new Solution01().isSymmetric(
                new TreeNode(1, new TreeNode(2, new TreeNode(3, null, null), new TreeNode(4, null, null))
                        , new TreeNode(2, new TreeNode(4, null, null), new TreeNode(3, null, null)))));
    }
}