代码随想录算法训练营第十三天｜二叉树数据结构、二叉树递归遍历、二叉树迭代遍历

写代码的企鹅

已于 2024-06-21 17:06:38 修改

阅读量243

点赞数 3

文章标签：算法数据结构

于 2024-06-20 14:23:36 首次发布

本文链接：https://blog.csdn.net/m0_73129864/article/details/139805150

版权

二叉树数据结构（Python）

 class TreeNode:
        def __init__(self, val, left = None, right = None):
            self.val = val
            self.left = left
            self.right = right

二叉树的深度优先遍历

144. 二叉树的前序遍历

# 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 preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        #列表放置遍历的节点
        res = []

        def dfs(node):
            if node is None:
                return 
            
            res.append(node.val)
            dfs(node.left)
            dfs(node.right)
        
        dfs(root)
        return res

94. 二叉树的中序遍历

# 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 inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        res = []

        def dfs(node):
            if node == None:
                return
            dfs(node.left)
            res.append(node.val)
            dfs(node.right)

        dfs(root)
        return res

145. 二叉树的后序遍历

# 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 postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        res = []

        def dfs(node):
            if node == None:
                return
            dfs(node.left)
            dfs(node.right)
            res.append(node.val)
        
        dfs(root)
        return res

迭代法：用栈实现

二叉树的层次遍历

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]]:
        #返回的为二维列表
        #先判断根节点是否为空

        if not root:
            return []
        
        que = deque([root])
        res = []
        while que:
            level = []
            for _ in range(len(que)):
                cur = que.popleft()
                level.append(cur.val)
                if cur.left:
                    que.append(cur.left)
                if cur.right:
                    que.append(cur.right)

            res.append(level)
        return res

107. 二叉树的层序遍历 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: Optional[TreeNode]) -> List[List[int]]:
        if not root:
            return []
        
        que = deque([root])
        res = []
        while que:
            level = []
            for _ in range(len(que)):
                cur = que.popleft()
                level.append(cur.val)
                if cur.left:
                    que.append(cur.left)
                if cur.right:
                    que.append(cur.right)
            res.append(level)
        return res[::-1]

199. 二叉树的右视图

层序遍历的时候，判断是否遍历到单层的最后面的元素，如果是，就放进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: Optional[TreeNode]) -> List[int]:
        if not root:
            return []
        
        que = deque([root])
        res = []

        while que:
            size = len(que) #注意要用size储存最开始时que的长度
            for i in range(size):
                cur = que.popleft()
                if i == size - 1:
                    res.append(cur.val)
                
                if cur.left:
                    que.append(cur.left)
                if cur.right:
                    que.append(cur.right)
        return res

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 []
        
        que = deque([root])
        avg = []
        while que:
            level = []
            size = len(que)
            for i in range(size):
                cur = que.popleft()
                level.append(cur.val)
                if cur.left:
                    que.append(cur.left)
                if cur.right:
                    que.append(cur.right)

            avg.append(sum(level)/len(level)) #求一个列表中数据平均值的方法
        
        return avg

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 []
        
        que = deque([root])
        res = []
        while que:
            level = []
            size = len(que)
            for i in range(size):
                cur = que.popleft()
                level.append(cur.val)
                
                #将多个子节点加入队列中
                for child in cur.children:
                    que.append(child)

            res.append(level)
        
        return res

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 []
        
        que = deque([root])
        res = []
        while que:
            level = []
            size = len(que)
            for i in range(size):
                cur = que.popleft()
                level.append(cur.val)
                
                if cur.left:
                    que.append(cur.left)
                if cur.right:
                    que.append(cur.right)

            res.append(max(level))
        
        return res

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
        
        que = deque([root])

        while que:
            size = len(que)
            prev = None
            for i in range(size):
                cur = que.popleft()
                
                if prev:
                    prev.next = cur

                prev = cur


                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
        
        que = deque([root])

        while que:
            size = len(que)
            prev = None #每一层都重置prev
            for _ in range(size):
                cur = que.popleft()
                
                if prev:
                    prev.next = cur
                
                prev = cur

                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:
        if not root:
            return 0
        
        que = deque([root])
        cnt = 0
        while que:
            size = len(que)
            for _ in range(size):
                cur = que.popleft()
                if cur.left:
                    que.append(cur.left)
                if cur.right:
                    que.append(cur.right)
            cnt += 1
        return cnt

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 not root:
            return 0
        
        que = deque([root])
        level = 1
        while que:
            size = len(que)
            for i in range(size):
                cur = que.popleft()
                if not cur.left and not cur.right:
                    return level
                if cur.left:
                    que.append(cur.left)
                if cur.right:
                    que.append(cur.right)
            level += 1

使用DFS解决树从root到leaf问题的模板：

class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

def dfs_template(root):
    # 存储最终结果
    res = []
    # 初始化当前结果
    start = 0

    # 构造递归函数dfs，通常参数为当前节点和当前结果
    def dfs(node, current_result):
        if node is None:
            return
        # 更新当前结果current_result
        #current_result += node.val #更新的方法不同
        
        # 若到达末尾叶子结点，进行最优结果更新
        if node.left is None and node.right is None:
            # 更新res
            #res.append(current_result) 
        # 左右子树递归
        dfs(node.left, current_result)
        dfs(node.right, current_result)

    dfs(root, start)
    return res

def dfs(node, current_max):
    # 1. 终止条件：如果当前节点为空，返回0
    if node is None:
        return 0
    
    # 2. 路径有效性检查：如果当前节点值不大于路径中的最大值，返回0
    if node.value <= current_max:
        return 0
    
    # 3. 叶子节点处理：如果是叶子节点，返回1，表示找到一条符合条件的路径
    if node.num_children() == 0:
        return 1
    
    # 4. 更新当前路径的最大值
    current_max = node.value
    
    # 5. 递归遍历子节点
    total_paths = 0
    for child in node.children:
        total_paths += dfs(child, current_max)
    
    # 6. 返回结果
    return total_paths

uchi题：

计算递增path的个数

列表结构的二叉树：

#题目代码（列表形式）
class TreeNode:
    def __init__(self, nn, value):
        self.node_num = nn
        self.value = value
        self.children: list['Tree'] = []

def count_monotonic_paths(root):
   
    def dfs(node, current_max):
        if node is None:
            return 0
        # 如果当前节点值不大于路径中的最大值，则不是严格递增路径
        if node.value <= current_max:
            return 0
        # 如果是叶子节点且路径严格递增，则找到一条路径
        if node.num_children() == 0:
            return 1
        # 更新当前路径中的最大值
        current_max = node.value
        # 递归遍历所有子节点，并累计所有严格递增路径的数目
        total_paths = 0
        for child in node.children:
            total_paths += dfs(child, current_max)
        return total_paths

    # 从根节点开始，初始最大值为负无穷大
    return dfs(root, float('-inf'))

链表结构的二叉树：

#题目代码（链表形式）
class TreeNode:
    def __init__(self, value=0, left=None, right=None):
        self.value = value
        self.left = left
        self.right = right

def count_monotonic_paths(root):
    '''
    Count the number of paths from the root to a leaf node that are strictly
    monotonically increasing. See the problem description for more details.
    
    Arguments:
        root: the root of the tree
        
    Returns:
        the number of paths from the root to a leaf node that are strictly
        monotonically increasing
    '''
    def dfs(node, current_max):
        if node is None:
            return 0
        
        if node.value <= current_max:
            return 0
        
        if node.left is None and node.right is None:
            return 1
        
        current_max = node.value
        total_paths = 0
        
        if node.left:
            total_paths += dfs(node.left, current_max)
        
        if node.right:
            total_paths += dfs(node.right, current_max)
        
        return total_paths

    return dfs(root, float('-inf'))

写代码的企鹅

关注

3
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
代码随想录算法训练营第十三天｜二叉树数据结构、二叉树递归遍历、二叉树迭代遍历

本题依然是层序遍历，只不过在单层遍历的时候记录一下本层的头部节点，然后在遍历的时候让前一个节点指向本节点就可以了。这道题目说是二叉树，但116题目说是完整二叉树，其实没有任何差别，一样的代码一样的逻辑一样的味道。层序遍历的时候，判断是否遍历到单层的最后面的元素，如果是，就放进result数组中。相对于102.二叉树的层序遍历，就是最后把result数组反转一下就可以了。
复制链接

扫一扫