代码随想录算法训练营第十五天｜层序遍历 ， 226.翻转二叉树， 101.对称二叉树

226.翻转二叉树

思路： 直接用递归就行了

class Solution:
    def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:        
        if not root:
            return None
        tmp = root.left
        root.left = self.invertTree(root.right)
        root.right = self.invertTree(tmp)
        return root
        

101.对称二叉树

思路： 刚开始想反转root一边，然后两边对比， 但是发现 == 好像有问题， 不能判断两个subTree 是不是一样的。 那我就遍历两个subtree。 左边的 中左右 （顺序遍历） 右边的中右左。 然后判断遍历出来的元素是不是一样的， 注意none 也要放进去考虑

class Solution:
    def isSymmetric(self, root: Optional[TreeNode]) -> bool:

        def search_l2r(node):
            if not node:
                return [None]
            return [node.val] + search_l2r(node.left) + search_l2r(node.right)
        
        def search_r2l(node):
            if not node:
                return [None]
            return [node.val] + search_r2l(node.right) + search_r2l(node.left)

        if not root:
            return True

        left_vals = search_l2r(root.left)
        right_vals = search_r2l(root.right)
        return left_vals == right_vals

层序遍历：

思路：逐层遍历二叉树的元素。 典型的 bfs 算法应用。 首先把 root 推进queue，然后外层用while 循环直到 queue 里面空了， 内层用 for 循环， i 从 0 到 循环前的len(q)，len(q) 就是当前层数的元素， 内层循环可以把当前层的元素全部pop 出来， 然后每个元素如果有left 或者 right， 就把left 和 right 不为 null 在放进queue。 

训练题有10 个， 但是循环的结构都是一样的。 

class Solution:
    def minDepth(self, root: Optional[TreeNode]) -> int:
        if not root:
            return 0
        q = deque([root])
        ans = 0
        while q:
            ans += 1
            l = len(q)
            for i in range(l):
                cur_node = q.popleft()
                if not (cur_node.left or cur_node.right):
                    return ans
                if cur_node.left: q.append(cur_node.left)
                if cur_node.right: q.append(cur_node.right)
                

# Leetcode 104
class Solution:
    def maxDepth(self, root: Optional[TreeNode]) -> int:
        if not root:
            return 0
        q = deque([root])
        ans = 0
        while q:
            ans += 1
            l = len(q)
            for i in range(l):
                cur_node = q.popleft()
                if cur_node.left: q.append(cur_node.left)
                if cur_node.right: q.append(cur_node.right)
        return ans

​
# Leetcode 117
class Solution:
    def connect(self, root: 'Node') -> 'Node':
        if not root:
            return None
        q = deque([root])
        while q:
            l = len(q)
            for i in range(l):
                cur_node = q.popleft()
                if i == l-1:
                    cur_node.next = None
                else:
                    cur_node.next = q[0]
                if cur_node.left: q.append(cur_node.left)
                if cur_node.right: q.append(cur_node.right)
        return root

​

# Leetcode 102

from collections import deque

class Solution:
    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
        if not root:
            return []
        q = deque([root])
        ans = []
        while q:
            ans_one_layer = []
            i, n = 0, len(q)
            while i < n:
                i += 1
                cur_node = q.popleft()
                ans_one_layer.append(cur_node.val)
                if cur_node.left: q.append(cur_node.left)
                if cur_node.right: q.append(cur_node.right)                
            ans.append(ans_one_layer)
        return ans

# Leetcode 107
from queue import Queue

class Solution:
    def levelOrderBottom(self, root: Optional[TreeNode]) -> List[List[int]]:
        if not root:
            return []
        q = Queue()
        q.put(root)
        ans = []
        while not q.empty():
            n = q.qsize()
            one_layer_vals = []
            for i in range(n):
                cur_node = q.get()
                one_layer_vals.append(cur_node.val)
                if cur_node.left: q.put(cur_node.left)
                if cur_node.right: q.put(cur_node.right)
            ans.append(one_layer_vals)
        return ans[::-1]

# Leetcode 199

class Solution:
    def rightSideView(self, root: Optional[TreeNode]) -> List[int]:
        if not root:
            return []
        q = deque([root])
        ans = []
        while q:
            l = len(q)
            for i in range(l):
                cur_node = q.popleft()
                if i == l-1:
                    ans.append(cur_node.val)
                if cur_node.left: q.append(cur_node.left)
                if cur_node.right: q.append(cur_node.right)
        return ans
        

# Leetcode 637
class Solution:
    def averageOfLevels(self, root: Optional[TreeNode]) -> List[float]:
        if not root:
            return []
        q = deque([root])
        ans = []
        while q:
            l = len(q)
            layer_sum = 0
            for i in range(l):
                cur_node = q.popleft()
                layer_sum += cur_node.val
                if cur_node.left: q.append(cur_node.left)
                if cur_node.right: q.append(cur_node.right)
            avg = layer_sum/l
            ans.append(avg)
        return ans

# Leetcode 429
class Solution:
    def levelOrder(self, root: 'Node') -> List[List[int]]:
        if not root:
            return []
        q = deque([root])
        ans = []
        while len(q):
            l = len(q)
            one_layer_vals = []
            for i in range(l):
                cur_node = q.popleft()
                one_layer_vals.append(cur_node.val)
                if cur_node.children: q.extend(cur_node.children)
            ans.append(one_layer_vals)
        return ans

# Leetcode 515
class Solution:
    def largestValues(self, root: Optional[TreeNode]) -> List[int]:
        if not root:
            return []
        q = deque([root])
        ans = []
        while q:
            l = len(q)
            max_val = float('-inf')
            for i in range(l):
                cur_node = q.popleft()
                max_val = max(max_val, cur_node.val)
                if cur_node.left: q.append(cur_node.left)
                if cur_node.right: q.append(cur_node.right)
            ans.append(max_val)
        return ans

# Leetcode 116
class Solution:
    def connect(self, root: 'Optional[Node]') -> 'Optional[Node]':
        if not root:
            return None
        q = deque([root])
        while q:
            l = len(q)
            for i in range(l):
                cur_node = q.popleft()
                if i == l-1:
                    cur_node.next = None
                else:
                    cur_node.next = q[0]
                if cur_node.left:
                    q.append(cur_node.left)
                    q.append(cur_node.right)
        return root