代码随想录算法训练营Day15|二叉树层序遍历，leetcode226 反转二叉树，leetcode101 对称二叉树

二叉树层序遍历

  二叉树的层序遍历也就是广度优先搜索，用队列实现，先把根节点加入队列，然后弹出，将根节点的左孩子和右孩子加入队列，再把左孩子弹出，加入左孩子的左孩子和右孩子，再把右孩子弹出，加入右孩子的左孩子和右孩子，同时有一个参数size控制弹出的节点数量。

题目链接：102. 二叉树的层序遍历 - 力扣（LeetCode）

视频讲解：讲透二叉树的层序遍历 | 广度优先搜索 | LeetCode：102.二叉树的层序遍历_哔哩哔哩_bilibili

文章讲解：代码随想录 (programmercarl.com)

# 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]]:
        results = []      #创建列表存结果
        if not root:      #如果root为空就返回空列表
            return []
        
        from collections import deque
        que = deque([root])    #创建队列先把root放进去

        while que:
            size = len(que)
            resule = []
            for _ in range(size):
                cur = que.popleft()     #队列多长就pop多少次
                resule.append(cur.val)
                if cur.left:
                    que.append(cur.left)
                if cur.right:
                    que.append(cur.right)
            results.append(resule)

        return results

 leetcode226.反转二叉树

题目链接：226. 翻转二叉树 - 力扣（LeetCode）

视频讲解：听说一位巨佬面Google被拒了，因为没写出翻转二叉树 | LeetCode：226.翻转二叉树_哔哩哔哩_bilibili

文章讲解：代码随想录 (programmercarl.com)

 思路：迭代法，交换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 invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
        if not root:
            return None
        
        root.left, root.right = root.right, root.left
        self.invertTree(root.left)
        self.invertTree(root.right)

        return root

 leetcode101.对称二叉树

题目链接：101. 对称二叉树 - 力扣（LeetCode）

视频讲解：新学期要从学习二叉树开始！ | LeetCode：101. 对称二叉树_哔哩哔哩_bilibili

文章讲解：代码随想录 (programmercarl.com)

思路：先判断是不是一个空一个不空，或者两个都空，或者两个都不空但不相等，然后开始递归。

# 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
        return self.compare(root.left, root.right)

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

        outside = self.compare(left.left, right.right)      #布尔类型
        inside = self.compare(left.right, right.left)       #布尔类型
        isSame = outside and inside                        #布尔类型
        return isSame