101. 对称二叉树

题目-简单难度

给你一个二叉树的根节点 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

进阶：

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

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/summary-ranges
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

1.dfs

时间
48ms
击败 49.52%使用 Python3 的用户
内存
15.85MB
击败 27.16%使用 Python3 的用户

# 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:
        # 如果根节点为空, 直接判断为True
        if not root: return True

        # dfs判断是否对称
        def dfs(l,r):
            # 如果左右都为空,返回True
            if not l and not r:
                return True
            # 基于两者都为空已经被判断的前提下, 判断如果其中一个为空, 另一个不为空, 则返回False
            if not l or not r:
                return False
            # 如果当前节点值相同,左侧左节点与右侧右节点相同, 右侧左节点与左侧右节点相同，返回True
            # 但凡遇到一个不相同则返回False
            return l.val == r.val and dfs(l.left,r.right) and dfs(r.left,l.right)
        
        # 从根节点的左右节点开始递归
        return dfs(root.left,root.right)

2. bfs+列表

时间
36ms
击败 96.95%使用 Python3 的用户
内存
15.72MB
击败 74.23%使用 Python3 的用户

# 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:
        # 如果根节点为空, 直接判断为True
        if not root: return True
        # 根节点添加到列表进行遍历
        li = [root]
        while li:
            # 每次一行，添加到lis列表
            lis = []
            for _ in range(len(li)):
                a = li.pop(0)
                # 判断左节点是否存在，不存在则在lis中添加字符串None替代空节点的值
                if a.left:
                    lis.append(a.left.val)
                    li.append(a.left)
                else:
                    lis.append('None')
                # 同上
                if a.right:
                    lis.append(a.right.val)
                    li.append(a.right)
                else:
                    lis.append('None')
            # 判断是否对称
            if lis != lis[::-1]:
                return False
        return True
                
            

3. bfs

时间
48ms
击败 49.52%使用 Python3 的用户
内存
15.78MB
击败 55.56%使用 Python3 的用户

# 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:
        # 如果根节点为空, 直接判断为True
        if not root: return True
        # 根节点添加到列表进行遍历
        li = [root.left,root.right]
        while li:
            # 每次获取两个节点进行对比
            l = li.pop(0)
            r = li.pop(0)
            # 如果都为空,则直接跳过本次遍历,进行下一次
            if not l and not r:
                continue
            # 如果有单一项为空, 或者两者的值不同, 直接返回False
            if (not l or not r) or (l.val != r.val):
                return False
            # 添加左侧左节点, 右侧右节点,方便之后获取并对比两个节点
            li.append(l.left)
            li.append(r.right)
            # 添加右侧左节点, 左侧右节点,让li列表每次对比的两个节点是判断对称所需求的
            li.append(l.right)
            li.append(r.left)
        return True