代码随想录刷题 Day16

二叉数的层序遍历

DFS，深度优先搜索用的是栈，因为先进后出的特性->想一想调用栈，暂停当前程序并记录当前程序的位置，先处理别的程序，然后再回来处理当前程序

BFS，广度优先搜索用的是队列，先进先出，一层一层处理

python 复制代码

from collections import deque
class Solution:
    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
        res=[]
        queue=deque()
        count=0
        if root==None:
            return res
        else:
            queue.append(root)
        while(queue):
            tmp=[]
            for _ in range(len(queue)): #一次输出一层的内容，用for循环实现
                node=queue.popleft()
                tmp.append(node.val)
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
            res.append(tmp)
        return res

while(queue) 每次进循环都是处理了一层的数据-> for 循环的功劳二叉树层序遍历Ⅱ是从左到右，从下到上遍历，只需要把上述代码的res翻转一下即可

二叉树的右视图

python 复制代码

class Solution:
    def rightSideView(self, root: Optional[TreeNode]) -> List[int]:
        res=[]
        queue=deque()
        if root:
            queue.append(root)
        else:
            return res
        while(queue):
            res.append(queue[0].val)
            for _ in range(len(queue)):
                node=queue.popleft()
                if node.right:
                    queue.append(node.right)
                if node.left:
                    queue.append(node.left)
        return res

这里只需要注意一下每一层每个节点入队的顺序（先右后左），然后存结果的时候只存队首（即该层最右节点）的值即可

二叉树的层平均值

python 复制代码

from collections import deque
class Solution:
    def averageOfLevels(self, root: Optional[TreeNode]) -> List[float]:
        queue=deque()
        queue.append(root)
        res=[]

        while(queue):
            n=len(queue)
            sum=0
            for _ in range(n):
                node=queue.popleft()
                sum+=node.val
                if node.left: #记得一遍遍历该层节点，一遍把下一层的节点加进来
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
            avg=sum/n
            res.append(avg)
        return res

层序遍历要注意，一边处理一层节点，一边就要把下一层的节点加进来了

N叉树的层序遍历

python 复制代码

from collections import deque
class Solution:
    def levelOrder(self, root: 'Node') -> List[List[int]]:
        queue=deque()
        res=[]
        if root:
            queue.append(root)
        else:
            return res
        while(queue):
            level=[]
            for _ in range(len(queue)):
                node=queue.popleft()
                level.append(node.val)
                if node.children:
                    for pointer in node.children:
                        queue.append(pointer)
            res.append(level)
        return res

N叉树就是有多个孩子，每次遍历一层的时候把多个孩子都加进来就行，这多个孩子应该默认就是从左到右的顺序

在每个树行中找到最大值

python 复制代码

from collections import deque
class Solution:
    def largestValues(self, root: Optional[TreeNode]) -> List[int]:
        queue=deque()
        res=[]
        if not root:
            return res
        else:
            queue.append(root)
        while(queue):
            max=-inf
            for _ in range(len(queue)):
                node=queue.popleft()
                if node.val>max:
                    max=node.val 
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
            res.append(max)
        return res

也是以层序遍历为基础的题目。

填充每一个节点的下一个右侧指针

python 复制代码

from collections import deque
class Solution:
    def connect(self, root: 'Optional[Node]') -> 'Optional[Node]':
        queue=deque()
        if not root:
            return
        queue.append(root)
        while(queue):
            level=[]
            for _ in range(len(queue)):
                node=queue.popleft()
                level.append(node)
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
            for i in range(len(level)-1): #只需要遍历len(level)-1个节点
                level[i].next=level[i+1]
        return root

这道题其实还蛮有意思的，我的做法是先遍历每一层的节点，并把他们存下来，然后再填充右侧指针

或者其实还有个办法，就是用一个last_node把上一个节点存下来，然后让上一个节点指向当前节点

python 复制代码

from collections import deque
class Solution:
    def connect(self, root: 'Optional[Node]') -> 'Optional[Node]':
        queue=deque()
        if not root:
            return
        queue.append(root)
        while(queue):
            last_node=None #需要先定义一下
            for _ in range(len(queue)):
                node=queue.popleft()
                if last_node: #每层的第一个节点没有last_node，所以需要判断一下
                    last_node.next=node
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
                last_node=node
        return root

二叉树的最大深度

python 复制代码

from collections import deque
class Solution:
    def maxDepth(self, root: Optional[TreeNode]) -> int:
        queue=deque()
        res=0
        if not root:
            return res
        queue.append(root)
        while(queue):
            res+=1
            for _ in range(len(queue)):
                node=queue.popleft()
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
        return res

二叉树的最小深度

python 复制代码

from collections import deque
class Solution:
    def minDepth(self, root: Optional[TreeNode]) -> int:
        queue=deque()
        res=0
        if not root:
            return res
        queue.append(root)
        while(queue):
            res+=1
            for _ in range(len(queue)):
                node=queue.popleft()
                if not node.left and not node.right:
                    return res
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)
        return res

层序遍历总结

首先需要理解这个层序遍历的实现，毕竟不是所有代码都能死记硬背实现。层序遍历是需要靠队列来实现。层序遍历的时候 queue 里存的都是当前这一层的所有节点。利用 for 循环可以实现每次处理完一层的节点。每次处理一个节点要把它从队列里弹出来处理，然后如果有左右孩子的话记得要按序加入到队尾

层序遍历的模板可以写成这样：

python 复制代码

from collections import deque
class Solution:
    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
        queue=deque()
        if not root:
            return res
        queue.append(root)
        while(queue):
            '''
            处理这一层的代码
            '''
            for _ in range(len(queue)):
                node=queue.popleft()
                '''
                处理这个节点的代码
                '''
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)

然后具体题目只是在这个模板里改变"怎么处理节点"和"怎么保存结果"。