LeetCode101——对称二叉树

最新推荐文章于 2025-07-02 00:30:00 发布

清風逐尘乀

最新推荐文章于 2025-07-02 00:30:00 发布

阅读量477

点赞数

CC 4.0 BY-SA版权

分类专栏： LeetCode题解文章标签： LeetCode Java 广度优先遍历对称二叉树递归

本文链接：https://blog.youkuaiyun.com/qq_41231926/article/details/81582778

LeetCode题解专栏收录该内容

263 篇文章

订阅专栏

本文介绍了三种不同的方法来判断一棵二叉树是否为对称二叉树，包括通过翻转右子树并比较、层序遍历检查回文性质以及递归比较左右子树。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

我的LeetCode代码仓：https://github.com/617076674/LeetCode

原题链接：https://leetcode-cn.com/problems/symmetric-tree/description/

题目描述：

知识点：递归，队列

思路一：翻转根结点的右子树，比较与根结点的左子树是否相同

具体实现步骤如下：

（1）如果root结点为null，则直接返回true。

（2）如果root结点没有任何孩子，返回true。

（3）如果root结点只有左孩子或者只有右孩子，返回false。

（4）判断root结点的左子树和右子树翻转之后的树是否相同，如果相同，则返回true；不相同，则返回false。

时间复杂度是O(n)，其中n为树的节点数。空间复杂度是O(h)，其中h为树的高度。

JAVA代码：

public class Solution {
    public boolean isSymmetric(TreeNode root) {
        if(root == null) {
            return true;
        }else if(root.left == null && root.right == null) {
            return true;
        }else if(root.left != null && root.right == null) {
            return false;
        }else if(root.left == null && root.right != null) {
            return false;
        }else {
            return isSameTree(root.left, inverseTree(root.right));
        }
    }

    private TreeNode inverseTree(TreeNode root) {
        if(root == null) {
            return null;
        }
        inverseTree(root.left);
        inverseTree(root.right);
        TreeNode temp = root.left;
        root.left = root.right;
        root.right = temp;
        return root;
    }

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

JAVA解题报告：

思路二：层序遍历二叉树，判断每一层中的元素是否符合回文的性质

具体实现步骤如下：

（1）如果root结点为null，则直接返回true。

（2）新建一个队列，并将根结点入队。

（3）在while循环中，层序遍历该根结点对应的二叉树。

a：记录队列中的元素个数level。

b：新建一个List类型的变量list，用来记录每一层的结点。

c：while(level > 0)进行如下循环：

c-1：让level值-1。

c-2：让队首元素temp出队并将其加入到list中。

c-3：如果temp不为null，则将其左右孩子入队。（这里不用判断左右孩子是否为空，而改为判断temp是否为空。因为在本题中，为了比较每一层左右两边的对称性，空也是需要入队并最终出队加入list的。）

（4）设立一个指针从list首开始往后走，另一个指针从list尾开始往前走，比较两个指针所指位置的值是否相等，如果不相等，直接返回false。

（5）结束整个层序遍历后，直接返回true。

时间复杂度和空间复杂度均是O(n)，其中n为树的节点数。

JAVA代码：

public class Solution {
    public boolean isSymmetric(TreeNode root) {
        if(root == null) {
            return true;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        while(!queue.isEmpty()) {
            int level = queue.size();
            List<TreeNode> list = new ArrayList<>();
            while(level > 0) {
                level--;
                TreeNode temp = queue.poll();
                list.add(temp);
                if(temp != null) {
                    queue.add(temp.left);
                    queue.add(temp.right);
                }
            }
            int i = 0;
            int j = list.size() - 1;
            while(i < j) {
                if(list.get(i) == null && list.get(j) == null) {
                    i++;
                    j--;
                    continue;
                }
                if(list.get(i) == null && list.get(j) != null) {
                    return false;
                }
                if(list.get(i) != null && list.get(j) == null) {
                    return false;
                }
                if(list.get(i).val != list.get(j).val) {
                    return false;
                }
                i++;
                j--;
            }
        }
        return true;
    }
}

JAVA解题报告：

思路三：递归地判断根结点的左子树和右子树是否是对称的。

具体实现步骤如下：

（1）如果root结点为null，则直接返回true。

（2）设立一个函数isSymmetric(TreeNode node1, TreeNode node2)，传入两个参数root.left和root.right。

（3）递归地实现b中新建的函数。

a：如果node1和node2均为空，返回true。

b：如果node1或者node2中只有一个为空，返回false。

c：如果node1的val值和node2的val值不相等，返回false。

d：递归地调用isSymmetric(TreeNode node1, TreeNode node2)，判断node1的左子树和node2的右子树是否对称，以及node1的右子树和node2的左子树是否对称，即返回isSymmetric(node1.left, node2.right) && isSymmetric(node1.right, node2.left)。

时间复杂度是O(n)，其中n为树的节点数。空间复杂度是O(h)，其中h为树的高度。

JAVA代码：

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

        return isSymmetric(root.left, root.right);
    }

    private boolean isSymmetric(TreeNode node1, TreeNode node2) {
        if(node1 == null && node2 == null) {
            return true;
        }else if(node1 == null && node2 != null){
            return false;
        }else if(node1 != null && node2 == null){
            return false;
        }else if(node1.val != node2.val){
            return false;
        }
        return isSymmetric(node1.left, node2.right) && isSymmetric(node1.right, node2.left);
    }
}

JAVA解题报告：