【LeetCode】二叉树的广度优先遍历

最新推荐文章于 2023-09-21 22:04:09 发布
最新推荐文章于 2023-09-21 22:04:09 发布
阅读量513 收藏 1
点赞数
分类专栏： 数据结构与算法 文章标签： python c++ 算法 leetcode 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41959920/article/details/118857790
版权

前言

本文展示LeetCode中与二叉树广度优先遍历（层序遍历）的变体相关的题目，读者可以用来借此默写以检验是否熟悉相关算法，其难度为简单或中等，我们会给出最基础的层序遍历算法，然后推荐读者熟练掌握相关变体算法。

LeetCode题目

相关题目类型

相关链接

102

二叉树的层序遍历-按层输出（中等难度）

https://leetcode-cn.com/problems/binary-tree-level-order-traversal/

107

二叉树的层序遍历II-按层反转输出（中等难度）

https://leetcode-cn.com/problems/binary-tree-level-order-traversal-ii/

199

二叉树的右视图-按层输出最后一个（中等难度）

https://leetcode-cn.com/problems/binary-tree-right-side-view/

637

二叉树的层平均值-按层取均值（简单难度）

https://leetcode-cn.com/problems/average-of-levels-in-binary-tree/

429

N叉树的层序遍历-按层输出（中等难度）

https://leetcode-cn.com/problems/n-ary-tree-level-order-traversal/

515

在每个树行中找最大值-按层取最大值（中等难度）

https://leetcode-cn.com/problems/find-largest-value-in-each-tree-row/

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/

虽然上述有8道题目，但是最根本的是第一道题目，请读者在理解第一道题目的基础上做其他7道就会非常容易。

一、最简单的层序遍历

假设我们有如下二叉树：

image.png

如果希望经过层序遍历得到连续输出[3,9,20,15,7]

我们之前已经讲解过该算法的迭代实现，可以借助队列仿照先序遍历流程：

即“层序遍历同先序，借用队列先左右”，

相关Python3代码如下：

def levelOrder(self, root: TreeNode) -> List[List[int]]:
        result = []
        if not root:
            return result
        queue = [root]
        while len(queue)>0:
            cur = queue.pop(0)
            result.append(cur.val)
            if cur.left:
                queue.append(cur.left)
            if cur.right:
                queue.append(cur.right)
        return result
对应的C++代码：

vector<int> levelOrder(TreeNode* node) {
        vector<int> result;
        if (node == NULL) {
            return result;
        }
        queue<TreeNode*> queue;
        queue.push(node);
        while (!queue.empty()) {
            TreeNode* cur = queue.front();
            result.push_back(cur->val);
            queue.pop();
            if (cur->left) {
                queue.push(cur->left);
            }
            if (cur->right) {
                queue.push(cur->right);
            }
        }
        return result;
    }

二、层序遍历的变体

1、102.⼆叉树的层序遍历（按层输出）

题⽬链接：https://leetcode-cn.com/problems/binary-tree-level-order-traversal/

如果希望经过层序遍历得到按层输出：[[3],[9,20],[15,7]]

我们在上述代码中进行更改，相关Python3代码如下：

def levelOrder(self, root: TreeNode) -> List[List[int]]:
        result = []
        if not root:
            return result
        queue = [root]
        while len(queue)>0:
            length = len(queue)
            level_result = []
            for i in range(0,length):
                cur = queue.pop(0)
                level_result.append(cur.val)
                if cur.left:
                    queue.append(cur.left)
                if cur.right:
                    queue.append(cur.right)
            result.append(level_result)
        return result

我们可以执行代码来理解流程：

第一次循环时，length=1，cur = root ，queue中只有root=3，将其出队，root.val加入level_result

cur.left和cur.right都存在，加入队列，此时队列中有第二层的两个节点；

第二次循环时，length=2，cur = 9节点时 ，将其出队加入level_result，然后左右节点不存在不需要添加；

cur = 20节点时 ，将其出队加入level_result，然后左右节点存在需要添加到队列，此时队列中有第三层的两个节点；

即每次循环，第一层循环负责循环二叉树的每一层，第二层循环负责循环二叉树的每一层的节点，并将下一层节点加入队列。

这里给出C++代码：

vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> result;
        if(root==NULL){
            return result;
        }
        queue<TreeNode*> queue;
        queue.push(root);
        while(!queue.empty()){
            int size = queue.size();
            vector<int> level_result;
            for(int i=0;i<size;i++){
                TreeNode* cur=queue.front();
                queue.pop();
                level_result.push_back(cur->val);
                if (cur->left!=NULL){
                    queue.push(cur->left);
                }
                if (cur->right!=NULL){
                    queue.push(cur->right);
                }
            }
            result.push_back(level_result);
        }
        return result;
    }

2、107.⼆叉树的层序遍历（按层反转输出）

题⽬链接：https://leetcode-cn.com/problems/binary-tree-level-order-traversal-ii/

该题希望经过层序遍历得到按层反转输出：[[15,7]，[9,20],[3]]

最简单的做法就是在之前代码返回result前添加反转操作。

C++需要在“return result;”前添加如下语句：

reverse(result.begin(),result.end());

Python需要在“return result;”前添加如下语句：

result = result[::-1]

3、199.⼆叉树的右视图（按层输出最后一个）

题⽬链接：https://leetcode-cn.com/problems/binary-tree-right-side-view/

该题描述如下：

image.png

该题非常简单，在每层加入result时，只加入每层最后一个即可。

C++版本：

vector<int> rightSideView(TreeNode* root) {
        vector<int> result;
        if(root==NULL){
            return result;
        }
        queue<TreeNode*> queue;
        queue.push(root);
        while(!queue.empty()){
            int size = queue.size();
            for(int i=0;i<size;i++){
                TreeNode* cur=queue.front();
                queue.pop();
                if(i==size-1){
                    result.push_back(cur->val);
                }
                if (cur->left!=NULL){
                    queue.push(cur->left);
                }
                if (cur->right!=NULL){
                    queue.push(cur->right);
                }
            }
        }
        return result;
    }

Python版本：

def rightSideView(self, root: TreeNode) -> List[int]:
        result = []
        if not root:
            return result
        queue = [root]
        while len(queue)>0:
            length = len(queue)
            for i in range(0,length):
                cur = queue.pop(0)
                if i==length-1:
                    result.append(cur.val)
                if cur.left:
                    queue.append(cur.left)
                if cur.right:
                    queue.append(cur.right)
        return result

4、637.⼆叉树的层平均值（按层取平均值）

题⽬链接：https://leetcode-cn.com/problems/average-of-levels-in-binary-tree/

该题描述如下：

image.png

该题只要把每层的数累加起来求均值即可，注意C++要将sum定义为double，不然精度不足。

C++版本：

vector<double> averageOfLevels(TreeNode* root) {
        vector<double> result;
        if(root==NULL){
            return result;
        }
        queue<TreeNode*> queue;
        queue.push(root);
        while(!queue.empty()){
            int size = queue.size();
            double sum = 0;
            for(int i=0;i<size;i++){
                TreeNode* cur=queue.front();
                queue.pop();
                sum+=cur->val;
                if (cur->left!=NULL){
                    queue.push(cur->left);
                }
                if (cur->right!=NULL){
                    queue.push(cur->right);
                }
            }
            result.push_back(sum/size);
        }
        return result;
    }

Python版本：

def averageOfLevels(self, root: TreeNode) -> List[float]:
        result = []
        if not root:
            return result
        queue = [root]
        while len(queue)>0:
            length = len(queue)
            sum=0.0
            for i in range(0,length):
                cur = queue.pop(0)
                sum+=cur.val
                if cur.left:
                    queue.append(cur.left)
                if cur.right:
                    queue.append(cur.right)
            result.append(sum/length)
        return result

5、429.N叉树的层序遍历（按层输出）

题⽬链接：https://leetcode-cn.com/problems/n-ary-tree-level-order-traversal/

该题描述如下：

image.png

该题只要把遍历一下children数组即可。

C++版本：

vector<vector<int>> levelOrder(Node* root) {
        vector<vector<int>> result;
        if(root==NULL){
            return result;
        }
        queue<Node*> queue;
        queue.push(root);
        while(!queue.empty()){
            int size = queue.size();
            vector<int> level_result;
            for(int i=0;i<size;i++){
                Node* cur=queue.front();
                queue.pop();
                level_result.push_back(cur->val);
                for(int j=0;j<cur->children.size();j++){
                    if (cur->children[j]!=NULL){
                        queue.push(cur->children[j]);
                    }
                }
            }
            result.push_back(level_result);
        }
        return result;
    }

Python版本：

def levelOrder(self, root: 'Node') -> List[List[int]]:
        result = []
        if not root:
            return result
        queue = [root]
        while len(queue)>0:
            length = len(queue)
            level_result = []
            for i in range(0,length):
                cur = queue.pop(0)
                level_result.append(cur.val)
                for child in cur.children:
                    if child:
                        queue.append(child)
            result.append(level_result)
        return result

6、515.在每个树⾏中找最⼤值（按层输出）

题⽬链接：https://leetcode-cn.com/problems/find-largest-value-in-each-tree-row/

该题描述如下：

image.png

该题需要注意的是，取最大值，最大值的初始值要设置为整数的最小值。

在C++中为INT_MIN，在Python中为-sys.maxsize - 1。

C++版本：

vector<int> largestValues(TreeNode* root) {
        vector<int> result;
        if(root==NULL){
            return result;
        }
        queue<TreeNode*> queue;
        queue.push(root);
        while(!queue.empty()){
            int size = queue.size();
            int max = INT_MIN;
            for(int i=0;i<size;i++){
                TreeNode* cur=queue.front();
                queue.pop();
                if (max<cur->val){
                    max = cur->val;
                }
                if (cur->left!=NULL){
                    queue.push(cur->left);
                }
                if (cur->right!=NULL){
                    queue.push(cur->right);
                }
            }
            result.push_back(max);
        }
        return result;
    }

Python版本：

def largestValues(self, root: TreeNode) -> List[int]:
        result = []
        if not root:
            return result
        queue = [root]
        while len(queue)>0:
            length = len(queue)
            max=-sys.maxsize - 1
            for i in range(0,length):
                cur = queue.pop(0)
                if max<cur.val:
                    max=cur.val
                if cur.left:
                    queue.append(cur.left)
                if cur.right:
                    queue.append(cur.right)
            result.append(max)
        return result

7、116.填充每个节点的下⼀个右侧节点指针（按层输出）

题⽬链接：https://leetcode-cn.com/problems/populating-next-right-pointers-in-each-node/

该题描述如下：

image.png

该题需要注意的是理解题目，输入root，返回root，二叉树的存储结构要改变。

C++版本：

Node* connect(Node* root) {
        if(root==NULL){
            return root;
        }
        queue<Node*> queue;
        queue.push(root);
        while(!queue.empty()){
            int size = queue.size();
            vector<Node*> level_node;//记录每层的node
            for(int i=0;i<size;i++){
                Node* cur=queue.front();
                queue.pop();
                level_node.push_back(cur);
                if (cur->left!=NULL){
                    queue.push(cur->left);
                }
                if (cur->right!=NULL){
                    queue.push(cur->right);
                }
            }
            //连接next
            for(int i=0;i<size;i++){
                if (i==size-1){
                    level_node[i]->next = NULL;
                }
                else{
                    level_node[i]->next = level_node[i+1];
                }
            }
        }
        return root;
    }

Python版本：

def connect(self, root: 'Node') -> 'Node':
        if not root:
            return root
        queue = [root]
        while len(queue)>0:
            length = len(queue)
            level_node = []
            for i in range(0,length):
                cur = queue.pop(0)
                level_node.append(cur)
                if cur.left:
                    queue.append(cur.left)
                if cur.right:
                    queue.append(cur.right)
            for i in range(0,length):
                if i==length-1:
                    level_node[i].next=None
                else:
                    level_node[i].next=level_node[i+1]
        return root

8、116.填充每个节点的下⼀个右侧节点指针II（按层输出）

题⽬链接：https://leetcode-cn.com/problems/populating-next-right-pointers-in-each-node-ii/

该题描述如下：

image.png

该题需要注意的是理解题目，输入root，返回root，二叉树的存储结构要改变。

该题目本质上和上一道区别不大，可以直接使用上一道题的答案，但是这里我们给出一个改进版本。

C++版本：

Node* connect(Node* root) {
       if(root==NULL){
            return root;
        }
        queue<Node*> queue;
        queue.push(root);
        while(!queue.empty()){
            int size = queue.size();
            vector<Node*> level_node;//记录每层的node
            Node* pre;
            Node* cur;
            for(int i=0;i<size;i++){
                cur=queue.front();
                queue.pop();
                if(i!=0){
                    pre->next = cur;
                }
                pre= cur;
                if (cur->left!=NULL){
                    queue.push(cur->left);
                }
                if (cur->right!=NULL){
                    queue.push(cur->right);
                }
            }
        }
        return root; 
    }

Python版本：

def connect(self, root: 'Node') -> 'Node':
        if not root:
            return root
        queue = [root]
        while len(queue)>0:
            length = len(queue)
            pre = None
            cur = None
            for i in range(0,length):
                cur = queue.pop(0)
                if i!=0:
                    pre.next = cur
                pre = cur
                if cur.left:
                    queue.append(cur.left)
                if cur.right:
                    queue.append(cur.right)
        return root

魔法攻城狮MRL
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【华为OD机试】二叉树的广度优先遍历（二叉树的构建和层次遍历—Java&Python&C++&JS实现）
一键难忘的博客
02-25 3145
【华为OD机试】二叉树的广度优先遍历（二叉树的构建和层次遍历—Java&Python&C++&JS实现） 有一棵二叉树，每个节点由一个大写字母标识(最多26个节点）。现有两组字母，分别表示后序遍历（左孩子->右孩子->父节点）和中序遍历（左孩子->父节点->右孩子）的结果，请输出层次遍历的结果。 输入描述： 输入为两个字符串，分别是二叉树的后续遍历和中序遍历结果。 输出描述： 输出二叉树的层次遍历结果。
数据结构—二叉树广度优先遍历
mcsdnuser的博客
06-25 6101
如果说深度遍历是在一个方向上“一头扎到底”，那么广度遍历则恰恰相反，现在各个方向上走出第1步，再在各个方向上走出第2步，第3步…一直在各个方向上全部走完。学习二叉树层序遍历时，第一次发现数据结构还是挺有意思的，选用不同的数据结构，对完成数据操作的难易程度和效率都有很大影响，根据不同业务场景，选择合适的数据结构，至关重要。 ...
二叉树(一)：深度优先遍历与广度优先遍历
Mike_honor的博客
07-17 2485
二叉树是一种非常高效的数据结构，树结构可以高效地查找和搜索语义，比如近邻算法中就用到了树来存储训练数据，大大提高了近邻搜索的效率，又比如电脑的文件管理器，都采用了树结构，通过树查找会变得十分快捷。总之，二叉树这种数据结构的应用非常广泛，能够大大提高搜索效率，本文将全面讲解二叉树结构以及二叉树的相关算法，相信会对大家数据结构与算法的学习产生很大的帮助。...............
二叉树的广度优先遍历
拯救世界的光太郎
12-04 2193
二叉树的广度优先遍历：从根节点开始，一层一层遍历二叉树，自左向右地打印每一个节点 思路： 先创建一个数组，用数组模拟队列。压入根节点，然后开始遍历： 从数组头弹出一个元素，然后看数组 let arr = []; function getRes(node){ if(node){ console.log( node.val ); arr.push(node); } while(arr.length > 0){ let.
[刷题笔记] 二叉树的广度优先遍历 (递归法迭代法) 和 深度优先遍历
weixin_44797288的博客
09-14 233
本文参考二叉树章节。
二叉树遍历(深度优先+广度优先)
Dablelv 的博客专栏。
05-22 8515
二叉树的遍历分为两类，一类是深度优先遍历，一类是广度优先遍历。
windhuiyi#leetcode#02-二叉树-广度遍历层序遍历1
07-25
public void helper(TreeNode root, int level){// 当前层没有 list，新建// 取得当前层的 list迭代pub
最大公共字符串leetcode-Binary-Tree:Swift中的二叉树
07-01
能够使用广度优先遍历来打印二叉树的值。 能够使用深度优先顺序遍历来打印二叉树的值。 能够使用深度优先预序遍历来打印二叉树的值。 能够使用深度优先后序遍历来打印二叉树的值。 能够确定二叉树的高度或最大深度。...
leetcode
03-21
147对链表进行插入排序去做148排序链表归并排序（TODO）回溯算法序号译文思路17电话号码的字母组合回溯之组合问题46全分...广度优先遍历序号译文思路102二叉树层序遍历107二叉树层序遍历II 199二叉树的右视图层序遍历...
LeetCode解题总结
10-09
9. 广度优先搜索 9.1 单词变换路径（Word Ladder） 9.1.1 是否存在变换路径 9.1.2 所有最短变换路径9.2 包围区域 10. 深度优先搜索 10.1 N皇后问题 10.2 恢复IP地址 10.3 集合元素之和 10.3.1 元素可以重复 10.3.2 ...
leetcode中DFS与BFS算法在数组和字符串中的应用
12-20
DFS（深度优先遍历）与BFS（广度优先遍历）算法是基于树和图结构进行遍历的两种算法。 一般来说DFS在前中后遍历中运用比较明显，DFS的运用基本是要利用递归进行嵌套使用。回溯算法其实也是一种比较经典的DFS算法升级...
算法套路九——二叉树广度优先遍历（层序遍历）
Pistachiout的学习博客
04-13 1240
二叉树广度优先层序遍历，采用双数组或队列
【算法】二叉树广度优先(BFS)
个人学习笔记
08-27 1061
二叉树广度优先(BFS)
Python数据结构与算法篇（十五）-- 二叉树的遍历：深度优先搜索与广度优先搜索
CarpeDiem
05-24 3091
本篇带你走进二叉树，使用深度优先搜索和广度优先搜索思想进行二叉树的顺序遍历和层序遍历，带你刷遍LeetCode上的二叉树遍历题目。
广度优先搜索遍历二叉树
一觉睡过头的菜鸡的博客
05-24 478
1.前言 当我们在需要遍历一颗二叉树时，我们可以使用广度优先搜索算法（BFS）进行实现，广度优先算法会一层一层的遍历二叉树，从根节点向下一层一层的访问，直到没有节点为止。 2. Queue 在Java中，我们一般使用队列(Queue)进行广度优先搜索的实现。 Queue中的主要方法： add()或offer()加入数据 poll()从队列中删除第一个元素 peek()用于在队列的头部查询元素，只得到但不会删除这个元素， isEmpty()判断当前队列是非为空。 3. 实现思路 创建队列后先将根结点入队，
【数据结构】二叉树的·深度优先遍历（前中后序遍历）and·广度优先（层序遍历）
最新发布
luhaoran814的博客
09-21 2129
二叉树的·深度优先遍历（前中后序遍历）and·广度优先（层序遍历）
深度优先遍历和广度优先遍历二叉树的实现方法
小白
04-01 415
二叉树是一种非常重要的数据结构，在计算机科学中得到广泛的应用。二叉树是一种树形结构，其中每个节点最多有两个子节点，分别称为左子节点和右子节点。在这篇文章中，我们将探讨二叉树的广度优先遍历和深度优先遍历。
二叉树广度优先遍历（层次遍历）
xuebaobao130526的博客
03-11 1784
宽度优先遍历，广度度优先遍历，层次遍历。 即从根节点开始依次遍历左子节点和右子节点，直到所有子节点都变遍历完为止。 遍历结果：{1,2,3,4,5,6,7,8,9,10 } leetcode练习： 思路： 将树上顶点按照层次依次放入队列结构中，队列中元素满足 FIFO（先进先出）的原则。 初始化队列只包含一个节点 root 和层次编号 0 ： level = 0。 当队列非空的...
二叉树遍历——深度优先遍历、广度优先遍历
热门推荐
雾幻的博客
10-23 2万+
二叉树遍历简介 深度优先遍历： 对每一个可能的分支路径深入到不能再深入为止，而且每个结点只能访问一次。对每一个可能的分支路径深入到不能再深入为止，而且每个结点只能访问一次。 要特别注意的是，二叉树的深度优先遍历比较特殊，可以细分为先序遍历、中序遍历、后序遍历。具体说明如下： 先序遍历：对任一子树，先访问根，然后遍历其左子树，最后遍历其右子树。 中序遍历：对任一子树，先遍历其左子树，然后访问根，...
leetcode 二叉树
09-16
在LeetCode上，二叉树问题是常见的算法题型，我们需要实现各种操作，如合并树、找出深度、遍历等。 在引用中，给出了一个合并二叉树的解法。该解法使用递归的方式将两棵二叉树合并为一棵新的二叉树。首先判断两棵树...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

魔法攻城狮MRL

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值