【Leetcode笔记】对称二叉树

最新推荐文章于 2024-09-16 06:54:08 发布

zyzcuczyu

最新推荐文章于 2024-09-16 06:54:08 发布

阅读量91

点赞数

文章标签： leetcode 笔记算法

本文链接：https://blog.csdn.net/zyzcuczyu/article/details/131216657

版权

文章介绍了如何使用递归、迭代和层序遍历三种方法解决LeetCode上的对称二叉树问题。通过比较二叉树的左右子节点来判断其对称性，递归法直观但需考虑多种情况，迭代法则利用队列处理，层序遍历则关注每层节点数量和值的对称性。

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

Leetcode原题链接：
对称二叉树

一、思路

后序遍历（左右中），递归最好理解，先比子节点，若对称再返回True，继续向上比较
实际上迭代遍历和层序遍历也可以实现，具体看代码吧，有点难描述。。

二、代码

1、递归遍历

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def isSymmetric(self, root: Optional[TreeNode]) -> bool:
        return self.compare(root.left, root.right)

    def compare(self, l_node, r_node):
        if not l_node and not r_node:
            return True
        elif not l_node and r_node:
            return False
        elif l_node and not r_node:
            return False
        elif l_node.val != r_node.val:
            return False
        else:
            outside = self.compare(l_node.left, r_node.right)
            inside = self.compare(l_node.right, r_node.left)
            result = (outside and inside)
            return result

2、迭代遍历

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def isSymmetric(self, root: Optional[TreeNode]) -> bool:
        queue = []
        queue.append(root.left)
        queue.append(root.right)
        while queue:
            l_node = queue.pop(0)
            r_node = queue.pop(0)
            if not l_node and not r_node:
                continue
            if not l_node or not r_node or l_node.val != r_node.val:
                return False
            queue.append(l_node.left)
            queue.append(r_node.right)
            queue.append(l_node.right)
            queue.append(r_node.left)
        return True

迭代遍历的话，最初放入队列的节点就不只是根节点了，放的是根节点的左右孩子节点
每次加入队列也是分别按照对称的顺序加入左右孩子节点的子节点

3、层序遍历

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def isSymmetric(self, root: Optional[TreeNode]) -> bool:
        queue = [root.left, root.right]
        while queue:
            size = len(queue)
            if size%2 != 0:
                return False
            tmp = []
            for i in range(size):
                node = queue.pop(0)
                if node:
                    tmp.append(node.val)
                    queue.append(node.left)
                    queue.append(node.right)
                else:
                    tmp.append(None)
            if tmp != tmp[::-1]:
                return False
        return True