代码随想录 Day15

# leetcode 102. 二叉树层序遍历

class Solution:
    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
        if not root:
            return []
        deque = collections.deque([root])
        result = []
        while deque:
            level = []
            length = len(deque)
            for _ in range(length):
                cur = deque.popleft()
                level.append(cur.val)
                if cur.left:
                    deque.append(cur.left)
                if cur.right:
                    deque.append(cur.right)
            result.append(level)
        return result

使用列队的方法。

# 使用队列 collections.deque([])

# 两个方法 .popleft() & .append()

# 广度优先算法的思想（尤其是代码实现），需要好好掌握

比较重要的点在于，通过控制length的长度，使用for _ in range(length)来遍历所有的deque列队。

# leetcode 226. 反转二叉树

很简单：

class Solution:
    def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
        if root:
            root.right, root.left = self.invertTree(root.left), self.invertTree(root.right)
            return root

# leetcode 101. 对称二叉树

前备知识：

copy.copy() & copy.deepcopy() & 直接赋值的区别：

1. 直接赋值 (b = a):

   • 对于可变对象（如列表、字典等）：a 和 b 指向同一个对象，任何一方的修改都会影响另一方。
   • 对于不可变对象（如整数、字符串、元组等）：a 和 b 指向同一个对象，但由于不可变对象的特性，重新赋值不会影响另一方。

2. 浅拷贝 (b = copy.copy(a)):

   • 对于可变对象：创建一个新的对象，但新的对象中的元素仍然引用原来的对象中的元素。对于嵌套的可变对象，修改其中的内容会影响到浅拷贝的副本。
   • 对于不可变对象：浅拷贝实际上没有效果，等同于直接赋值，因为不可变对象本身不能被修改。

3. 深拷贝 (b = copy.deepcopy(a)):

   • 对于可变对象：创建一个完全独立的对象，包括递归地复制所有嵌套对象，修改原对象不会影响深拷贝的副本。
   • 对于不可变对象：深拷贝实际上没有效果，等同于直接赋值，因为不可变对象本身不能被修改。

对于一颗二叉树，就属于是可变对象，同时还有嵌套。

is 和 ==：is 判断是否同地址；==判断值是否相同

为何二叉树 使用 == 判断的任然是地址，需要自定义函数：

在 Python 中，直接使用 == 运算符比较两个自定义的复杂对象（如二叉树）时，默认行为是调用对象的 __eq__ 方法。对于内置的数据类型（如整数、字符串、列表等），== 运算符已经被定义为比较其内容。但对于自定义类（如二叉树节点 TreeNode），除非我们明确定义 __eq__ 方法，否则 == 的默认行为只是比较对象的内存地址（实际上类似于 is 操作符）。

因为二叉树节点 TreeNode 类没有定义 __eq__ 方法，所以使用 == 比较两个二叉树对象将会比较它们的内存地址，而不是它们的内容。这就是为什么两个内容相同但内存地址不同的树对象，用 == 比较时会返回 False。

 综上，使用 反转二叉树 后，判断前后两颗树是否相同，进而判断二叉树是否对称，在思路上是可行的，但是判断二叉树是否相同需要自定义函数。所以该思路没有这么容易。

class Solution:
    def isSymmetric(self, root: Optional[TreeNode]) -> bool:
        if not root:
            return True
        def symmetricHelper(leftRoot, rightRoot) -> bool:
            # 两个都为None
            if not leftRoot and not rightRoot:
                return True
            # 已知至少有一个不为None
            # 一个为None代表：不相同
            elif not leftRoot or not rightRoot:
                return False
            else:
                return leftRoot.val == rightRoot.val and symmetricHelper(leftRoot.right, rightRoot.left) and symmetricHelper(leftRoot.left, rightRoot.right)
        return symmetricHelper(root.left, root.right)