层序遍历学好了可以解十道题

本专题来自代码随想录,链接:

代码随想录

学会二叉树的层序遍历，可以一口气打完以下十题(来源:代码随想录)：

• 102.二叉树的层序遍历(opens new window)
• 107.二叉树的层次遍历II(opens new window)
• 199.二叉树的右视图(opens new window)
• 637.二叉树的层平均值(opens new window)
• 429.N叉树的层序遍历(operuns new window)
• 515.在每个树行中找最大值(opens new window)
• 116.填充每个节点的下一个右侧节点指针(opens new window)
• 117.填充每个节点的下一个右侧节点指针II(opens new window)
• 104.二叉树的最大深度(opens new window)
• 111.二叉树的最小深度

层序遍历需要用队列来求解,队列也是在广度优先里常用的数据结构.层序遍历最基础的代码如下:

class Solution:
    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
        if not root:
            return []##树为空,返回也为空
        que = collections.deque([root])   ##创建队列    
        res = []
        while que:
            level = []   ##创建当前层需要返回的一维数组
            levelsize = len(que)  ##记录当前队列里有几个数,有几个数就在下面的for循环循环几次
            for i in range(levelsize):  ##这个for循环循环一次,遍历完当前层的所有结点
                cur = que.popleft()  ##取出当前结点元素
                level.append(cur.val)  ##把结点元素放入一位数组中
                if cur.left:  ##如果当前结点有左右子结点,就放到队列中
                    que.append(cur.left)
                if cur.right:
                    que.append(cur.right)
            res.append(level)##将当前层的一维数组放入res中,res是个二维数组
        return res

如果是自底向上遍历,把结果倒过来就好了,代码如下:

class Solution:
    def levelOrderBottom(self, root: Optional[TreeNode]) -> List[List[int]]:
        if not root:
            return []
        queue = collections.deque([root])
        res = []
        while queue:
            levelsize = len(queue) 
            for i in range(levelsize):
                cur = queue.popleft()
                level = []
                res.append(cur.val)
                if cur.left:
                    queue.append(cur.left)
                if cur.right:
                    queue.append(cur.right) 
        return res[::-1]  

二叉树右视图

如果是只返回最右边结点,在for循环中判断是不是到了最右边结点,如果是,返回即可:

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

二叉树层平均值

如果是求每一层平均值,在for循环外计算一下就好

class Solution:
    def averageOfLevels(self, root: Optional[TreeNode]) -> List[float]:
        que = collections.deque([root])
        res = []
        while que:
            levelsize = len(que)
            sum = 0
            for i in range(levelsize):
                cur = que.popleft()
                sum += cur.val
                if cur.left:
                    que.append(cur.left)
                if cur.right:
                    que.append(cur.right)
            res.append(sum/levelsize)
        return res
                

N叉树层序遍历

如果是N叉树,那就把for循环里的判断有没有左右子节点改为for循环,遍历所有子节点,然后加到que里面去:

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

二叉树每层最大值

如果是求最大值也是修改一下就好

class Solution:
    def largestValues(self, root: Optional[TreeNode]) -> List[int]:
        if not root:
            return []
        que = collections.deque([root])
        res = []
        while que:
            level = []
            levelsize = len(que)
            for i in range(levelsize):
                cur = que.popleft()
                level.append(cur.val)
                if cur.left:
                    que.append(cur.left)
                if cur.right:
                    que.append(cur.right)
            maxnum = max(level)
            res.append(maxnum)
        return res

填充二叉树同一层右侧结点指针(完全二叉树和非完全二叉树一样)

如果想把同一层的数据当链表一样从左到右串起来,也是在这个基础上改下:

class Solution:
    def connect(self, root: 'Optional[Node]') -> 'Optional[Node]':
        if not root:
            return root
        que = collections.deque([root])
        # res = []
        while que:
            levelsize = len(que)
            prev = None #设一个结点,是当前层,且当前结点的前一个结点
            for i in range(levelsize):
                cur = que.popleft()
                if prev:#如果当前层的结点,有前一个结点
                    prev.next = cur #前一个结点的指针指向当前结点
                prev = cur #指完之后记得更新prev的值
                if cur.left:
                    que.append(cur.left)
                if cur.right:
                    que.append(cur.right)
        return root

如果不是完全二叉树,也没有影响,代码和上面一样.

二叉树最大深度

求二叉树最大深度,可以用层序遍历,记住自己遍历的多少层就行:

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

二叉树最小深度

求最小深度,多家一个判断是否为叶子节点的代码即可:

class Solution:
    def minDepth(self, root: Optional[TreeNode]) -> int:
        if not root:
            return 0
        que = collections.deque([root])
        res = 0
        while que:
            levelsize = len(que)
            for i in range(levelsize):
                cur = que.popleft()
                if not cur.left and not cur.right:#判断是否为叶子节点
                    res += 1
                    return res
                if cur.left:
                    que.append(cur.left)
                if cur.right:
                    que.append(cur.right)
            res += 1
        return res