二叉树的层序遍历 - 灵神视频总结

养那个乐多

已于 2024-07-01 13:59:27 修改

阅读量1.6k

点赞数 48

分类专栏：算法刷题文章标签：算法数据结构 python

于 2024-07-01 13:38:17 首次发布

本文链接：https://blog.csdn.net/weixin_43939296/article/details/140098711

版权

算法刷题专栏收录该内容

13 篇文章 2 订阅

订阅专栏

这节课讲了二叉树的层次遍历，就是一层层的遍历。

关于二叉树相关的文章：

这节课讲了二叉树的层次遍历，就是一层层的遍历。

可以设置两个数组， cur 用来存储第一层，nxt 用来存储下一层的节点。

只要cur 不为空，就需要存储当前节点的值，并把下一层的节点存储在nxt中。当一次循环结束之后，需要把cur = nxt，继续遍历，知道所有的节点都遍历完。

# 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
class Solution:
    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
        ans = []
        if root is None:
            return []
        cur = [root]
        while cur : 
            nxt = []
            vals = []
            for node in cur:
                vals.append(node.val)
                if node.left: nxt.append(node.left)
                if node.right: nxt.append(node.right)
            cur = nxt
            ans.append(vals)
        return ans

那有个问题哈， cur nxt 能不能合并成一个数组呢？这种结构就是先进先出的结构。这种数据结构叫队列，python中使用 deque来实现。代码也很简单，就是需要熟悉deque的两个函数， popleft(), append()，把节点移除和添加新的节点。

这里值得说明的是，BFS算法一般都可以使用队列才操作。不管是二叉树还是多叉树。

代码：

# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
        ans = []
        if root is None:
            return []
        q = deque([root])
        while q : 
            vals = []
            for _ in range(len(q)):
                node = q.popleft()
                vals.append(node.val)
                if node.left: q.append(node.left)
                if node.right: q.append(node.right)
            ans.append(vals)
        return ans

103. 二叉树的锯齿形层序遍历

和上一题一样，只不过是偶数层要反转一下，设置一个even变量即可，如果even = True，直接反转数组。

时空复杂度都是O(n)

python 反转数组为 vals[::-1]

代码

# 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
class Solution:
    def zigzagLevelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
        ans = []
        if root is None:
            return []
        q = deque([root])
        even = False
        while q : 
            vals = []
            for _ in range(len(q)):
                node = q.popleft()
                vals.append(node.val)
                if node.left: q.append(node.left)
                if node.right: q.append(node.right)
            ans.append(vals[::-1] if even else vals)
            even = not even
        return ans

513. 找树左下角的值

其实就是找到最后一层的第一个节点即可。

# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def findBottomLeftValue(self, root):
        # 节点最少为1个, 不需要判别空。
        ans = []
        q = deque([root])
        while q: 
            vals = []
            for _ in range(len(q)):
                node = q.popleft()
                vals.append(node.val)
                if node.left : q.append(node.left)
                if node.right : q.append(node.right)
            ans.append(vals)
        print(ans)
        print(vals)
        return ans[-1][0]

视频给了另外一种解法

把入队的顺序变成从右向左，最后一个节点节点即是第一个节点；

这种做法在右视图中也经常用的到。

# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def findBottomLeftValue(self, root: Optional[TreeNode]) -> int:
        q = deque([root])
        while q:
            node = q.popleft()
            if node.right: q.append(node.right)
            if node.left: q.append(node.left)
        return node.val

系列文章