代码随想录刷题15天|二叉树层序遍历

102.二叉树层序遍历

对队列中弹出的元素加以控制

最终结果用二维数组保存

类似于广度优先

class Solution:
    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
        levels = []
        self.helper(root, 0, levels)
        return levels
    
    def helper(self, node, level, levels):
        if not node:
            return
        if len(levels) == level:
            levels.append([])
        levels[level].append(node.val)
        self.helper(node.left, level + 1, levels)
        self.helper(node.right, level + 1, levels)

好的，我们以输入 [3, 9, 20, null, null, 15, 7] 为例，使用递归的隐式栈来描述整个过程。这里的树结构如下：

以下是递归的隐式栈过程：

1. 调用 levelOrder(root)：

   • root 是根节点 3。
   • 创建一个空列表 levels，然后调用 helper(root, 0, levels)。

2. 调用 helper(node=3, level=0, levels)：

   • 将节点值 3 添加到 levels[0]，现在 levels = [[3]]。
   • 递归调用 helper(node=9, level=1, levels)。

3. 调用 helper(node=9, level=1, levels)：

   • 将节点值 9 添加到 levels[1]，现在 levels = [[3], [9]]。
   • 递归调用 helper(node=20, level=1, levels)。

4. 调用 helper(node=20, level=1, levels)：

   • 将节点值 20 添加到 levels[1]，现在 levels = [[3], [9, 20]]。
   • 递归调用 helper(node=15, level=2, levels)。

5. 调用 helper(node=15, level=2, levels)：

   • 将节点值 15 添加到 levels[2]，现在 levels = [[3], [9, 20], [15]]。
   • 递归调用 helper(node=7, level=2, levels)。

6. 调用 helper(node=7, level=2, levels)：

   • 将节点值 7 添加到 levels[2]，现在 levels = [[3], [9, 20], [15, 7]]。
   • 递归调用 helper(node=None, level=3, levels)（因为节点 7 的左右子节点都为 None）。

7. 递归返回到上一层 helper(node=15, level=2, levels)：

   • 递归调用结束，返回到上一层。

8. 递归返回到上一层 helper(node=20, level=1, levels)：

   • 递归调用结束，返回到上一层。

9. 递归返回到上一层 helper(node=9, level=1, levels)：

   • 递归调用结束，返回到上一层。

10. 递归返回到上一层 levelOrder(root)：

    • 递归调用结束，最终返回 levels = [[3], [9, 20], [15, 7]]。

这就是使用递归的隐式栈来描述输入 [3, 9, 20, null, null, 15, 7] 的层序遍历过程。

# 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 []
        queue=collections.deque([root])#构建对列
        result=[]
        while queue:
            level=[]
            for _ in range(len(queue)):
                cur=queue.popleft()
                level.append(cur.val)
                if cur.left:
                    queue.append(cur.left)
                if cur.right:
                    queue.append(cur.right)
            result.append(level)
        return result
        

107.二叉树的遍历（自底向上）

# 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 not root:#如果为空，返回空数组
            return []
        queue=collections.deque([root])
        result=[]
        while queue:
            level=[]
            for _ in range(len(queue)):
                cur=queue.popleft()
                level.append(cur.val)
                if cur.left:
                    queue.append(cur.left)
                if cur.right:
                    queue.append(cur.right)
            result.append(level)
        return result[::-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 not root:
            return []
        queue=collections.deque([root])
        right_review=[]
        while queue:
            level_size=len(queue)#要存储每一层开始的队列长度
            for i in range(len(queue)):
                node=queue.popleft()
                
                
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
                if i==level_size-1:
                    right_review.append(node.val)

        return right_review

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 not root:
            return []
        queue=collections.deque([root])
        averages=[]

        while queue:
            size=len(queue)
            level_sum=0

            for i in range(size):
                node=queue.popleft()

                level_sum+=node.val

                if node.left:
                    queue.append(node.left)
                
                if node.right:
                    queue.append(node.right)
            
            averages.append(level_sum/size)
        
        return averages

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 not root:
            return []

        result = []
        queue = collections.deque([root])
        while queue:
            level_size=len(queue)
            level=[]
            for _ in range(level_size):
                node=queue.popleft()
                level.append(node.val)
                for child in node.children:
                    queue.append(child)
                
            result.append(level)
        return result

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 not root:
            return []

        result = []
        queue = collections.deque([root])

        while queue:
            level_size = len(queue)
            max_val = float('-inf')#将一开始的最大值定义为最小

            for _ in range(level_size):
                node = queue.popleft()
                max_val = max(max_val, node.val)#遍历每个点时更新

                if node.left:
                    queue.append(node.left)

                if node.right:
                    queue.append(node.right)

            result.append(max_val)

        return result
        

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 not root:
            return root
        
        queue = collections.deque([root])

        while queue:
            level_size=len(queue)
            prev=None
            for i in range(level_size):
                node=queue.popleft()#
                if prev:
                    prev.next=node
            
                prev=node

                if node.left:
                    queue.append(node.left)
                
                if node.right:
                    queue.append(node.right)
        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 not root:
            return 0
        depth=0
        queue=collections.deque([root])

        while queue:
            depth+=1
            for _ in range(len(queue)):
                node=queue.popleft()
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
        return depth

111.二叉树的最小深度

相对于 104.二叉树的最大深度 ，本题还也可以使用层序遍历的方式来解决，思路是一样的。

需要注意的是，只有当左右孩子都为空的时候，才说明遍历的最低点了。如果其中一个孩子为空则不是最低点

class Solution:
    def minDepth(self, root: Optional[TreeNode]) -> int:
        if not root:
            return 0
        depth=0
        queue=collections.deque([root])

        while queue:
            depth+=1
            for _ in range(len(queue)):
                node=queue.popleft()

                if not node.left and not node.right:
                    return depth
                
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
                
                
        return depth

111.二叉树的最小深度

if not root:
            return 0
        depth=0
        queue=collections.deque([root])

        while queue:
            depth+=1
            for _ in range(len(queue)):
                node=queue.popleft()

                if not node.left and not node.right:
                    return depth
                
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
                
                
        return depth