对称二叉树-力扣

思路

• 是否对称？
  答：比较根节点的左子树与右子树是不是相互翻转的；需要递归遍历2棵树，用后序遍历，一棵左右中，另一颗右左中。
• 递归法
• 递归三要素：
  • 递归函数的参数和返回值
    比较根节点的左右子树是否互相翻转，需要2个参数:左子树节点、右子树结点
    返回值：bool型
  • 终止条件
    1）左节点为空，右节点不为空，返回false
  2. 左节点不为空，右节点为空，返回fasle
  3. 左节点为空，右节点为空，返回true
  4. 左节点值不等于右节点值，返回false
  • 单层逻辑
    此时，左右结点不为空且左右结点值相等
    外侧：左节点的左孩子，与右节点的右孩子比较是否相等
    内侧：左节点的右孩子，与右节点的左孩子比较是否相等
    若左右都对称，返回true；有一侧不对称，返回fasle

# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
# 
# @param pRoot TreeNode类 
# @return bool布尔型
#
class Solution:
    def isSymmetrical(self , pRoot: TreeNode) -> bool:
        # 递归法
        #为空处理
        if not pRoot:
            return True
        return self.compare(pRoot.left, pRoot.right)
    
    def compare(self,left,right)->bool:
        #排除空节点
        if left == None and right != None: return False
        elif left != None and right == None: return False
        elif left==None and right == None: return True
        #排除值不相等的情况
        elif left.val != right.val: return False
        
        #此时，左右结点都不为空且值都相等，才进行递归
        #左子树：左，右子树：右
        outsider=self.compare(left.left, right.right)
        #左子树：右，右子树：左
        insider=self.compare(left.right, right.left)
        #左子树：中，右子树：中；逻辑处理
        isSame=outsider and insider
        return isSame       
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

• 迭代法
  使用队列来比较两个树（根节点的左右子树）是否相互翻转，这不是层序遍历，本质是把左右两个子树要比较的元素顺序放进一个容器，然后成对成对的取出来进行比较。因此，不仅队列可以，栈、数组也可以作容器。

# 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
from collections import deque
class Solution:
    def isSymmetric(self, root: Optional[TreeNode]) -> bool:
        #迭代法，用双头队列做容器
        #为空处理
        if not root:
            return True
        que=deque()
        que.append(root.left)
        que.append(root.right)
        #判断根节点的左右子树是否翻转
        while que:
            leftnode=que.popleft()
            rightnode=que.popleft()
            #若都为空，表示对称
            if leftnode==None and rightnode==None:
                continue
            #若左右一个节点不为空，或都不为空但值不等，不对称
            if not leftnode or not rightnode or leftnode.val != rightnode.val:
                return False
            #加入左节点左孩子
            que.append(leftnode.left)
            #右节点右孩子
            que.append(rightnode.right)
            #左节点右孩子
            que.append(leftnode.right)
            #右节点左孩子
            que.append(rightnode.left)
        return True
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35