层序遍历

102.二叉树的层序遍历

1. 文档链接

programmercarl.com/0102.二叉树的层序…

2. 第一想法

我们可以每遍历一个节点，就把它的所有子节点加入到当前层的下一层列表。

1. 初始化一个level_idx=0的层；
2. level_queues_list = []存储每一层的的level_queue。
3. 初始化是root.value加入到level_queue中，然后将level_queue加入到level_queues_list中。
4. 维护一个node_queue，表示存储当前层的节点node。node_queue = [root]
5. 每一次要把整个node_queue都pop()出来，并将他们的子节点push()进去。
6. pop()出来的所有node都要把对应的值放入level_queue。 这样的操作直到node_queue全部为空。

# 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 root is None:
            return []
        node_queue = [root]
        value_level_queue_list = []
        while node_queue:
            temp_value_level = []
            temp_level_queue = []
            while node_queue:
                node = node_queue.pop(0)
                temp_value_level.append(node.val)
                if node.left:
                    temp_level_queue.append(node.left)
                if node.right:
                    temp_level_queue.append(node.right)
            node_queue = temp_level_queue
            value_level_queue_list.append(temp_value_level)
        return value_level_queue_list

3. 实现的困难点

list从队首pop()元素，用的是list.pop(0)。

4. 阅读文档思路

文档的思路与我基本一致，但是唯一的区别是文档的思路统计了node_queue中一层节点有多少个，然后通过for循环弹出当前层中所有的节点。这样node_queue在整个for循环结束后就能保证里面的所有节点就是下一个level的nodes.

5. 学习时长

1小时40分钟。

6. 其他9道题

107.二叉树的层序遍历II

# 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 levelOrderBottom(self, root: Optional[TreeNode]) -> List[List[int]]:
        if root is None:
            return []
        else:
            node_queue = deque()
            value_level_list = []
            
            node_queue.append(root)
            while node_queue:
                value_level = []
                level_size = len(node_queue)
                for i in range(level_size):
                    node = node_queue.popleft()
                    value_level.append(node.val)
                    if node.left:
                        node_queue.append(node.left)
                    if node.right:
                        node_queue.append(node.right)
                value_level_list.append(value_level)
            return value_level_list[::-1]

难点在于最后的反转用的是list[::-1]这种倒着一个一个数。

199.二叉树的右视图

# 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 rightSideView(self, root: Optional[TreeNode]) -> List[int]:
        if root is None:
            return []
        else:
            node_queue = deque()
            node_queue.append(root)
            value_levels_list = []
            while node_queue:
                value_level = []
                queue_size = len(node_queue)
                for i in range(queue_size):
                    node = node_queue.popleft()
                    value_level.append(node.val)
                    if node.left:
                        node_queue.append(node.left)
                    if node.right:
                        node_queue.append(node.right)
                value_levels_list.append(value_level[-1])
            return value_levels_list

637.二叉树的层平均值

# 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 averageOfLevels(self, root: Optional[TreeNode]) -> List[float]:
        if root is None:
            return []
        node_queue = deque()
        node_queue.append(root)
        mean_list = []
        while node_queue:
            size = len(node_queue)
            sum_level = 0.0
            for i in range(size):
                node = node_queue.popleft()
                sum_level += node.val
                if node.left:
                    node_queue.append(node.left)
                if node.right:
                    node_queue.append(node.right)
            mean_level = sum_level / size
            mean_list.append(mean_level)
        return mean_list

429.N叉树的层序遍历

"""
# Definition for a Node.
class Node:
    def __init__(self, val=None, children=None):
        self.val = val
        self.children = children
"""

class Solution:
    def levelOrder(self, root: 'Node') -> List[List[int]]:
        if root is None:
            return []
        node_queue = deque()
        node_queue.append(root)
        level_val_list = []
        while node_queue:
            size = len(node_queue)
            level_val = []
            for i in range(size):
                node = node_queue.popleft()
                level_val.append(node.val)
                for child in node.children:
                    node_queue.append(child)
            level_val_list.append(level_val)
        return level_val_list

515.在每个树行中找最大值

# 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 largestValues(self, root: Optional[TreeNode]) -> List[int]:
        if root is None:
            return []
        res_list = []
        node_queue = deque()
        node_queue.append(root)
        while node_queue:
            size = len(node_queue)
            val_max = (-1)<<31
            for i in range(size):
                node = node_queue.popleft()
                val_max = node.val if val_max < node.val else val_max
                if node.left:
                    node_queue.append(node.left)
                if node.right:
                    node_queue.append(node.right)
            res_list.append(val_max)
        return res_list

116.填充每个节点的下一个右侧节点指针

"""
# 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]':
        if root is None:
            return None
        node_queue = deque()
        node_queue.append(root)
        while node_queue:
            size = len(node_queue)
            level_nodes = []
            for i in range(size):
                node = node_queue.popleft()
                level_nodes.append(node)
                if node.left:
                    node_queue.append(node.left)
                if node.right:
                    node_queue.append(node.right)
            for idx in range(len(level_nodes) - 1):
                level_nodes[idx].next = level_nodes[idx + 1]
        return root

117.填充每个节点的下一个右侧节点指针II

"""
# 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: 'Node') -> 'Node':
        if root is None:
            return None
        node_queue = deque()
        node_queue.append(root)
        while node_queue:
            size = len(node_queue)
            tmp_level = []
            for i in range(size):
                node = node_queue.popleft()
                tmp_level.append(node)
                if node.left:
                    node_queue.append(node.left)
                if node.right:
                    node_queue.append(node.right)
            for idx in range(len(tmp_level) - 1):
                tmp_level[idx].next = tmp_level[idx + 1]
        return root

104.二叉树的最大深度

# 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 maxDepth(self, root: Optional[TreeNode]) -> int:
        if root is None:
            return 0
        level_num = 0
        node_queue = deque()
        node_queue.append(root)
        while node_queue:
            size = len(node_queue)
            level_num += 1
            for i in range(size):
                node = node_queue.popleft()
                if node.left:
                    node_queue.append(node.left)
                if node.right:
                    node_queue.append(node.right)
        return level_num

111.二叉树的最小深度

# 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 minDepth(self, root: Optional[TreeNode]) -> int:
        if root is None:
            return 0
        node_queue = deque()
        node_queue.append(root)
        max_depth = 0
        while node_queue:
            size = len(node_queue)
            max_depth += 1
            for i in range(size):
                node = node_queue.popleft()
                if node.left:
                    node_queue.append(node.left)
                if node.right:
                    node_queue.append(node.right)
                if (node.left is None) and (node.right is None):
                    return max_depth
        return max_depth

注意最小深度的计数位置，不是在一个level全部弹出的内部，而是在此之前，就是外层循环上做计数。

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 root is None:
            return None
        stack = [root]
        while stack:
            node = stack.pop()
            if (node.right is None) and (node.left is None):
                continue
            else:
                node.right, node.left = node.left, node.right
                if node.right:
                    stack.append(node.right)
                if node.left:
                    stack.append(node.left)
        return root

2. 学习时长

30分钟

101. 对称二叉树

1. 想法

后序遍历吧，每一层只管自己左右孩子是否相等，如果相等就继续，如果不相等立刻就返回False即可。 但是我想错了，不能这么做，判断左右孩子不行，左右孩子不一样，说不定处于对称轴的一侧。 所以我们的后序遍历不行，要做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 __init__(self):
        self.left_list = []
        self.right_list = []
        
    def post_left(self, root: TreeNode):
        if root is None:
            self.left_list = self.left_list + [None,]
        else:
            self.post_left(root.left)
            self.post_left(root.right)
            self.left_list.append(root.val)
    
    def post_right(self, root: TreeNode):
        if root is None:
            self.right_list = self.right_list + [None,]
        else:
            self.post_right(root.right)
            self.post_right(root.left)
            self.right_list.append(root.val)
    
    def isSymmetric(self, root: Optional[TreeNode]) -> bool:
        if root is None:
            return True
        self.post_left(root.left)
        self.post_right(root.right)
        return self.left_list == self.right_list