Leetcode| 二叉树的层序遍历、226. 翻转二叉树、101. 对称二叉树 Day15

二叉树的层序遍历

队列先进先出，符合一层一层遍历的逻辑。

102. Binary Tree Level Order Traversal

# 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
from queue import Queue
class Solution:
    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
        que = Queue()
        res = []
        if root == None:
            return res
        que.put(root)
        while not que.empty():
            tmp = []
            size = que.qsize()
            for _ in range(size):
                node = que.get()
                tmp.append(node.val)
                if node.left:
                    que.put(node.left)
                if node.right:
                    que.put(node.right)
            res.append(tmp)
        return res

107. Binary Tree Level Order Traversal 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
from queue import Queue
class Solution:
    def levelOrderBottom(self, root: Optional[TreeNode]) -> List[List[int]]:
        que = Queue()
        res = []
        if root == None:
            return res
        que.put(root)
        while not que.empty():
            tmp = []
            size = que.qsize()
            for _ in range(size):
                node = que.get()
                tmp.append(node.val)
                if node.left:
                    que.put(node.left)
                if node.right:
                    que.put(node.right)
            res.append(tmp)
        res.reverse()
        return res

199. Binary Tree Right Side View

# 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
from queue import Queue
class Solution:
    def rightSideView(self, root: Optional[TreeNode]) -> List[int]:
        que = Queue()
        res = []
        if root == None:
            return res
        que.put(root)
        while not que.empty():
            tmp = []
            size = que.qsize()
            for _ in range(size):
                node = que.get()
                tmp.append(node.val)
                if node.left:
                    que.put(node.left)
                if node.right:
                    que.put(node.right)
            res.append(tmp[-1])
        return res

637. Average of Levels in Binary Tree

# 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
from queue import Queue
class Solution:
    def averageOfLevels(self, root: Optional[TreeNode]) -> List[float]:
        que = Queue()
        res = []
        if root == None:
            return res
        que.put(root)
        while not que.empty():
            tmp = []
            size = que.qsize()
            for _ in range(size):
                node = que.get()
                tmp.append(node.val)
                if node.left:
                    que.put(node.left)
                if node.right:
                    que.put(node.right)
            average = sum(tmp) / size
            res.append(average)
        return res

429. N-ary Tree Level Order Traversal

"""
# Definition for a Node.
class Node:
    def __init__(self, val=None, children=None):
        self.val = val
        self.children = children
"""
from queue import Queue
class Solution:
    def levelOrder(self, root: 'Node') -> List[List[int]]:
        que = Queue()
        res = []
        if root == None:
            return res
        que.put(root)
        while not que.empty():
            tmp = []
            size = que.qsize()
            for _ in range(size):
                node = que.get()
                tmp.append(node.val)
                if node.children:
                    for child in node.children:
                        que.put(child)
            res.append(tmp)
        return res

515. Find Largest Value in Each Tree Row

# 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
from queue import Queue
class Solution:
    def largestValues(self, root: Optional[TreeNode]) -> List[int]:
        que = Queue()
        res = []
        if root == None:
            return res
        que.put(root)
        while not que.empty():
            tmp = []
            size = que.qsize()
            for _ in range(size):
                node = que.get()
                tmp.append(node.val)
                if node.left:
                    que.put(node.left)
                if node.right:
                    que.put(node.right)
            res.append(max(tmp))
        return res

116. Populating Next Right Pointers in Each Node

"""
# 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
"""
from collections import deque
class Solution:
    def connect(self, root: 'Optional[Node]') -> 'Optional[Node]':
        que = deque()
        if root == None:
            return root
        que.append(root)
        while que:
            size = len(que)
            for i in range(size):
                node = que.popleft()
                if i == size - 1:
                    node.next = None
                else:
                    node.next = que[0]
    
                if node.left:
                    que.append(node.left)
                if node.right:
                    que.append(node.right)

        return root

117. Populating Next Right Pointers in Each Node 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
"""
from collections import deque
class Solution:
    def connect(self, root: 'Node') -> 'Node':
        que = deque()
        if root == None:
            return root
        que.append(root)
        while que:
            size = len(que)
            for i in range(size):
                node = que.popleft()
                if i == size - 1:
                    node.next = None
                else:
                    node.next = que[0]
    
                if node.left:
                    que.append(node.left)
                if node.right:
                    que.append(node.right)

        return root

104. Maximum Depth of Binary Tree

# 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
from queue import Queue
class Solution:
    def maxDepth(self, root: Optional[TreeNode]) -> int:
        res = 0
        que = Queue()
        if root == None:
            return res
        que.put(root)
        while not que.empty():
            size = que.qsize()
            for _ in range(size):
                node = que.get()
                if node.left:
                    que.put(node.left)
                if node.right:
                    que.put(node.right)
            res += 1
        return res

111. Minimum Depth of Binary Tree

# 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
from queue import Queue
class Solution:
    def minDepth(self, root: Optional[TreeNode]) -> int:
        res = 0
        que = Queue()
        if root == None:
            return res
        que.put(root)
        while not que.empty():
            size = que.qsize()
            for _ in range(size):
                node = que.get()
                if not node.left and not node.right:    # 叶子节点
                    return res + 1
                if node.left:
                    que.put(node.left)
                if node.right:
                    que.put(node.right)
            res += 1
        # return res

---

226. Invert Binary Tree

# 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]:
        def preTraversal(root):
            if root == None:
                return
            root.left, root.right = root.right, root.left   # 中
            preTraversal(root.left)                         # 左
            preTraversal(root.right)                        # 右
        
        preTraversal(root)
        return root

---

101. Symmetric Tree

# 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: Optional[TreeNode]) -> bool:

        def compare(left, right):
            # 存在空节点
            if left == None and right != None:
                return False
            if left != None and right == None:
                return False
            if left == None and right == None:
                return True
            # 不存在空节点，数值不相等
            if left.val != right.val:
                return False

            # 此时就是：左右节点都不为空，且数值相同的情况
            # 此时才做递归，做下一层的判断
            outside = compare(left.left, right.right)
            inside = compare(left.right, right.left)
            isSame = outside and inside
            return isSame

        if root == None:
            return True
        return compare(root.left, root.right)