leetcode 二叉树的层次遍历题型汇总 python

最新推荐文章于 2023-04-12 22:26:02 发布

15plus

最新推荐文章于 2023-04-12 22:26:02 发布

阅读量327

点赞数

CC 4.0 BY-SA版权

本文链接：https://blog.youkuaiyun.com/weixin_42664431/article/details/102562137

本文总结了LeetCode中关于二叉树层次遍历的题目，包括常规层次遍历、自底向上层次遍历和锯齿形层次遍历。通过广度优先搜索（BFS）策略，结合不同返回顺序，可以解决这类问题。同时提到了两道层次遍历的变形题，填充每个节点的下一个右侧节点指针。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

二叉树的层次遍历题型通用思路：
1.首先判断是用bfs还是dfs（这里的三道题因为是按层返回所以都用bfs来实现）
2.判断一下是用先进后出的栈还是先进先出的队列来保存数据
3.划分当前层和下一层，逐层返回即可。

下面是例题：

Leetcode 107. 二叉树的层次遍历https://leetcode-cn.com/problems/binary-tree-level-order-traversal-ii/：
给定一个二叉树，返回其节点值自底向上的层次遍历。（即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）

class Solution:
    def levelOrderBottom(self, root: TreeNode) -> List[List[int]]:
        from collections import deque
        if not root: return []
        queue = deque()
        queue.appendleft(root)
        res = []
        while queue:
            tmp = []
            n = len(queue)
            for _ in range(n):
                node = queue.pop()
                tmp.append(node.val)
                if node.left:
                    queue.appendleft(node.left)
                if node.right:
                    queue.appendleft(node.right)
            res.insert(0, tmp)
        return res

二叉树的层次遍历 https://leetcode-cn.com/problems/binary-tree-level-order-traversal/
给定一个二叉树，返回其按层次遍历的节点值。（即逐层地，从左到右访问所有节点）。

class Solution:
    def levelOrder(self, root: TreeNode) -> List[List[int]]:
        if not root:
            return []
        res = []
        cur_level = [root]
        
        while cur_level:
            tmp = []
            next_level = []
            for node in cur_level:
                tmp.append(node.val)
                if node.left:
                    next_level.append(node.left)
                if node.right:
                    next_level.append(node.right)
            res.append(tmp)
            cur_level = next_level
        return res

二叉树的锯齿形层次遍历 https://leetcode-cn.com/problems/binary-tree-zigzag-level-order-traversal/
给定一个二叉树，返回其节点值的锯齿形层次遍历。（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。
这道题是102题的升级版，解题的思路也大体相同。在实现锯齿型遍历的时候可以用一个布尔值left_to_right来判断当前的这一层应该是从什么方向返回。

class Solution:
    def zigzagLevelOrder(self, root: TreeNode) -> List[List[int]]:  
        if not root:
            return []
        cur_level = [root]
        res = []
        left_to_right = True
        
        while cur_level:
            next_level = []
            tmp = []
            for node in cur_level:
                tmp.append(node.val)
                if node.left:
                    next_level.append(node.left)
                if node.right:
                    next_level.append(node.right)
            cur_level = next_level
            if left_to_right == True:
                res.append(tmp)
            else:
                res.append(tmp[::-1])
            left_to_right = not left_to_right
        return res

还有两道二叉树的层次遍历的变形题一并附上：
116. 填充每个节点的下一个右侧节点指针（https://leetcode-cn.com/problems/populating-next-right-pointers-in-each-node/）
117. 填充每个节点的下一个右侧节点指针 II （https://leetcode-cn.com/problems/populating-next-right-pointers-in-each-node-ii/）
这两道题的解法也是通过bfs的迭代来解，只要对上面的代码稍加变形即可。

class Solution:
    def connect(self, root: 'Node') -> 'Node':
        if not root:
            return None
        cur_level = [root]
        while cur_level:
            next_level = []
            for node in cur_level:
                if node.left:
                    next_level.append(node.left)
                if node.right:
                    next_level.append(node.right)
            #在这里改动一下，依次给当前层中所有点加上next指针即可。
            for i in range(len(cur_level) - 1):
                cur_level[i].next = cur_level[i + 1]
            cur_level = next_level
            
        return root