二叉树-层次遍历

已于 2023-03-16 10:35:12 修改
阅读量2.7k 收藏 3
点赞数
分类专栏： 算法复习 文章标签： python 算法 数据结构
于 2022-04-14 23:32:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sueong/article/details/124182378
版权

二叉树的层序遍历，就是图论中的广度优先搜索在二叉树中的应用，需要借助队列来实现（此时又发现队列的一个应用了）。

102.二叉树的层序遍历

在这里插入图片描述

# 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: TreeNode) -> List[List[int]]:
        result = []
        if not root:
            return result
        
        que = deque([root])
        while que:
            #获取每层的长度
            size = len(que)
            r = []
            for _ in range(size):
                #头结点出队 添加值
                cur =que.popleft()
                r.append(cur.val)
                # 左右孩子添加到队列
                if cur.left:
                    que.append(cur.left)
                if cur.right:
                    que.append(cur.right)
            result.append(r)
        return result

107.二叉树的层次遍历II

层次遍历后result反转即可
在这里插入图片描述

# 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 levelOrderBottom(self, root: TreeNode) -> List[List[int]]:
        result = []
        if not root:
            return result
        
        que =deque([root])
        while que:
            size = len(que)
            r = []
            for _ in range(size):
                cur =que.popleft()
                r.append(cur.val)
                if cur.left:
                    que.append(cur.left)
                if cur.right:
                    que.append(cur.right)
            result.append(r)
        return result[::-1]

199.二叉树的右视图

层序遍历的时候，判断是否遍历到单层的最后面的元素，如果是，就放进result数组中，随后返回result就可以了。
在这里插入图片描述

# 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 rightSideView(self, root: TreeNode) -> List[int]:
        r = []
        if not root:
            return r
        que = deque([root])
        while que:
            size = len(que)
            for i in range(size):
                cur = que.popleft()
                # 说明是本层的最后一个元素 加入
                if i == size-1:
                    r.append(cur.val)
                if cur.left:
                    que.append(cur.left)
                if cur.right:
                    que.append(cur.right)
        return r

637.二叉树的层平均值

在这里插入图片描述

# 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 averageOfLevels(self, root: Optional[TreeNode]) -> List[float]:
        r = []
        if not root:
            return r
        que = deque([root])
        
        while que:
            # 要先记下que的长度 否则移动过程长度会变化
            size = len(que)
            sum = 0
            ave = 0
            for _ in range(size):
                cur = que.popleft()
                sum += cur.val
                if cur.left:
                    que.append(cur.left)
                if cur.right:
                    que.append(cur.right)
            ave = sum/size
            r.append(ave)
        return r

429.N叉树的层序遍历

在这里插入图片描述

"""
# Definition for a Node.
class Node:
    def __init__(self, val=None, children=None):
        self.val = val
        self.children = children
"""

class Solution:
    def levelOrder(self, root: 'Node') -> List[List[int]]:
        result = []
        if not root:
            return result
        
        que = deque([root])
        
        while que:
            r = []
            size = len(que)
            for _ in range(size):
                cur = que.popleft()
                r.append(cur.val)
                # 像二叉树模板一样 队列中添加孩子结点
                if cur.children:
                    que.extend(cur.children)
            result.append(r)
        return result

515.在每个树行中找最大值

在这里插入图片描述

# 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 largestValues(self, root: Optional[TreeNode]) -> List[int]:
        result = []
        if not root:
            return result
        
        que = deque([root])
        
        while que:
            r = []
            size = len(que)
            for _ in range(size):
                cur = que.popleft()
                r.append(cur.val)
                if cur.left:
                    que.append(cur.left)
                if cur.right:
                    que.append(cur.right)
            result.append(max(r))
        return result

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

本题依然是层序遍历，只不过在单层遍历的时候记录一下本层的头部节点，然后在遍历的时候让前一个节点指向本节点就可以了。
总结：让当前结点（已经pop出来了）的next指向下一个结点，即队列里的第0个
在这里插入图片描述

"""
# Definition for a Node.
class Node:
    def __init__(self, val: int = 0, left: 'Node' = None, right: 'Node' = None, next: 'Node' = None):
        self.val = val
        self.left = left
        self.right = right
        self.next = next
"""

class Solution:
    def connect(self, root: 'Optional[Node]') -> 'Optional[Node]':
        if not root:
            return root
        
        que = deque([root])
        
        while que:
            r = []
            size = len(que)
            for i in range(size):
                cur = que.popleft()
                if cur.left:
                    que.append(cur.left)
                if cur.right:a
                    que.append(cur.right)
                # 已经到最后一个结点 next已经默认设置成None
                if i == size-1:
                    break
                # 当前结点(已经pop出来了)的next指向他的下一个结点(队列的第0元素)
                cur.next = que[0]
        return root

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

思路：

这道题目说是二叉树，但116题目说是完整二叉树，其实没有任何差别，一样的代码一样的逻辑一样的味道
在这里插入图片描述

"""
# Definition for a Node.
class Node:
    def __init__(self, val: int = 0, left: 'Node' = None, right: 'Node' = None, next: 'Node' = None):
        self.val = val
        self.left = left
        self.right = right
        self.next = next
"""

class Solution:
    def connect(self, root: 'Node') -> 'Node':
        if not root:
            return root
        
        que = deque([root])
        
        while que:
            r = []
            size = len(que)
            for i in range(size):
                cur = que.popleft()
                if cur.left:
                    que.append(cur.left)
                if cur.right:
                    que.append(cur.right)
                # 已经到最后一个结点 next已经默认设置成None
                if i == size-1:
                    break
                # 当前结点(已经pop出来了)的next指向他的下一个结点(队列的第0元素)
                cur.next = que[0]
        return root

104.二叉树的最大深度

在这里插入图片描述

# 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 maxDepth(self, root: Optional[TreeNode]) -> int:
        if not root:
            return 0
        
        que = deque([root])
        k = 0 # 记录遍历的层数 
        while que:
            r = []
            size = len(que)
            for i in range(size):
                cur = que.popleft()
                if cur.left:
                    que.append(cur.left)
                if cur.right:
                    que.append(cur.right)
            k+=1
        return k

111.二叉树的最小深度

相对于 104.二叉树的最大深度 ，本题还也可以使用层序遍历的方式来解决，思路是一样的。

需要注意的是，只有当左右孩子都为空的时候，才说明遍历的最低点了。如果其中一个孩子为空则不是最低点

 # 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 minDepth(self, root: TreeNode) -> int:
        if not root:
            return 0
        
        que = deque([root])
        k = 0 # 记录层数
        while que:
            size = len(que)
            k += 1 # 开始进入新的一层
            for i in range(size):
                cur = que.popleft()
                if cur.left:
                    que.append(cur.left)
                if cur.right:
                    que.append(cur.right)
                # 左右孩子都空 则返回k
                if cur.left == None and cur.right == None:
                    return k 

        return 0

# 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 minDepth(self, root: TreeNode) -> int:
        if not root:
            return 0

        # 根节点深度1
        que = deque([(root,1)])
        while que:
            size = len(que)
            for i in range(size):
                cur,k = que.popleft()
                # 假设是根节点 左右孩子都空 则返回k
                if cur.left == None and cur.right == None:
                    return k 
                # 因为在一个for循环内 有左还右孩子 层数都加1 
                if cur.left:
                    que.append((cur.left,k+1))
                if cur.right:
                    que.append((cur.right,k+1))

        return 0

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

在这里插入图片描述
思路：判读奇偶层数 偶数层然后翻转

# 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: TreeNode) -> List[List[int]]:
        if not root:
            return []
        res = []
        que = deque([root])
        k = 0
        while que:
            r = []
            size = len(que)
            for i in range(size):
                cur = que.popleft()
                r.append(cur.val)
                if cur.left:
                    que.append(cur.left)
                if cur.right:
                    que.append(cur.right)
            k += 1
            if k % 2 == 0:
                r = r[::-1]
            res.append(r)
        return res
sueong
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
（数据结构）二叉树层次遍历
weixin_51927215的博客
03-30 1万+
二叉树层次遍历 二叉树层次遍历的实现思想是：通过队列数据结构，从树的根结点开始，依次将其左孩子和右孩子入队；而后每次队列中一个结点出队，都将其左孩子和右孩子入队，直到树中所有结点都出队，出队结点的先后顺序就是层次遍历的最终结果 图1 二叉树 以上图 1 为例，层次遍历的过程如下： 首先，根结点 1 入队 根结点 1 出队，出队的同时，将左孩子 2 和右孩子 3 分别入队 队头结点 2 出队，出队的同时，将结点 2 的左孩子 4 和右孩子 5 依次入队 队头结点 3 ...
二叉树层序遍历
努力进大厂的小码娄
07-10 2477
二叉树的层序遍历，带详细图解。【LeetCode】判断一颗树是否为完全二叉树
二叉树的层次遍历
qq_44722109的博客
08-11 4250
二叉树的层次遍历
二叉树的遍历（七种方法）
兔子王
10-23 8000
本章主要通过运用递归与非递归方法分别对二叉树进行遍历 主要分先序遍历、中序遍历、后序遍历以及层次遍历四种情况进行讨论
层次遍历二叉树
10-24
层次遍历二叉树
二叉树的层次遍历 c语言 算法 数据结构
02-13
二叉树的层次遍历
二叉树的层次遍历-labview
06-14
层次遍历的特点是，在所有未被访问结点的集合中，排列在已访问结点集合中最前⾯结点的左⼦树的根结点将最先被访问，然后是该结 点的右⼦树的根结点。这样，如果把已访问的结点放在⼀个队列中，那么，所有未被访问...
leetcode107. 二叉树的层次遍历 II
12-23
给定一个二叉树，返回其节点值自底向上的层次遍历。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历） 例如： 给定二叉树 [3,9,20,null,null,15,7],  3  / \  9 20  / \  15 7 返回其自底向上的...
二叉树的层次遍历(python&C++)
06-07
二叉树的层次遍历，思路与实现
二叉树的层序遍历
Codenange的博客
02-08 1210
二叉树的非递归层序遍历需要借用队列来实现。
二叉树的层次遍历（C语言）
热门推荐
chenshengnanii的博客
05-24 2万+
一、二叉树的概念以及结构 二叉树是n(n>=0)个节点的有限集合，该集合或者为空集（称为空二叉树），或者由一个根节点和两棵互不相交的、分别称为根节点的左子树和右子树组。 二、二叉树的遍历图解 先序遍历 中序遍历 后序遍历 层次遍历 ...
二叉树的层序遍历，看这一篇就搞定了
qq_36917571的博客
05-17 1674
层序遍历一个二叉树。就是从左到右一层一层的去遍历二叉树。这种遍历的方式和我们之前讲过的都不太一样。需要借用一个辅助数据结构即队列来实现，队列先进先出，符合一层一层遍历的逻辑，而是用栈先进后出适合模拟深度优先遍历也就是递归的逻辑。而这种层序遍历方式就是图论中的广度优先遍历，只不过我们应用在二叉树上。 102.二叉树的层序遍历 给你一个二叉树，请你返回其按 层序遍历 得到的节点值。（即逐层地，从左到右访问所有节点） 示例：二叉树：[3,9,20,null,null,15,7] 返回其层序遍历结果： clas
二叉树的四种遍历详解（先序，中序，后序，层次）
最新发布
2301_80035594的博客
01-16 3232
详细讲解了二叉树的四种遍历，用画图的方式帮助大家理解（包括二叉树的图），并给出例题供读者学习，文中的所有代码均经过调试。
算法数据结构基础——二叉树的遍历（前序、中序、后序、层序）及python实现
学习中
08-25 1593
算法数据结构基础——二叉树的遍历（前序、中序、后序、层序）及python实现
【数据结构】二叉树的层序遍历(BFS)
Colorful___的博客
10-06 3873
层序遍历是一种广度优先搜索的遍历方式，适用于树结构。通过利用队列实现层序遍历，我们可以按照从上到下、从左到右的顺序逐层遍历树中的节点。层序遍历广泛应用于树的分析、最短路径寻找、二叉树的构建等场景。掌握层序遍历的原理和实现方法将对解决相关问题非常有帮助。
数据结构——二叉树层序遍历
mdjsmg的博客
09-20 5792
来喽来喽~ 二叉树的层序遍历来喽~层序遍历那是相当有趣滴！我的朋友，请不要迷惘，你要记住，你终有鲲鹏一日！加油吧！从现在开始~不知道有没有难住你呢！相信你不会被这些小困难绊倒！说给你，更说给我，现在的努力至少不会辜负这一点青春时光！
JAVA7-1 二叉树的层次遍历
11-11
以下是JAVA实现二叉树层次遍历的代码： ```java import java.util.LinkedList; import java.util.Queue; public class BinaryTree { private Node root; public BinaryTree() { root = null; } // 层次遍历 public void levelOrderTraversal() { if (root == null) { return; } Queue<Node> queue = new LinkedList<>(); queue.offer(root); while (!queue.isEmpty()) { Node node = queue.poll(); System.out.print(node.data + " "); if (node.left != null) { queue.offer(node.left); } if (node.right != null) { queue.offer(node.right); } } } private static class Node { private int data; private Node left; private Node right; public Node(int data) { this.data = data; left = null; right = null; } } } ``` 以上代码中，我们使用了一个队列来实现二叉树的层次遍历。首先将根节点入队，然后每次从队列中取出一个节点，输出该节点的值，并将该节点的左右子节点入队。重复以上操作，直到队列为空。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值