算法训练记录day15

一、层序遍历

用的模板，很形象。

思路

• 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 []
        res = []
        from collections import deque
        que = deque([root])
# 因为是层序，每一层都要区分，实际是个二维。所以先用res1接受当层的，再将每一层加到res中
        while que:          # 只要队列不为空
            res1 = []
            for i in range(len(que)):   # 循环的次数由每一层的元素决定。对每一个元素处理他的左右节点
                node = que.popleft()    # 删除该节点，从队列头部开始
                res1.append(node.val)   # 将这一层元素加到res1中
                if node.left:           # 判断左节点是否要加到que中
                    que.append(node.left)
                if node.right:
                    que.append(node.right)
            res.append(res1)            # 循环一层后，将这一层的res1加到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]]:
        if not root:
            return []
        res = []
        from collections import deque
        que = deque([root])
# 因为是层序，每一层都要区分，实际是个二维。所以先用res1接受当层的，再将每一层加到res中
        while que:          # 只要队列不为空
            res1 = []
            for i in range(len(que)):   # 循环的次数由每一层的元素决定。对每一个元素处理他的左右节点
                node = que.popleft()    # 删除该节点，从队列头部开始
                res1.append(node.val)   # 将这一层元素加到res1中
                if node.left:           # 判断左节点是否要加到que中
                    que.append(node.left)
                if node.right:
                    que.append(node.right)
            res.append(res1)            # 循环一层后，将这一层的res1加到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]:
        if not root:
            return []
        from collections import deque
        que = deque([root])
        res = []
        while que:
            res1 = []
            for i in range(len(que)):
                node = que.popleft()
                res1.append(node.val)
                if node.left:
                    que.append(node.left)
                if node.right:
                    que.append(node.right)
            res.append(res1[-1])
        return res

# 只需把每层的最后一个元素加到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 []
        from collections import deque
        que = deque([root])
        res = []
        while que:
            sum = 0
            res1 = []
            n = len(que)            # n不能丢
            # 这里要把n单独拿出来，因为len（que）是一个变值，而n才是每层的节点个数
            for i in range(n):
                node = que.popleft()
                sum += node.val
                res1.append(node.val)
                if node.left:
                    que.append(node.left)
                if node.right:
                    que.append(node.right)
            res.append(sum/n)
        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]]:
        if not root:
            return []
        from collections import deque
        que = deque([root])
        res = []
        while que:
            res1 = []
            for i in range(len(que)):
                node = que.popleft()
                res1.append(node.val)
                if node.children:
                    que.extend(node.children)       # 注意extend和append的区别
            # 稍作改动 
            res.append(res1)
        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 []
        from collections import deque
        que = deque([root])
        res = []
        while que:
            res1 = []
            for i in range(len(que)):
                node = que.popleft()
                res1.append(node.val)
                if node.left:
                    que.append(node.left)
                if node.right:
                    que.append(node.right)
            res.append(max(res1))           # 注意max的使用
        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 None
        que = [root]
        while que:
            n = len(que)
            
            for i in range(n):
                node = que.pop(0)        # 更新头节点
                if node.left :
                    que.append(node.left)
                if node.right:
                    que.append(node.right)
                if i == n-1:    # 由于每一个节点都指向None,最右侧就不用处理
                    break
                node.next = que[0]  # 指向下个节点
        return root

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

和上一题没区别

"""
# 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
        que = [root]
        while que:
            n = len(que)
            
            for i in range(n):
                node = que.pop(0)
                if node.left :
                    que.append(node.left)
                if node.right:
                    que.append(node.right)
                if i == n-1:
                    break
                node.next = que[0]
        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
        from collections import deque
        que = deque([root])
        conut = 0
        while que:
            for i in range(len(que)):
                node = que.popleft()
                
                if node.left:
                    que.append(node.left)
                if node.right:
                    que.append(node.right)
            conut+=1
# 循环多少次，就有多少层
        return conut

• 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
        from collections import deque
        que = deque([root])
        count = 1
        while que:
            for i in range(len(que)):
                node = que.popleft()
                if node.left:
                    que.append(node.left)
                if node.right:
                    que.append(node.right)
                if not node.left and not node.right:
                    return count        # 某一层没有循环完就结束了  count没有加一，所以count从一开始
            count += 1
# 需判断停止条件
        return count

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

题目

思路

# 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 None
        from collections import deque
        que = deque([root])

        while que:
            node = que.popleft()
            node.left ,node.right = node.right ,node.left
            if node.left:
                que.append(node.left)
            if node.right:
                que.append(node.right)
                
        return 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
import collections
class Solution:
    def isSymmetric(self, root: TreeNode) -> bool:
        if not root:
            return True
        queue = collections.deque()
        queue.append(root.left) #将左子树头结点加入队列
        queue.append(root.right) #将右子树头结点加入队列
        while queue: #接下来就要判断这这两个树是否相互翻转
            leftNode = queue.popleft()
            rightNode = queue.popleft()
            if not leftNode and not rightNode: #左节点为空、右节点为空，此时说明是对称的
                continue
            
            #左右一个节点不为空，或者都不为空但数值不相同，返回false
            if not leftNode or not rightNode or leftNode.val != rightNode.val:
                return False
            queue.append(leftNode.left) #加入左节点左孩子
            queue.append(rightNode.right) #加入右节点右孩子
            queue.append(leftNode.right) #加入左节点右孩子
            queue.append(rightNode.left) #加入右节点左孩子
        return True