第一想法：

# 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 levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
        # 自己的错误想法：得出的结果是[3.9.20.15.7]，无法对每层遍历到的结果加括号实现，考虑内部一个for循环的写法
        que = deque()
        res = []
        if not root:
            return []
        que.append(root)
        while que:
            node = que.popleft()
            res.append(node.val)
            if node.left:
                que.append(node.left)
            if node.right:
                que.append(node.right)
        return res

：更正后

class Solution:
    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
        # 法一：迭代法
        que = deque()
        res = []
        if not root:
            return []
        que.append(root)
        while que:
        	# 每层加入几个节点，就遍历几次
            size = len(que)
            temp = []
            for _ in range(size):
                node = que.popleft()
                temp.append(node.val)
                if node.left:
                    que.append(node.left)
                if node.right:
                    que.append(node.right)
            res.append(temp)
        return res
        # 法二：递归法
        res = []
        def recursion(cur, depth):
            if not cur: return []
            if len(res) == depth:
                res.append([])
            res[depth].append(cur.val)
            if cur.left:
                recursion(cur.left, depth+1)
            if cur.right:
                recursion(cur.right, depth + 1)
        recursion(root, 0)
        return res

# 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 invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
    	# 递归法
        def recursion(node):
            if not node:
                return
            if not node.left and not node.right:
                return 
            node.left, node.right = node.right,node.left
            recursion(node.left)
            recursion(node.right)
        recursion(root)
        return root

看过代码随想录后才知道原来用了前序遍历的想法，并且补充学习了层次遍历的解法

class Solution:
    def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
        que = deque([root])
        if not root:
            return 
        while que:
            n = len(que)
            for _ in range(n):
                node = que.popleft()
                node.left,node.right = node.right,node.left
                if node.left:
                    que.append(node.left)
                if node.right:
                    que.append(node.right)
        return root

之前学习的递归法

# 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 dfs(l,r):
            if not r and l:
                return False
            elif not l and r:
                return False
            elif not l and not r:
                return True 
            else:
                return l.val == r.val and dfs(l.left,r.right) and dfs(l.right,r.left)
        return dfs(root.left,root.right)