【代码随想录算法训练营】第15天 | 第六章二叉树（二）

最新推荐文章于 2024-04-23 14:26:21 发布

tinydiu

最新推荐文章于 2024-04-23 14:26:21 发布

阅读量238

点赞数

分类专栏：代码随想录算法训练营文章标签：算法 leetcode 职场和发展

版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文链接：https://blog.csdn.net/jhl1102/article/details/127175008

版权

代码随想录算法训练营专栏收录该内容

52 篇文章 0 订阅

订阅专栏

主要内容

题目

层序遍历

102. 二叉树的层序遍历

# 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]]:
        results = []
        if not root:
            return results
        from collections import deque
        que = deque([root])
        while que:
            s = len(que)
            res = []
            for _ in range(s):
                cur = que.popleft()
                res.append(cur.val)
                if cur.left:
                    que.append(cur.left)
                if cur.right:
                    que.append(cur.right)
            results.append(res)
        return results

# 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]]:
        results = []

        def helper(root,depth):
            # 终止条件
            if not root:
                return
            # 单层逻辑    
            if len(results) == depth:
                results.append([])
            results[depth].append(root.val)
            helper(root.left, depth + 1)
            helper(root.right, depth + 1)

        helper(root, 0)
        
        return results

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]]:
        results = []
        if not root:
            return results
        from collections import deque
        que = deque([root])
        while que:
            l = len(que)
            res = []
            for _ in range(l):
                cur = que.popleft()
                res.append(cur.val)
                if cur.left:
                    que.append(cur.left)
                if cur.right:
                    que.append(cur.right)
            results.append(res)
        return results[::-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]:
        results = []
        if not root:
            return results
        from collections import deque
        que = deque([root])
        while que:
            l = len(que)
            res = []
            for _ in range(l):
                cur = que.popleft()
                res.append(cur.val)
                if cur.left:
                    que.append(cur.left)
                if cur.right:
                    que.append(cur.right)
            results.append(res)
        return [results[i][-1] for i in range(len(results))]

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]:
        results = []
        if not root:
            return results
        from collections import deque
        que = deque([root])
        while que:
            l = len(que)
            res = []
            for _ in range(l):
                cur = que.popleft()
                res.append(cur.val)
                if cur.left:
                    que.append(cur.left)
                if cur.right:
                    que.append(cur.right)
            results.append(res)
        return [sum(results[i])/len(results[i]) for i in range(len(results))]

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]]:
        results = []
        if not root:
            return results
        from collections import deque
        que = deque([root])
        while que:
            l = len(que)
            res = []
            for _ in range(l):
                cur = que.popleft()
                res.append(cur.val)
                if cur.children:
                    for child in cur.children:
                        que.append(child)
            results.append(res)
        return results

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

        results = []
        if not root:
            return results
        from collections import deque
        que = deque([root])
        while que:
            l = len(que)
            res = []
            for _ in range(l):
                cur = que.popleft()
                res.append(cur.val)
                if cur.left:
                    que.append(cur.left)
                if cur.right:
                    que.append(cur.right)
            results.append(res)
        return [max(results[i]) for i in range(len(results))]

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
        from collections import deque
        que = deque([root])
        while que:
            l = len(que)
            for i in range(l):
                cur = que.popleft()
                if i < l - 1:
                    cur.next = que[0]
                if cur.left:
                    que.append(cur.left)
                if cur.right:
                    que.append(cur.right)        
        return root

117.填充每个节点的下一个右侧节点指针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 root
        from collections import deque
        que = deque([root])
        while que:
            l = len(que)
            for i in range(l):
                cur = que.popleft()
                if i < l - 1:
                    cur.next = que[0]
                if cur.left:
                    que.append(cur.left)
                if cur.right:
                    que.append(cur.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:
        res = 0
        if not root:
            return res
        from collections import deque
        que = deque([root])
        while que:
            l = len(que)
            for _ in range(l):
                cur = que.popleft()
                if cur.left:
                    que.append(cur.left)
                if cur.right:
                    que.append(cur.right)
            res += 1
        return res

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:
        res = 0
        if not root:
            return res
        from collections import deque
        que = deque([root])
        while que:
            l = len(que)
            res += 1
            for _ in range(l):
                cur = que.popleft()
                if cur.left or cur.right:
                    if cur.left:
                        que.append(cur.left)
                    if cur.right:
                        que.append(cur.right)
                else:
                    return res         
        return res

226.翻转二叉树（优先掌握递归）

题目描述

思路分析

三种方式实现：
递归前序遍历
迭代前序遍历
迭代层次遍历

代码

# 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 not root:
    #         return
    #     # 单层逻辑
    #     root.left, root.right = root.right, root.left
    #     self.invertTree(root.left)
    #     self.invertTree(root.right)
    #     return root     

    # 迭代前序   
    # def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
    #     if not root:
    #         return root
    #     s = [root]
    #     while s:
    #         cur = s.pop()
    #         cur.left, cur.right = cur.right, cur.left
    #         if cur.right:
    #             s.append(cur.right)
    #         if cur.left:
    #             s.append(cur.left)
    #     return root      

    # 迭代层次
    def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
        if not root:
            return root
        from collections import deque
        que = deque([root])
        while que:
            l = len(que)
            for _ in range(l):
                cur = que.popleft()
                cur.left, cur.right = cur.right, cur.left
                if cur.left:
                    que.append(cur.left)
                if cur.right:
                    que.append(cur.right)
        return root

101. 对称二叉树（优先掌握递归）

题目描述

链接

思路分析

代码

# 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 isSymmetric(self, root: Optional[TreeNode]) -> bool:
        if not root:
            return True
        return self.compare(root.left, root.right)    

    def compare(self, left, right):
        if not left and not right:
            return True
        elif left and not right:
            return False
        elif right and not left:
            return False
        elif right.val != left.val:
            return False

        # 单层逻辑
        outside = self.compare(left.left, right.right)
        inside = self.compare(left.right, right.left)

        return outside and inside

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
【代码随想录算法训练营】第15天 | 第六章二叉树（二）

代码随想录算法训练营第15天二叉树层次遍历着重递归
复制链接

扫一扫

专栏目录

评论

被折叠的条评论为什么被折叠?

到【灌水乐园】发言

查看更多评论

添加红包

成就一亿技术人!

hope_wisdom

发出的红包

实付元

使用余额支付

点击重新获取

扫码支付

钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。