Day15代码随想录二叉树part02：层次遍历

Day15 二叉树part02

层次遍历：

102.二叉树的层序遍历

题意：给你一个二叉树，请你返回其按 层序遍历 得到的节点值。 （即逐层地，从左到右访问所有节点）。

思路：类似广度优先搜索，使用队列

具体步骤：以[6,4,7,1,3,5,8]这个树为例，首先将root = 6放入队列，记录size=1；随后size为1的弹出6，push进左右儿子4，7，记录size=2；再pop出size=2个，分别推入左右儿子

# 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 levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
        if not root:
            return []
        res = []
        que = collections.deque([root]) # 建立双端队列
        while que:
            res_i = []
            for i in range(len(que)): 
                #这里可以不用单独记录size而是直接用循环是因为在使用这个循环的时候len(que)是固定的
                cur = que.popleft()
                res_i.append(cur.val)
                if cur.left:
                    que.append(cur.left)
                if cur.right:
                    que.append(cur.right)
            res.append(res_i)
        return res

107.二叉树的层次遍历 II

题意：刚刚是由顶向下遍历二叉树，这次希望能够由底向上遍历，也就是先输出下面的层

一开始的思路：可能要用栈做，先顺序从上到下压入队列，然后弹出到栈并且要记录size

一个非常聪明的思路：相比于刚刚普通的层次遍历，只需要把最后的result反转就可以了！

只需要最后return res[::-1]

199.二叉树的右视图

还是照常遍历，但是最后取出每一层最后一个元素即可；下面的写法可能时间复杂度高了一点，可以直接在res保存的时候操作

real_res = []
        for i in range(len(res)):
            real_res.append(res[i][-1])
        return real_res

完整写法：

import collections
class Solution:
    def rightSideView(self, root: Optional[TreeNode]) -> List[int]:
        if not root:
            return []
        res = []
        que = collections.deque([root]) # 建立双端队列
        while que:
            size = len(que)
            for i in range(len(que)): 
            #这里可以不用单独记录size而是直接用循环是因为在使用这个循环的时候len(que)是固定的
                cur = que.popleft()
                # print(i, cur.val)
                if i+1 == size:
                    res.append(cur.val)
                if cur.left:
                    que.append(cur.left)
                if cur.right:
                    que.append(cur.right)
        return res

429. N 叉树的层序遍历

一个树有多个孩子就依次处理即可：

from collections import deque
class Solution:
    def levelOrder(self, root: 'Node') -> List[List[int]]:
        if not root:
            return []
        que = deque([root])
        res = []
        while que:
            res_i = []
            for i in range(len(que)):
                cur = que.popleft()
                res_i.append(cur.val)
                children = cur.children
                for j in range(len(children)):
                    que.append(children[j])
            res.append(res_i)
        return res

二叉树的翻转和对称：

226.翻转二叉树

注意：这道题最后想要输出的是root节点，而不是一个反转之后正确的数组，所以只保留数组值是不可行的

这部分可以再看一下递归的代码和非递归的代码，最好使用前序或者后续遍历

本题采用的层次遍历进行交换

from collections import deque
class Solution:
    def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
        if not root:
            return None
        que = deque([root])
        while que:
            for i in range(len(que)):
                cur = que.popleft()
                cur.left, cur.right = cur.right, cur.left
                if cur.left:
                    que.append(cur.left)
                if cur.right:
                    que.append(cur.right)
        return root

101. 对称二叉树

一个比较笨拙的写法：

from collections import deque
class Solution:
    def isSymmetric(self, root: Optional[TreeNode]) -> bool:
        if not root:
            return []
        que = deque([root])
        inf = float('inf')
        while(que):
            res_i = []
            for i in range(len(que)):
                cur = que.popleft()
                # res_i.append(cur.val)
                if cur.left:
                    que.append(cur.left)
                    res_i.append(cur.left.val)
                if not cur.left:
                    res_i.append(inf)
                if cur.right:
                    res_i.append(cur.right.val)
                    que.append(cur.right)
                if not cur.right:
                    res_i.append(inf)
            print(res_i)
            if res_i != res_i[::-1]:
                return False
        return True