2021.08.21-力扣刷题（102、107、199、637、429、515、116、117、104、111）

最新推荐文章于 2022-04-10 18:24:50 发布

QFIUNE

最新推荐文章于 2022-04-10 18:24:50 发布

阅读量233

点赞数

分类专栏： LeetCode 文章标签： python leetcode 二叉树

本文链接：https://blog.csdn.net/weixin_42038527/article/details/119838095

版权

LeetCode 专栏收录该内容

31 篇文章 1 订阅

订阅专栏

参考【代码随想录】：

（1） https://mp.weixin.qq.com/s/4-bDKi7SdwfBGRm9FYduiA

（2）https://leetcode-cn.com/problems/n-ary-tree-level-order-traversal/solution/dai-ma-sui-xiang-lu-wo-yao-da-shi-ge-er-3rkpg/

二叉树层序遍历的应用

102.二叉树的层序遍历
107.二叉树的层次遍历II
199.二叉树的右视图
637.二叉树的层平均值
429.N叉树的前序遍历
515.在每个树行中找最大值
116.填充每个节点的下一个右侧节点指针
117.填充每个节点的下一个右侧节点指针II
104.二叉树的最大深度
111.二叉树的最小深度

102. 二叉树的层序遍历

题目链接：https://leetcode-cn.com/problems/binary-tree-level-order-traversal/

# 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: TreeNode) -> List[List[int]]:
        if not root:
            return []

        from collections import deque
        ans = []
        queue = deque()
        queue.append(root)

        while queue: # 只要队不空
            cur = []
            for _ in range(len(queue)):      
                node = queue.popleft()
                cur.append(node.val)
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
            ans.append(cur)
            
        return ans

107. 二叉树的层序遍历 II

题目链接：https://leetcode-cn.com/problems/binary-tree-level-order-traversal-ii/

思路：相对于102.二叉树的层序遍历，最后把result数组反转一下就可。

# 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: TreeNode) -> List[List[int]]:

        if not root:
            return []
        
        from collections import deque
        ans = []
        queue = deque()
        queue.append(root)

        while queue:
            cur = []
            for _ in range(len(queue)):
                node = queue.popleft()
                cur.append(node.val)
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
            ans.append(cur)

        res = ans[::-1]
        return res

199.二叉树的右视图

题目链接：https://leetcode-cn.com/problems/binary-tree-right-side-view/

思路：层序遍历的时候，判断是否遍历到单层的最后面的元素，如果是，就放进result数组中，随后返回result就可以了。

# 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: TreeNode) -> List[int]:
        if not root:
            return []
        
        from collections import deque
        queue = deque()
        ans = []
        queue.append(root)
        
        while queue:
            cur = []

            for _ in range(len(queue)):
                node = queue.popleft()
                cur.append(node.val)
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
            
            ans.append(cur)
        
        res = [num[-1] for num in ans]

        return res

637.二叉树的层平均值

题目链接：https://leetcode-cn.com/problems/average-of-levels-in-binary-tree/

思路：本题就是层序遍历的时候把一层求个总和在取一个均值。

# 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: TreeNode) -> List[float]:
        if not root:
            return []
        
        from collections import deque
        queue = deque()
        ans = []
        queue.append(root)
        
        while queue:
            cur = []

            for _ in range(len(queue)):
                node = queue.popleft()
                cur.append(node.val)
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
            
            ans.append(cur)
        
        res = [sum(num)/len(num) for num in ans]

        return res

429.N叉树的层序遍历

题目链接：https://leetcode-cn.com/problems/n-ary-tree-level-order-traversal/

思路：这道题依旧是二叉树层序遍历的模板题，只不过一个节点有多个孩子了

"""
# 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 []
        
        from collections import deque
        ans = []
        queue = deque()
        queue.append(root)

        while queue:
            cur = []
            for _ in range(len(queue)):
                node = queue.popleft()
                cur.append(node.val)
                if node.children:
                    queue.extend(node.children)
            ans.append(cur)
        
        return ans

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

题目链接：https://leetcode-cn.com/problems/find-largest-value-in-each-tree-row/

# 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: TreeNode) -> List[int]:
        if not root:
            return []
        
        from collections import deque
        queue = deque()
        ans = []
        queue.append(root)
        
        while queue:
            cur = []

            for _ in range(len(queue)):
                node = queue.popleft()
                cur.append(node.val)
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
            
            ans.append(cur)
        
        res = [max(num) for num in ans]

        return res

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

题目链接：https://leetcode-cn.com/problems/populating-next-right-pointers-in-each-node/

思路：对二叉树进行层次遍历，在层次遍历的过程中将我们将二叉树每一层的节点拿出来遍历并连接。

"""
# 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 not root:
            return None
        
        from collections import deque
        queue = deque()
        queue.append(root)

        while queue:
            n = len(queue)
            for i in range(n):
                node = queue.popleft()
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
                if i == n-1:
                    break
                node.next = queue[0]

        return root

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

题目地址：https://leetcode-cn.com/problems/populating-next-right-pointers-in-each-node-ii/

思路：这道题目说是二叉树，但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: 'Node') -> 'Node':
        if not root:
            return None
        
        from collections import deque
        queue = deque()
        queue.append(root)

        while queue:  # 遍历每一层
            n = len(queue)
            tail = None # 每一层维护一个尾节点
            for i in range(n): # 遍历当前层
                curnode = queue.popleft()

                if tail:
                    tail.next = curnode # 让尾节点指向当前节点
                tail = curnode # 让当前节点成为尾节点
                
                if curnode.left: 
                    queue.append(curnode.left)
                if curnode.right: 
                    queue.append(curnode.right)
        return root

104.二叉树的最大深度

题目地址：https://leetcode-cn.com/problems/maximum-depth-of-binary-tree/

参考：https://mp.weixin.qq.com/s/jRaRcRerhEHepQbt-aKstw

方法一：迭代法+层序遍历

# 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: TreeNode) -> int:
        if not root:
            return 0
        
        depth = 0

        from collections import deque
        queue = deque()
        queue.append(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

方法二：递归+ 后序遍历

# 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: TreeNode) -> int:
        if not root:
            return 0
        # 递归求左子树深度
        leftdepth = self.maxDepth(root.left)
        # 递归求右子树深度
        rightdepth = self.maxDepth(root.right)
        
        depth = max(leftdepth, rightdepth) + 1

        return depth

111.二叉树的最小深度

题目链接：https://leetcode-cn.com/problems/minimum-depth-of-binary-tree/

思路：当左右孩子都为空的时候，说明遍历的最低点了。如果其中一个孩子为空则不是最低点

参考：https://mp.weixin.qq.com/s/83ApJOFu4CgTICNRX0hHnA

方法一：迭代法+层序遍历

# 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: TreeNode) -> int:
        if not root:
            return 0
        
        from collections import deque
        queue = deque()
        queue.append(root)

        depth = 0

        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)
                if not node.left and not node.right:
                    return depth
                    
        return depth

方法二：递归+后序遍历

# 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: TreeNode) -> int:
        if not root:
            return 0
        if not root.left and not root.right:
            return 1

        min_depth = 10**9
        if root.left:
            min_depth = min(self.minDepth(root.left), min_depth) # 获得左子树的最小高度
        if root.right:
            min_depth = min(self.minDepth(root.right), min_depth) # 获得右子树的最小高度
        return min_depth + 1

QFIUNE

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
2021.08.21-力扣刷题（102、107、199、637、429、515、116、117、104、111）

参考：https://leetcode-cn.com/problems/n-ary-tree-level-order-traversal/solution/dai-ma-sui-xiang-lu-wo-yao-da-shi-ge-er-3rkpg/102. 二叉树的层序遍历题目链接：https://leetcode-cn.com/problems/binary-tree-level-order-traversal/# Definition for a binary tree node..
复制链接

扫一扫