相同的树和对称二叉树都可以使用递归实现。

1. • 相同的树

题目链接：https://leetcode.cn/problems/same-tree/solution/xiang-tong-de-shu-by-leetcode-solution/

1.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 isSameTree(self, p: Optional[TreeNode], q: Optional[TreeNode]) -> bool:
        if not p and not q:
            return True
        elif not p or not q:
            return False
        elif p.val != q.val:
            return False
        else:
            return self.isSameTree(p.left,q.left) and self.isSameTree(p.right,q.right)

1.2.队列、广度优先搜索

使用两个队列分别存储两个二叉树的节点。初始时将两个二叉树的根节点分别加入两个队列。

当队列两个队列都不为空时，进行如下循环：

从两个队列头各取出一个节点进行比较：

如果两个节点的值不相同 return False

判断两个节点的子节点是否为空，如果只有一个节点的左子节点（或右子节点）为空 return False

将两个节点的非空子节点分别加入两个队列，进行下一次循环

如果搜索结束时两个队列同时为空，则两个二叉树相同；如果只有一个队列为空 return False

class Solution:
    def isSameTree(self, p: TreeNode, q: TreeNode) -> bool:
        if not p and not q:
            return True
        if not p or not q:
            return False
        
        queue1 = [p]
        queue2 = [q]

        while queue1 and queue2:
            node1 = queue1.pop(0)
            node2 = queue2.pop(0)
            if node1.val != node2.val:
                return False
            left1, right1 = node1.left, node1.right
            left2, right2 = node2.left, node2.right
            if (not left1) ^ (not left2):
                return False
            if (not right1) ^ (not right2):
                return False
            if left1:
                queue1.append(left1)
            if right1:
                queue1.append(right1)
            if left2:
                queue2.append(left2)
            if right2:
                queue2.append(right2)
        return not queue1 and not queue2

2.对称二叉树

给你一个二叉树的根节点 root ， 检查它是否轴对称。

题目链接： https://leetcode.cn/problems/symmetric-tree/

使用递归，定义一个比较左右子树是否对称的函数，输入为两个节点（比如左子节点和右子节点）

将问题转换为 --> 比较左右子节点的值是否相同 + 比较树的外侧和内侧是否分别对称，即左子节点的左子树和右子节点的右子树是否对称 以及 左子节点的右子树和右子节点的左子树是否对称

class Solution:
    def isSymmetric(self, root: Optional[TreeNode]) -> bool:

        def twonodeSymmetric(p,q):
            if not p and not q:
                return True
            elif not p or not q:
                return False
            elif p.val != q.val:
                return False
            else:
                return twonodeSymmetric(p.left,q.right) and twonodeSymmetric(p.right,q.left)

        if not root:
            return True
        else:
            return twonodeSymmetric(root.left,root.right)