【leetcode刷刷】102.层序遍历、226.翻转二叉树 、101.对称二叉树

102. 二叉树的层序遍历

1. 代码里的stack应该用queue。写的时候以为是栈就这么命名了。层序遍历先入先出，所以应该是队列。
2. 递归法的想法是：记录下每个数属于哪一层，直接维护一个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 levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
        # 层序遍历
        if not root:
            return []

        stack = [root]
        res = []
        while(stack):
            l = len(stack)
            res_l = []
            stack_tmp = []
            
            for i in range(l):
                node = stack.pop(0)   # 先入先出，队列
                res_l.append(node.val)
                if node.left:
                    stack.append(node.left)
                if node.right:
                    stack.append(node.right)
            res.append(res_l)
        return res


        # 递归法
        levels = []
        helper(root, 0, [])
        return levels

    def helper(self, node, level, levels):
        if not node:
            return 
        if len(levels) == level:   # 如果level比现有levels的长度大，那么再加一层输出
            levels.append([])
        levels[level].append(node.val)
        self.helper(node.left, level+1, levels)
        self.helper(node.right, level+1, levels)                    

226. 翻转二叉树

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

        # 使用栈
        if not root:
            return root
        queue = [root]
        while(queue):
            node = queue.pop(0)
            node.left, node.right = node.right, node.left
            if node.left:
                queue.append(node.left)
            if node.right:
                queue.append(node.right)
        return root

101. 对称二叉树

1. 可以用迭代法和递归法两种方法完成。
2. 递归的话，要搞清楚递归的参数和返回值，然后确定终止条件，最后写一层的递归。
3. 迭代法就是用栈/队列来模拟递归，想清楚思路，写起来还是比较容易的

# 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:
        # 迭代法
        if not root:
            return True
        queue = collections.deque()
        queue.append(root.left)
        queue.append(root.right)
        while(queue):
            node_left = queue.popleft()
            node_right = queue.popleft()
            if not node_left and not node_right:
                continue
            elif not node_left or not node_right or node_left.val != node_right.val:
                return False
            queue.append(node_left.left)
            queue.append(node_right.right)
            queue.append(node_left.right)
            queue.append(node_right.left)
        return True

        # 递归
        if not root:
            return True
        return self.isSymmetric2(root.left, root.right)

    def isSymmetric2(self, left, right):
        if left and not right: return False
        elif right and not left: return False
        elif not left and not right: return True
        elif left.val != right.val: return False

        outside = self.isSymmetric2(left.left, right.right)
        inside = self.isSymmetric2(left.right, right.left)
        return outside and inside