2025/09/06 leetCode101. 对称二叉树

101. 对称二叉树 - 力扣（LeetCode）

 一、递归解法：

解法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:
        def isMirror(t1, t2):
            if not t1 and not t2: return True
            if not t1 or not t2: return False
            return t1.val == t2.val and \
                   isMirror(t1.left, t2.right) and \
                   isMirror(t1.right, t2.left)

        return isMirror(root.left, root.right)

以下两句的顺序不能颠倒：

if not t1 and not t2: return True
if not t1 or not t2: return False

知识点：python中的or

在 Python 中：

①

A or B 表示：如果 A 为真（truthy），就返回 A；否则返回 B。

它是 逻辑“或”：只要有一个为真，结果就为真。

②Python 中的 or 是返回值表达式，不是单纯布尔值。

a = 0
b = 123
print(a or b)    # 👉 123，因为 a 为 False，返回 b

表达式	结果	解释
0 or 123	123	0 为假 → 返回 123
[] or [1]	[1]	空列表为假 → 返回非空列表
'a' or 'b'	'a'	'a' 为真 → 返回 'a'
None or 1	1	None 为假 → 返回 1

③用途

name = user_input or "Default Name"

如果用户输入是空的，就使用默认值 "Default Name"

④and的优先级高于or

⑤区别：

C/C++ 的 || 只是返回布尔值（true / false）

Python 的 or 会返回第一个为真的值或最后一个为假值，既是逻辑运算符也是表达式运算符（逻辑判断里是“有真则真”，表达式里是“遇真返回真值”）

解法2：

class Solution:
    def isSymmetric(self, root: TreeNode) -> bool:
        if not root:
            return True
        return self.compare(root.left, root.right)

    def compare(self, left, right):
        # 1.排除空节点的情况
        if left == None and right == None: return True
        elif left != None and right == None: return False
        elif left == None and right != None: return False
        # 2.排除数值不相同的情况
        elif left.val != right.val: return False

        # 3. 剩余左右节点均不为空，且数值相同的情况
        # 此时做递归，对下一层做判断
        outside = self.compare(left.left, right.right)
        inside = self.compare(left.right, right.left)
        return inside and outside

 

二、迭代法

解法1：使用队列

class Solution:
    def isSymmetric(self, root: TreeNode) -> bool:
        if not root:
            return True
        queue = collections.deque()
        queue.append(root.left)
        queue.append(root.right)
        while queue:
            leftNode = queue.popleft()
            rightNode = queue.popleft()
            if not leftNode and not rightNode:
                continue
            if not leftNode or not rightNode or leftNode.val != rightNode.val:
                return False
            queue.append(leftNode.left)
            queue.append(rightNode.right)
            queue.append(leftNode.right)
            queue.append(rightNode.left)
        return True

解法2：使用栈

class Solution:
    def isSymmetric(self, root: TreeNode) -> bool:
        if not root:
            return True
        st = []
        st.append(root.left)
        st.append(root.right)
        while st:
            rightNode = st.pop()
            leftNode = st.pop()
            if not leftNode and not rightNode:
                continue
            if not leftNode or not rightNode or leftNode.val != rightNode.val:
                return False
            st.append(leftNode.left)
            st.append(rightNode.right)
            st.append(leftNode.right)
            st.append(rightNode.left)
        return True

三、层次遍历：

自己开始做这题也想到用层序遍历，但是很多细节问题没有想到，包括怎么把每一次的数值进行比较的问题，没有想到直接把每一层的数值列表倒序进行比较就可以。

class Solution:
    def isSymmetric(self, root: TreeNode) -> bool:
        if not root:
            return True
        queue = collections.deque()
        queue.append(root.left)
        queue.append(root.right)
        while queue:
            level_size = len(queue)
            if level_size % 2 != 0:
                return False

            level_vals = []
            for _ in range(level_size):
                node = queue.popleft()
                if node:
                    level_vals.append(node.val)
                    queue.append(node.left)
                    queue.append(node.right)
                else:
                    level_vals.append(None)
            if level_vals != level_vals[::-1]:
                return False
        return True

100. 相同的树 - 力扣（LeetCode）

递归法：

class Solution:
    def isSameTree(self, p: Optional[TreeNode], q: Optional[TreeNode]) -> bool:
        return self.compare(p, q)
    
    def compare(self, p: TreeNode, q: TreeNode) -> bool:
        if not p and not q:
            return True
        elif not p or not q:
            return False
        else:
            return p.val == q.val and self.compare(p.left, q.left) and self.compare(p.right, q.right)

层序遍历：

# 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
        if not p or not q: return False
        queue_p = collections.deque([p])
        queue_q = collections.deque([q])
        while queue_p and queue_q:
            level_size_p = len(queue_p)
            level_size_q = len(queue_q)
            if level_size_p != level_size_q:
                return False
            level_vals_p = []
            level_vals_q = []
            for _ in range(level_size_p):
                node_p = queue_p.popleft()
                node_q = queue_q.popleft()
                if node_p and node_q:
                    level_vals_p.append(node_p.val)
                    level_vals_q.append(node_q.val)
                    queue_p.append(node_p.left)
                    queue_p.append(node_p.right)
                    queue_q.append(node_q.left)
                    queue_q.append(node_q.right)
                elif not node_p and not node_q:
                    level_vals_p.append(None)
                    level_vals_q.append(None)
                else:
                    return False
            if level_vals_p != level_vals_q:
                return False
        return True
        

572. 另一棵树的子树 - 力扣（LeetCode）

主函数用栈辅助前序遍历root，用递归函数compare将root的子树与subRoot对比。

# 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 isSubtree(self, root: Optional[TreeNode], subRoot: Optional[TreeNode]) -> bool:
        st = [root]
        while st:
            node = st.pop()
            if self.compare(node, subRoot): return True
            else:
                if node.right: 
                    st.append(node.right)
                if node.left:
                    st.append(node.left)
        return False

    def compare(self, p: TreeNode, q: TreeNode) -> bool:
        if not p and not q: return True
        elif not p or not q: return False
        else: 
            return p.val == q.val and \
            self.compare(p.left, q.left) and \
            self.compare(p.right, q.right)