力扣刷题-python-二叉树-2（层序遍历、混合遍历）

1. 二叉树层序遍历

102. 二叉树的层序遍历 - 力扣（LeetCode） (leetcode-cn.com)

# 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: TreeNode) -> List[List[int]]:   
           #用队列
           if not root: return []
           queuer = [root]
           res,depth=[], -1   #depth表示层数
           while queuer:
               depth+=1
               res.append([])
               for _ in range(len(queuer)):
                   noder = queuer.pop(0)
                   res[depth].append(noder.val)
                   if noder.left: queuer.append(noder.left)  #将pop出的父结点的孩子节点压入
                   if noder.right:queuer.append(noder.right)
           return res

107. 二叉树的层序遍历 II - 力扣（LeetCode） (leetcode-cn.com)

# 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: TreeNode) -> List[List[int]]:
        #用队列 顺序读取层,然后反向输出
        if not root : return []
        res, depth=[], -1
        queue= [root]
        while queue:
            depth+=1
            res.append([])
            for _ in range(len(queue)):
                noder = queue.pop(0)
                res[depth].append(noder.val)
                if noder.left: queue.append(noder.left)
                if noder.right:queue.append(noder.right)
        return res[::-1]

199. 二叉树的右视图 - 力扣（LeetCode） (leetcode-cn.com)

# 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: TreeNode) -> List[int]:
        #同二叉树层序遍历 但是只输出最后一个
        #可以考虑用队列
        if not root: return []
        res = []
        queue = [root]
        while queue:
            res.append(queue[-1].val)   #只输出末尾的 
            for _ in range(len(queue)):
                noder = queue.pop(0)
                if noder.left: queue.append(noder.left)
                if noder.right:queue.append(noder.right)
        return res

637. 二叉树的层平均值 - 力扣（LeetCode） (leetcode-cn.com)

# 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]:
        #同样的用队列
        queue =deque([root])  #换用队列会加快运算速度
        res = []
        while queue:
            n= len(queue)
            sum=0
            for _ in range(n):
                noder = queue.popleft()
                sum+=noder.val
                if noder.left: queue.append(noder.left)
                if noder.right:queue.append(noder.right)
            res.append(sum/n)
        return res

429. N 叉树的层序遍历 - 力扣（LeetCode） (leetcode-cn.com)

"""
# 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 []
        #用队列
        res,depth=[],-1
        queue= deque([root])
        while queue:
            res.append([])
            depth+=1
            for _ in range(len(queue)):
                noder = queue.popleft()
                res[depth].append(noder.val)
                if len(noder.children):queue.extend(noder.children)
        return res

515. 在每个树行中找最大值 - 力扣（LeetCode） (leetcode-cn.com)

# 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 []
        queue= deque([root])
        res=[]
        while queue:
            resLs=[]
            for __ in range(len(queue)):
                noder = queue.popleft()
                resLs.append(noder.val)
                if noder.left: queue.append(noder.left)
                if noder.right:queue.append(noder.right)
            res.append(max(resLs))
        return res

116. 填充每个节点的下一个右侧节点指针 - 力扣（LeetCode） (leetcode-cn.com)

"""
# 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
        queue= deque([root])
        while queue:
            for _ in range(len(queue)):
                noder =queue.popleft()
                if _: noderLeft.next = noder
                if noder.left: queue.append(noder.left)
                if noder.right:queue.append(noder.right)
                noderLeft= noder
        return root

117. 填充每个节点的下一个右侧节点指针 II - 力扣（LeetCode） (leetcode-cn.com)

"""
# 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
         #用队列
         queue = deque([root])
         while queue:
               for _ in range(len(queue)):
                  noder = queue.popleft()
                  if _: nodeLeft.next = noder
                  nodeLeft = noder
                  if noder.left:queue.append(noder.left)
                  if noder.right:queue. append(noder.right)
         return root   

104. 二叉树的最大深度 - 力扣（LeetCode） (leetcode-cn.com)

# 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: TreeNode) -> int:
          if not root:return 0
          queue =deque([root])
          dapth=0
          while queue:
              dapth+=1
              for _ in range(len(queue)):
                 noder= queue.popleft()
                 if noder.left: queue. append(noder.left)
                 if noder.right: queue. append(noder.right)
          return dapth

111. 二叉树的最小深度 - 力扣（LeetCode） (leetcode-cn.com)

# 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: TreeNode) -> int:
      if not root:return 0
      depth=0
      queue=deque([root])
      while queue:
         depth+=1
         for _ in range(len(queue)):
             noder = queue.popleft()
             if not noder.left and not noder.right: return depth
             if noder.left: queue.append( noder.left)
             if noder.right: queue.append( noder.right)
      return 0

3.对称二叉树

101. 对称二叉树 - 力扣（LeetCode） (leetcode-cn.com)

# 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: TreeNode) -> bool:
        '''
        #递归法：
        def compare(noderleft, noderright):
            #首先排除空节点的情况
            if not noderleft or not noderright:
                if not noderleft and not noderright:return True
                else:return False
            elif noderleft.val != noderright.val:return False

            #此时就是：左右节点都不为空，且数值相同的情况
            #此时才做递归，做下一层的判断
            outside =compare(noderleft.left, noderright.right) #左子树：左、 右子树：右
            inside  =compare(noderleft.right,noderright.left)  #左子树：右、 右子树：左
            return outside and inside                          #左子树：中、 右子树：中 （逻辑处理）
        return compare(root.left,root.right)
         '''
        '''
         #迭代法：用队列
        queue = deque([])
        queue.append(root.left)
        queue.append(root.right)
        while queue:
              leftnoder= queue.popleft()
              righnoder= queue.popleft()
              if not leftnoder and not righnoder: continue  #两个都为空 说明镜像
              if not leftnoder or not righnoder or leftnoder.val!= righnoder.val: return False
              queue.append(leftnoder.left)
              queue.append(righnoder.right)
              queue.append(leftnoder.right)
              queue.append(righnoder.left)
        return True
       '''
         #迭代法：用栈
        stacker = deque([])
        stacker.append(root.right)
        stacker.append(root.left)
        while stacker:
              leftnoder= stacker.pop()
              righnoder= stacker.pop()
              if not leftnoder and not righnoder: continue  #两个都为空 说明镜像
              if not leftnoder or not righnoder or leftnoder.val!= righnoder.val: return False
              stacker.append(righnoder.left)
              stacker.append(leftnoder.right)
              stacker.append(righnoder.right)
              stacker.append(leftnoder.left)
        return True         

100. 相同的树 - 力扣（LeetCode） (leetcode-cn.com)

# 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 isSameTree(self, p: TreeNode, q: TreeNode) -> bool:
        #相当于是从二叉树的第二层开始的
        #用栈把
        stacker = [p,q]

        while stacker:
            righnoder = stacker.pop()
            leftnoder = stacker.pop()

            if not righnoder and not leftnoder: continue
            if not righnoder or not leftnoder or righnoder.val!= leftnoder.val:return False

            stacker.append(leftnoder.left)   #注意这个顺序
            stacker.append(righnoder.left)
            stacker.append(leftnoder.right)
            stacker.append(righnoder.right)
        return True

572. 另一棵树的子树 - 力扣（LeetCode） (leetcode-cn.com)

# 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 isSubtree(self, root: TreeNode, subRoot: TreeNode) -> bool:
        def issame(noder,subRoot)->bool:
        #然后类似比较镜像方式 从第二个节点开始
        #用队列
            queue =deque([noder,subRoot])
            while queue:
                leftnoder = queue.popleft()
                righnoder = queue.popleft()
                if not leftnoder and not righnoder:continue
                if not leftnoder or not righnoder or leftnoder.val != righnoder.val:return False
                queue.append(leftnoder.left)
                queue.append(righnoder.left)
                queue.append(leftnoder.right)
                queue.append(righnoder.right)   
            return True

        #首先层序寻找 根节点的位置
        queue= deque([root])
        while queue:
            noder = queue.popleft()
            if noder.val == subRoot.val:
                if issame(noder,subRoot):return True
            if noder.left: queue.append(noder.left)
            if noder.right:queue.append(noder.right)
        return False

4.总结

太多了，感觉明天弄不完了，最多给自己四天时间把。。