算法训练营 day13 ｜ 二叉树part01

递归遍历（前序）

题目链接

# 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的哪种遍历方式主要取决于这行代码的位置
            dfs(node.left)
            dfs(node.right)
        dfs(root)
        return res

总结：代码为前序遍历，只要调整添加节点值到res里的代码位置即可变成后序遍历或者中序遍历。

迭代遍历(前序)

# 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]:
        if root is None:
            return []
        stack = [root]
        res = []
        while stack:
            node = stack.pop()
            res.append(node.val)
            if node.right:
                stack.append(node.right)
            if node.left:
                stack.append(node.left)
        return res
            
        

总结：使用栈来实现非递归。先让root入栈然后出栈，再让右孩子入栈然后左孩子入栈，然后再出栈。这样出栈元素排列即为中左右

后序遍历：前序遍历的基础上，调整左右子节点入栈顺序再反转结果数组，即为后序遍历

迭代遍历（中序）

题目链接

# 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]:
        if root is None:
            return []
        stack = []
        res = []
        cur = root
        while cur or stack:
            if cur:
                stack.append(cur)
                cur = cur.left
            else:
                cur = stack.pop()
                res.append(cur.val)
                cur = cur.right
        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 root is None:
            return []
        queue = collections.deque([root])
        res = []
        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)
            res.append(level)
        return res

总结：每个节点都需要先进入队列然后才被添加到level数组中，同时用队列控制每层节点的数量。每次节点出队列的时候，把其左右孩子加入队列中。

会写层序遍历之后，接着就能很快刷完类似的很多题

107. 二叉树的层序遍历 II

思路：返回反转后的res即可

199. 二叉树的右视图

思路：调整左右孩子入队列的顺序，并且仅添加每层的第一个节点到res里即可

637. 二叉树的层平均值

思路：在添加到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 root is None:
            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
        

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

思路：在添加到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:
        if root is None:
            return 0
        queue = collections.deque([root])
        min = 0
        while queue:
            min += 1
            for _ in range(len(queue)):
                cur = queue.popleft()
                if cur.left == None and cur.right == None:
                    return min
                if cur.left:
                    queue.append(cur.left)
                if cur.right:
                    queue.append(cur.right)
        return min