LeetCode 101：对称树DFS代码无法通过所有测试用例求排查

你的代码始终返回False，核心问题有两个：

• 直接比较TreeNode对象：你把整个节点对象存入holder_left和holder_right，但即使两个节点值完全相同，它们是不同的实例对象，对象引用永远不相等，所以holder_left != holder_right永远成立，必然返回False。
• 未处理空节点：对称树的判断必须考虑空节点的位置，比如左子树为空时，对应的右子树位置也必须为空。你的遍历逻辑只处理存在的节点，漏掉了空节点的记录，会导致错误匹配。

修复后的代码 #

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def isSymmetric(self, root):
        holder_left = []
        holder_right = []
        
        def Traverse_left(current_node):
            # 记录当前节点值，空节点用None标记
            holder_left.append(current_node.val if current_node else None)
            if current_node:
                Traverse_left(current_node.left)
                Traverse_left(current_node.right)
        
        def Traverse_right(current_node):
            # 记录当前节点值，空节点用None标记
            holder_right.append(current_node.val if current_node else None)
            if current_node:
                Traverse_right(current_node.right)
                Traverse_right(current_node.left)
        
        Traverse_left(root)
        Traverse_right(root)
        
        return holder_left == holder_right

关键修改点 #

1. 存储节点值而非对象：把holder_left.append(current_node)改成holder_left.append(current_node.val if current_node else None)，这样比较的是节点的值，而非对象引用。
2. 添加空节点处理：无论节点是否为空，都要记录到遍历序列中，空节点用None表示，确保对称位置的空/非空状态能被正确对比。
3. 遍历逻辑调整：在递归前先记录当前节点（包括空节点），再递归子节点，保证遍历序列的顺序符合对称对比要求。

另外还有更高效的递归写法，无需额外存储遍历序列，直接在递归中对比左右子树的对称情况：

class Solution(object):
    def isSymmetric(self, root):
        def is_mirror(left, right):
            # 两个都为空，对称
            if not left and not right:
                return True
            # 一个空一个非空，不对称
            if not left or not right:
                return False
            # 值相等，且左的左等于右的右，左的右等于右的左
            return left.val == right.val and is_mirror(left.left, right.right) and is_mirror(left.right, right.left)
        
        return is_mirror(root, root)

这种写法空间复杂度更低，不需要额外存储数组，直接递归对比对称位置的节点。

内容的提问来源于stack exchange，提问作者Shahryar