【二叉树】基础理论：深度搜索和广度搜索（以递归写法为主）

一、深度搜索 dfs

• 144.二叉树的前序遍历
• 145.二叉树的后序遍历
• 94.二叉树的中序遍历

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(root):
            if not root:
                return
            res.append(root.val)
            dfs(root.left)
            dfs(root.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(root):
            if not root:
                return
            
            dfs(root.left)
            dfs(root.right)
            res.append(root.val)
        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(root):
            if not root:
                return
            
            dfs(root.left)
            res.append(root.val)
            dfs(root.right)
            
        dfs(root)
        return res

前序、中序、后序的迭代（非递归）统一写法

# 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 = []
        if not root:
            return []
        stack = [root]
        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
# 后序
class Solution:
    def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        res = []
        if not root:
            return res
        stack = [root]
        while stack:
            node = stack.pop()
            res.append(node.val)
            if node.left:
                stack.append(node.left)
            if node.right:
                stack.append(node.right)   
        return res[::-1]

# 中序   也可用该方法作为统一方法。
class Solution:
    def inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        res = []
        stack = []
        if root:
            stack.append(root)
        while stack:
            node = stack.pop()
            if node!=None:
                if node.right:  #添加右节点（空节点不入栈）
                    stack.append(node.right)
                stack.append(node)  #添加中节点
                stack.append(None)  #中节点访问过，但是还没有处理，加入空节点做为标记。
                if node.left:    #添加左节点（空节点不入栈）
                    stack.append(node.left)
            else:   #只有遇到空节点的时候，才将下一个节点放进结果集
                node = stack.pop()  #重新取出栈中元素
                res.append(node.val)  #加入到结果集

        return res

二、层序遍历 bfs

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

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

        def bfs(node,level,res):
            if not node:
                return
            if len(res) == level:
                res.append([])
            res[level].append(node.val)
            bfs(node.left,level+1,res)
            bfs(node.right,level+1,res)
        bfs(root,0, res)
        return res

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]]:
        res = []
        def bfs(node,level,res):
            if not node:
                return
            if len(res) == level:
                res.append([])
            res[level].append(node.val)
            bfs(node.left,level+1,res)
            bfs(node.right,level+1,res)
        bfs(root,0,res)
        return res[::-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]:
        res_mid = []
        def bfs(node,level,res_mid):
            if not node:
                return
            if len(res_mid) == level:
                res_mid.append([])
            res_mid[level].append(node.val)
            bfs(node.left,level+1,res_mid)
            bfs(node.right,level+1,res_mid)
            
        bfs(root,0 ,res_mid)
        res = []
        for i in res_mid:
            res.append(i[-1])
        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]:
        res_mid = []
        def bfs(node,level,res_mid):
            if not node:
                return
            if len(res_mid) == level:
                res_mid.append([])
            
            res_mid[level].append(node.val)
            bfs(node.left,level+1,res_mid)
            bfs(node.right,level+1,res_mid)
        bfs(root,0,res_mid)
        res = []
        for i in res_mid:
            res.append(mean(i))
        return res

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]]:
        res = []
        def bfs(node,level,res):
            if not node:
                return
            if len(res) == level:
                res.append([])
            res[level].append(node.val)
            for children in node.children:
                bfs(children,level+1,res)

        bfs(root,0,res)
        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]:
        res_mid = []
        def bfs(node,level,res_mid):
            if not node:
                return
            if len(res_mid) == level:
                res_mid.append([])
            res_mid[level].append(node.val)
            bfs(node.left,level+1,res_mid)
            bfs(node.right,level+1,res_mid)
        bfs(root,0,res_mid)
        res = []
        for i in range(len(res_mid)):
            res.append(max(res_mid[i]))
        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
        # if root.left:
        #     root.left.next = root.right
        #     if root.next:
        #         root.right.next = root.next.left
        # self.connect(root.left)
        # self.connect(root.right)
        # return root

        if not root:
            return
        def bfs(onelayer):  # onelayer为当前层的节点
            nextlayer = []
            for i in onelayer:
                if i.left:
                    nextlayer.append(i.left)
                if i.right:
                    nextlayer.append(i.right)
            if len(nextlayer)>1:
                for j in range(len(nextlayer)-1):
                    nextlayer[j].next = nextlayer[j+1]
            if nextlayer:  # nextlayer不为空的话继续往下走
                bfs(nextlayer)
        bfs([root])
        return root

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

【核心思路】：整个题就是要把树拆成一层一层的，然后每层里面，前一个节点的next指向后一个节点。后面没有就是空的。
其实对于oneLayer这一层树的所有节点来说，把他们每个节点的左右取出来，就是下一层的节点了。

for i in oneLayer:
    if i.left:
        nextLayer.append(i.left)
    if i.right:
        nextLayer.append(i.right)

然后对nextLayer里所有节点，每个节点的next指向后一个节点就可以了。

"""
# 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
        def bfs(onelayer):
            nextlayer = []
            for i in onelayer:
                if i.left:
                    nextlayer.append(i.left)
                if i.right:
                    nextlayer.append(i.right)

            if len(nextlayer)>1:
                for j in range(len(nextlayer)-1):
                    nextlayer[j].next = nextlayer[j+1]
            if nextlayer:
                bfs(nextlayer)
        bfs([root])
        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_mid = []

        def bfs(node, level, res_mid):
            if not node:
                return
            if len(res_mid) == level:
                res_mid.append([])
            res_mid[level].append(node.val)
            bfs(node.left, level + 1, res_mid)
            bfs(node.right, level + 1, res_mid)

        bfs(root, 0, res_mid)
        
        return len(res_mid)

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
        if not root.left and not root.right:
            return 1
        leftdepth = self.minDepth(root.left)
        rightdepth = self.minDepth(root.right)
        if root.left and not root.right:  # 抛开右子数深度的问题
            return leftdepth+1
        if root.right and not root.left:  # 抛开左子树深度的问题
            return rightdepth+1
        min_depth = min(leftdepth,rightdepth)+1
        return min_depth