最强二叉树层序遍历大全（附十道力扣练习题！！）

dianzi_233

于 2024-07-08 15:13:40 发布

阅读量873

点赞数 29

文章标签： leetcode 算法数据结构

本文链接：https://blog.csdn.net/dianzi_233/article/details/140240250

版权

💻题目目录：

接下来会讲解第一道题的解法，是有关构建二叉树层序遍历的，掌握本道题的解法就能试着做一下以上的相关题目，只需要稍微改两到三行代码即可。

📝102.二叉树的层序遍历 (Medium)

Input: root = [3,9,20,null,null,15,7]
Output: [[3],[9,20],[15,7]]

📊思路讲解：

广度搜索，需要创建一个queue，因为queue的原则是先进先出，正好符合我们的需求。创建两个维度的数组，一个用来储存每一层的元素，另一个存放每层的数组的集合。如何保证每层的node不多不少遍历完？需要记录每层的size，告诉电脑，我只需要pop这么多然后放入单独的一维数组，其他就算在queue里面也不需要关注。这样一来，我们就可以控制pop出的元素了。此外，要注意，每pop出一个元素后，就要将她的左孩子和右孩子放入queue中。最后，将这几个一维数组再放入二维数组中。

📸解题代码：（层序遍历-广度搜索）

时间复杂度为 O(n)，其中 n 是二叉树的节点数。这是因为在逐级遍历中，我们对每个节点都会访问一次。
空间复杂度是 O(n)，其中 n 是二叉树的节点数。这是因为我们使用队列来存储每一级的节点，而在最坏的情况下，队列可以包含二叉树最后一级的所有节点。

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def levelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        if not root:
            return []
        queue = collections.deque([root])
        result = [] #二维数组，记录所有层的元素，但是是分层记录的
        while queue:
            single_level = [] #一维数组，记录每一层的元素，例如[9,20]
            for i in range(len(queue)):
                node = queue.popleft()
                single_level.append(node.val)  
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
            result.append(single_level) #遍历完每一层，加入相对应的一维数组到二维里面
        return result

📝107.二叉树的层序遍历进阶 (Medium)

Input: root = [3,9,20,null,null,15,7]
Output: [[15,7],[9,20],[3]]

📸解题代码：（层序遍历-广度搜索）

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def levelOrderBottom(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        if not root:
            return []
        queue = collections.deque([root])
        result = [] #二维数组，记录所有层的元素，但是是分层记录的
        while queue:
            single_level = [] #一维数组，记录每一层的元素，例如[9,20]
            for i in range(len(queue)):
                node = queue.popleft()
                single_level.append(node.val)  
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
            result.append(single_level) #遍历完每一层，加入相对应的一维数组到二维里面
        return result[::-1]

📝199.二叉树的右视图 (Medium)

Input: root = [1,2,3,null,5,null,4]
Output: [1,3,4]

📸解题代码：（层序遍历-广度搜索）

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def rightSideView(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        if root is None:
            return []
        queue = collections.deque([root])
        result = []
        while queue:
            single_level = []
            for i in range(len(queue)):
                node = queue.popleft()
                single_level.append(node.val)
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)    
            result.append(single_level[-1])
        return result

📝637.二叉树的平均值 (Easy)

Input: root = [3,9,20,null,null,15,7]
Output: [3.00000,14.50000,11.00000]
Explanation: The average value of nodes on level 0 is 3, on level 1 is 14.5, and on level 2 is 11.
Hence return [3, 14.5, 11].

📸解题代码：（层序遍历-广度搜索）

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def averageOfLevels(self, root):
        """
        :type root: TreeNode
        :rtype: List[float]
        """
        if root is None:
            return []   
        queue = collections.deque([root])
        average = []
        while queue:
            single_level = []
            size = len(queue)
            for i in range(size):
                node = queue.popleft()
                single_level.append(node.val)
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
                level_sum = sum(single_level)
            average.append(float(level_sum) / size)
        return average

📝429.N叉树的层序遍历 (Medium)

Input: root = [1,null,3,2,4,null,5,6]
Output: [[1],[3,2,4],[5,6]]

📸解题代码：（层序遍历-广度搜索）

"""
# Definition for a Node.
class Node(object):
    def __init__(self, val=None, children=None):
        self.val = val
        self.children = children
"""
class Solution(object):
    def levelOrder(self, root):
        """
        :type root: Node
        :rtype: List[List[int]]
        """
        if root is None:
            return []
        queue = collections.deque([root])
        result = []
        while queue:
            single_level = []
            size = len(queue)
            for i in range(size):
                node = queue.popleft()
                single_level.append(node.val)
                #查找孩子是哪些元素，并添加进去
                for child in node.children:
                    queue.append(child)
            result.append(single_level)
        return result

shshhd

📝515.在每个树行中找最大值 (Medium)

Input: root = [1,3,2,5,3,null,9]
Output: [1,3,9]

📸解题代码：（层序遍历-广度搜索）

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def largestValues(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        if root is None:
            return []
        queue = collections.deque([root]) 
        result = []
        
        while queue:
            max_val = float('-inf')#初始化max value为负无穷，这样方便之后更新max的值
            for i in range(len(queue)):
                node = queue.popleft()
                max_val = max(node.val,max_val) #更新当前层的最大值

                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
            result.append(max_val)
        return result #最后返回result列表，它包含了每层的最大值

备注：
为什么要在for loop外初始化max value？
如果你在每个节点处理时重置 max_value，那么前一个节点的值就不会被保存下来，从而无法正确计算当前层的最大值。在正确的实现中，max_value 应该在每层遍历的开始时初始化，这样可以确保 max_value 能够在遍历当前层的所有节点过程中正确地比较和更新。

📝116.填充每个节点的下一个右侧节点指针 (Medium)

Input: root = [1,2,3,4,5,6,7]
Output: [1,#,2,3,#,4,5,6,7,#]

📸解题代码：（层序遍历-广度搜索）

"""
# Definition for a Node.
class Node(object):
    def __init__(self, val=0, left=None, right=None, next=None):
        self.val = val
        self.left = left
        self.right = right
        self.next = next
"""
class Solution(object):
    def connect(self, root):
        """
        :type root: Node
        :rtype: Node
        """
        if root is None:
            return None
        queue = collections.deque([root])
        while queue:
            size = len(queue)
            for i in range(size):
                node = queue.popleft()
                #当pop出来上一个node后，判断下一个node还在不在此层
                if i != size - 1:
                    node.next = queue[0] #如果在，则连接
                #如果不在一层，那么指向None，也就是下一层
                else:
                    node.next = None
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
        return root #最后返回root因为root可以保留对整个树的引用

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

这道题目说是二叉树，但116题目说是完整二叉树，没有任何差别，一样的代码一样的逻辑一样的味道，答案无需修改。

📝104.二叉树的最大深度 (Easy)

Input: root = [3,9,20,null,null,15,7]
Output: 3

📸解题代码：（层序遍历-广度搜索）

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def maxDepth(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        if root is None:
            return 0
        queue = collections.deque([root])
        level = 0 #初始化深度的值
        while queue:
            for i in range(len(queue)):
                node = queue.popleft()
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
            #每结束一次for循环，就意味着要开始遍历下一个层级，所以level加一
            level += 1
        return level

📝111.二叉树的最小深度 (Easy)

Input: root = [3,9,20,null,null,15,7] Output: 2

📸解题代码：（层序遍历-广度搜索）

# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def minDepth(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        if root is None:
            return 0
        queue = collections.deque([root])
        level = 0

        while queue:
            level += 1
            for i in range(len(queue)):
                node = queue.popleft()
                if not node.left and not node.right:
                    return level
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
            #level += 1 不能放到这里，但是在计算最大深度的时候可以
        return level

dianzi_233

关注

29
点赞
踩
12

收藏

觉得还不错? 一键收藏
0
评论
最强二叉树层序遍历大全（附十道力扣练习题！！）

在正确的实现中，max_value 应该在每层遍历的开始时初始化，这样可以确保 max_value 能够在遍历当前层的所有节点过程中正确地比较和更新。这样一来，我们就可以控制pop出的元素了。接下来会讲解第一道题的解法，是有关构建二叉树层序遍历的，掌握本道题的解法就能试着做一下以上的相关题目，只需要稍微改两到三行代码即可。这道题目说是二叉树，但116题目说是完整二叉树，没有任何差别，一样的代码一样的逻辑一样的味道，答案无需修改。，一个用来储存每一层的元素，另一个存放每层的数组的集合。，正好符合我们的需求。
复制链接

扫一扫