代码随想录day15 层序遍历 翻转二叉树 对称二叉树

1. 层序遍历 

102. 二叉树的层序遍历 - 力扣（LeetCode）

# 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
from collections import deque
class Solution:
    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
        res = []
        if not root:
            return res

        cur_level = deque()
        cur_level.append(root)

        while cur_level:
            cur_res = []
            size = len(cur_level)
            
            for i in range(size):
                cur_node = cur_level.popleft()
                cur_res.append(cur_node.val)
                if cur_node.left:
                    cur_level.append(cur_node.left)
                if cur_node.right:
                    cur_level.append(cur_node.right)
            
            res.append(cur_res)
        
        return res

107. 二叉树的层序遍历 II - 力扣（LeetCode）

代码同第一题，只是最后一行return res[::-1]

199. 二叉树的右视图 - 力扣（LeetCode）

代码同第一题，只是最后一行return [r[-1] for r in res]

637. 二叉树的层平均值 - 力扣（LeetCode）

代码同第一题，只是最后一行return [sum(r) / len(r) for r in res]

429. N 叉树的层序遍历 - 力扣（LeetCode）

多叉树，思路类似：

class Solution:
    def levelOrder(self, root: 'Node') -> List[List[int]]:
        from collections import deque
        if not root:
            return []
        
        res = []
        que = deque([root])
        while que:
            cur_res = []
            size = len(que)

            for _ in range(size):
                cur_node = que.popleft()
                cur_res.append(cur_node.val)

                if cur_node.children:
                    for ch in cur_node.children:
                        que.append(ch) 

            res.append(cur_res)

        return res

515. 在每个树行中找最大值 - 力扣（LeetCode） 

代码同第一题，只是最后一行return [max(r) for r in res]

116. 填充每个节点的下一个右侧节点指针 - 力扣（LeetCode）

注意返回的是root，即修改了各节点next之后的新树的根节点。

"""
# Definition for a Node.
class Node:
    def __init__(self, val: int = 0, left: 'Node' = None, right: 'Node' = None, next: 'Node' = None):
        self.val = val
        self.left = left
        self.right = right
        self.next = next
"""

class Solution:
    def connect(self, root: 'Optional[Node]') -> 'Optional[Node]':
        from collections import deque

        if not root:
            return root

        que = deque([root])
        while que:
            size = len(que)
            cur_node = que[0]

            for i in range(1, size):
                next_node = que[i]
                cur_node.next = next_node
                cur_node = next_node

            for _ in range(size):
                node = que.popleft()
                if node.left:
                    que.append(node.left)
                if node.right:
                    que.append(node.right)
        
        return root

104. 二叉树的最大深度 - 力扣（LeetCode） 

class Solution:
    def maxDepth(self, root: Optional[TreeNode]) -> int:
        from collections import deque
        if not root:
            return 0

        que = deque([root])
        depth = 0

        while que:
            size = len(que)
            depth += 1
            
            for i in range(size):
                cur_node = que.popleft()
                if cur_node.left:
                    que.append(cur_node.left)
                if cur_node.right:
                    que.append(cur_node.right)  
        
        return depth

111. 二叉树的最小深度 - 力扣（LeetCode） 

class Solution:
    def minDepth(self, root: Optional[TreeNode]) -> int:
        from collections import deque
        if not root:
            return 0

        que = deque([root])
        depth = 0

        while que:
            size = len(que)
            depth += 1
            
            for i in range(size):
                cur_node = que.popleft()
                if cur_node.left == None and cur_node.right == None:
                    return depth
                if cur_node.left:
                    que.append(cur_node.left)
                if cur_node.right:
                    que.append(cur_node.right)

2. 翻转二叉树

226. 翻转二叉树 - 力扣（LeetCode） 

1）bfs遍历翻转：迭代法层序遍历所有节点，将其左右孩子互换即可。

class Solution:
    def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
        from collections import deque
        if not root:
            return root

        que = deque([root])
        while que:
            size = len(que)
        
            for i in range(size):
                cur_node = que.popleft()
                tmp = cur_node.left
                cur_node.left = cur_node.right
                cur_node.right = tmp
                if cur_node.left:
                    que.append(cur_node.left)
                if cur_node.right:
                    que.append(cur_node.right)
        
        return root

2）dfs遍历翻转：递归法前序遍历所有节点，互换其左右孩子。

class Solution:
    def dfs(self, node):
        if not node:
            return
        
        node.left, node.right = node.right, node.left
        self.dfs(node.left)
        self.dfs(node.right)

    def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
        self.dfs(root)
        return root

3. 对称二叉树

101. 对称二叉树 - 力扣（LeetCode）

1）层序遍历，额外维护一个保存当前层所有节点值的列表，长度为2^depth，逐层检查包括空节点在内的val是否对称分布。由于题目给出node.val的范围是[-100, 100]，可以定义空节点值为101。

class Solution:
    def isSymmetric(self, root: Optional[TreeNode]) -> bool:
        #层序遍历
        from collections import deque
        if not root:
            return True
        
        que = deque([root])
        while que:
            size = len(que)
            cur_level = []
            
            for _ in range(size):
                cur_node = que.popleft()
                left = cur_node.left
                right = cur_node.right
                if left:
                    que.append(left)
                    cur_level.append(left.val)
                if not left:
                    cur_level.append(101)
                if right:
                    que.append(right)
                    cur_level.append(right.val)
                if not right:
                    cur_level.append(101)
            
            length = len(cur_level)
            if length % 2 != 0:
                return False

            l, r = 0, length - 1
            while l < r:
                if cur_level[l] != cur_level[r]:
                    return False
                l += 1
                r -= 1
        
        return True

2）递归法，比较当前两个节点的外侧节点、内侧节点是否对称。

class Solution:
    def comp(self, left, right):
        if left == None and right == None:
            return True

        elif not (left and right):
            return False

        else: #都非空
            if left.val != right.val:
                return False
            else:
                #当前节点对称，若它们对应的子树也对称，就返回True
                f1 = self.comp(left.left, right.right)
                f2 = self.comp(left.right, right.left)
                return f1 and f2

    def isSymmetric(self, root: Optional[TreeNode]) -> bool:
        if not root:
            return True
        return self.comp(root.left, root.right)