二叉树 | 5 层序遍历（广度优先遍历 共10题）

已于 2023-06-05 14:02:44 修改
阅读量498 收藏
点赞数
分类专栏： 力扣刷题集 文章标签： 宽度优先 leetcode 算法
于 2023-04-16 22:09:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48315360/article/details/130188468
版权

本文记录的是刷题过程中的重要概念和笔记。如有侵权，请联系删除。

目录

102.二叉树的层序遍历

力扣题目链接(opens new window) https://leetcode.cn/problems/binary-tree-level-order-traversal/submissions/

给你一个二叉树，请你返回其按 层序遍历 得到的节点值。 （即逐层地，从左到右访问所有节点）。

队列法

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        queue<TreeNode*> que;
        if (root != NULL) que.push(root);
        vector<vector<int>> result;
        while (!que.empty()) {
            int size = que.size();
            vector<int> vec;
            // 这里一定要使用固定大小size，不要使用que.size()，因为que.size是不断变化的
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                vec.push_back(node->val);
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
            result.push_back(vec);
        }
        return result;
    }
};

递归法

# 递归法
class Solution {
public:
    void order(TreeNode* cur, vector<vector<int>>& result, int depth)
    {
        if (cur == nullptr) return;
        if (result.size() == depth) result.push_back(vector<int>());
        result[depth].push_back(cur->val);
        order(cur->left, result, depth + 1);
        order(cur->right, result, depth + 1);
    }
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> result;
        int depth = 0;
        order(root, result, depth);
        return result;
    }
};

107.二叉树的层次遍历 II

力扣题目链接(opens new window) https://leetcode.cn/problems/binary-tree-level-order-traversal-ii/

给你二叉树的根节点 root ，返回其节点值 自底向上的层序遍历 。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：[[15,7],[9,20],[3]]
示例 2：

输入：root = [1]
输出：[[1]]
示例 3：

输入：root = []
输出：[]

提示：

树中节点数目在范围 [0, 2000] 内
-1000 <= Node.val <= 1000

思路

相对于102.二叉树的层序遍历，就是最后把result数组反转一下就可以了。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> levelOrderBottom(TreeNode* root) {
        vector<vector<int>> result;
        if(!root) return result;
        queue<TreeNode*> que;
        que.push(root);
        while(!que.empty()){
            int size = que.size();
            vector<int> vec(size);
            for(int i=0;i<size;i++){
                TreeNode* node = que.front();
                vec[i]=que.front()->val;
                que.pop();
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
            result.push_back(vec);
        }
        reverse(result.begin(),result.end());
        return result;
    }
};

199.二叉树的右视图

力扣题目链接(opens new window) https://leetcode.cn/problems/binary-tree-right-side-view/

给定一棵二叉树，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。

199.二叉树的右视图

思路

判断是否遍历到单层的最后面的元素，如果是，就放进result数组中，随后返回result就可以了。

lass Solution {
public:
    vector<int> rightSideView(TreeNode* root) {
        queue<TreeNode*> que;
        if (root != NULL) que.push(root);
        vector<int> result;
        while (!que.empty()) {
            int size = que.size();
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                if (i == (size - 1)) result.push_back(node->val); // 将每一层的最后元素放入result数组中
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
        }
        return result;
    }
};

直接增加判断语句。

637.二叉树的层平均值

力扣题目链接(opens new window) https://leetcode.cn/problems/average-of-levels-in-binary-tree/

给定一个非空二叉树, 返回一个由每层节点平均值组成的数组。

637.二叉树的层平均值

思路

算均值即可。

class Solution {
public:
    vector<double> averageOfLevels(TreeNode* root) {
        queue<TreeNode*> que;
        if (root != NULL) que.push(root);
        vector<double> result;
        while (!que.empty()) {
            int size = que.size();
            double sum = 0; // 统计每一层的和
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                sum += node->val;
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
            result.push_back(sum / size); // 将每一层均值放进结果集
        }
        return result;
    }
};

429.N叉树的层序遍历

力扣题目链接(opens new window)
https://leetcode.cn/problems/n-ary-tree-level-order-traversal/
给定一个 N 叉树，返回其节点值的层序遍历。 (即从左到右，逐层遍历)。

例如，给定一个 3叉树 :

429. N叉树的层序遍历

返回其层序遍历:

[ [1], [3,2,4], [5,6] ]

思路

多个子节点

/*
// Definition for a Node.
class Node {
public:
    int val;
    vector<Node*> children;

    Node() {}

    Node(int _val) {
        val = _val;
    }

    Node(int _val, vector<Node*> _children) {
        val = _val;
        children = _children;
    }
};
*/

class Solution {
public:
    vector<vector<int>> levelOrder(Node* root) {
        queue<Node*> que;
        if (root != NULL) que.push(root);
        vector<vector<int>> result;
        while (!que.empty()) {
            int size = que.size();
            vector<int> vec;
            for (int i = 0; i < size; i++) {
                Node* node = que.front();
                que.pop();
                vec.push_back(node->val);
                // auto 或者 Node* 都可以
                for(auto child:node->children){
                	// 默认不为空，所以可以直接加入，否则还要判断一下。
                    que.push(child);
                }               
            }
            result.push_back(vec);
        }
        return result;
    }
};

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

力扣题目链接(opens new window)
https://leetcode.cn/problems/find-largest-value-in-each-tree-row/

您需要在二叉树的每一行中找到最大的值。

思路

class Solution {
public:
    vector<int> largestValues(TreeNode* root) {
        queue<TreeNode*> que;
        if (root != NULL) que.push(root);
        vector<int> result;
        while (!que.empty()) {
            int size = que.size();
            int maxValue = INT_MIN; // 取每一层的最大值
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                maxValue = node->val > maxValue ? node->val : maxValue;
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
            result.push_back(maxValue); // 把最大值放进数组
        }
        return result;
    }
};

补充：INT_MIN与INT_MAX

INT_MIN与INT_MAX
在标准头文件limits.h中定义.

C语言中int的取值范围为：-2147483648 ~ 2147483647

解释如下：
int类型在C语言中占4个字节，即32个二进制位。
当表示正数时，最高位为符号位（符号位为0），最大的正数是 0111 1111 1111 1111 1111 1111 1111 1111 即2^31 -1 = 2147483647

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

力扣题目链接(opens new window)

给定一个完美二叉树，其所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树定义如下：

struct Node {
  int val;
  Node *left;
  Node *right;
  Node *next;
}

填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。

初始状态下，所有 next 指针都被设置为 NULL。在这里插入图片描述

思路

class Solution {
public:
    Node* connect(Node* root) {
        queue<Node*> que;
        if (root != NULL) que.push(root);
        while (!que.empty()) {
            int size = que.size();
            // vector<int> vec;
            Node* nodePre;
            Node* node;
            for (int i = 0; i < size; i++) {
                if (i == 0) {
                    nodePre = que.front(); // 取出一层的头结点
                    que.pop();
                    node = nodePre;
                } else {
                    node = que.front();
                    que.pop();
                    nodePre->next = node; // 本层前一个节点next指向本节点
                    nodePre = nodePre->next;
                }
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
            nodePre->next = NULL; // 本层最后一个节点指向NULL,可以不改，本来就是NULL
        }
        return root;

    }
};

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

力扣题目链接(opens new window)
https://leetcode.cn/problems/populating-next-right-pointers-in-each-node-ii/

思路

这道题目说是二叉树，但116题目说是完整二叉树，其实没有任何差别。

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* left;
    Node* right;
    Node* next;

    Node() : val(0), left(NULL), right(NULL), next(NULL) {}

    Node(int _val) : val(_val), left(NULL), right(NULL), next(NULL) {}

    Node(int _val, Node* _left, Node* _right, Node* _next)
        : val(_val), left(_left), right(_right), next(_next) {}
};
*/

class Solution {
public:
    Node* connect(Node* root) {
        if(!root) return root;
        queue<Node*> que;
        que.push(root);
        while(!que.empty()){
            int size = que.size();
            Node* cur, * pre;
            for(int i=0;i<size;i++){
                if(i==0){
                    pre = que.front();
                    que.pop();
                    cur = pre;
                }else{
                    cur = que.front();
                    que.pop();
                    pre->next = cur;
                    pre = cur;
                }
                if(cur->left) que.push(cur->left);
                if(cur->right) que.push(cur->right);
            }
            
        }
        return root;
    }
};
  • pre = que.front();
    que.pop();
    不可写成 pre = que.pop();
  • Node* cur, * pre; 注意后面 的 *

104.二叉树的最大深度

力扣题目链接(opens new window) https://leetcode.cn/problems/maximum-depth-of-binary-tree/

给定一个二叉树，找出其最大深度。

二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。

说明: 叶子节点是指没有子节点的节点。

思路

class Solution {
public:
    int maxDepth(TreeNode* root) {
        if (root == NULL) return 0;
        int depth = 0;
        queue<TreeNode*> que;
        que.push(root);
        while(!que.empty()) {
            int size = que.size();
            depth++; // 记录深度
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
        }
        return depth;
    }
};

111.二叉树的最小深度

力扣题目链接(opens new window)
https://leetcode.cn/problems/minimum-depth-of-binary-tree/
相对于 104.二叉树的最大深度 ，本题还也可以使用层序遍历的方式来解决，思路是一样的。
在这里插入图片描述

思路

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

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int minDepth(TreeNode* root) {
        if(!root) return 0;
        queue<TreeNode*> que;
        que.push(root);
        int depth = 0;
        while(!que.empty()){
            int size = que.size();
            depth++;
            for(int i=0;i<size;i++){
                TreeNode* node = que.front();
                que.pop();
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
                if(!node->left && !node->right) return depth;
            }
        }
        return depth;
    }
};
CLong005
关注
专栏目录
华为OD机试-二叉树的广度优先遍历（Java/Python/C++）
shen198899的博客
05-05 565
华为OD机试-二叉树的广度优先遍历-华为OD机试-二叉树的广度优先遍历：有一棵，每个节点由一个大写字母标识(最多26个节点）。现有两组字母，分别表示后序遍历（左孩子->右孩子->父节点）和中序遍历（左孩子->父节点->右孩子）的结果，请你输出层序遍历的结果。
二叉树的层序遍历(js)
weixin_45805570的博客
08-06 829
除了先序、中序、后序三种遍历外，还有一个层序遍历，所谓层序遍历就是按照每一层的顺序遍历整棵树（也就是说一层一层，从左往右遍历下来） 迭代法 层序遍历采用配合队列的方式来实现，其原因是它是从左往右遍历的，所以队列这种数据结构非常适合它。 var levelOrder = function(root) { if (!root) { return []; } var res = [];
二叉树的广度优先遍历（BFS）例题——二叉树打印
weixin_45895370的博客
02-05 996
题目描述 从上到下打印出二叉树的每个节点，同一层的节点按照从左到右的顺序打印。 算法思路 是一个典型的二叉树广度优先遍历的例子。广度优先经常利用队列的先进先出实现的。 特例处理：当树的根结点为空时，直接返回空列表。 建立一个队列，用于遍历每个父节点。遍历了这个父节点的左节点和右节点之后出队列。 class Solution { public: vector<int> levelOrder(TreeNode* root) { queue<TreeNode*> Q
数据结构 — 5.二叉树层次遍历
PeersLee的博客
10-28 974
【问题描述】编写按层次顺序(同一层自左至右)遍历二叉树的算法. 【输入形式】A B * C * * D * *  ( 按照先序输入二叉树中结点的值、字符在输入中没有空格 ) 【输出形式】A B D C #include #include #include using namespace std; typedef struct BiTNode{ char data; B
二叉树的遍历（前、中、后、层）
hi_siri的博客
11-17 374
二叉树的遍历二叉树代码前序遍历中序遍历后序遍历层序遍历推算遍历结果（知二求一） 二叉树代码 先展示二叉树的代码，此处的二叉树实现通过前序遍历加上补空的字符串来实现二叉树，具体代码如下： public class Tree { TreeNode root=null; class TreeNode<T>{//自定义二叉树结点类 T value; TreeNode left; TreeNode right; TreeNo
每日一题算法题-----二叉树的深度优先遍历和广度优先遍历
码农小姐姐的博客
06-17 519
思路：利用队列和双层list来进行广度优先遍历，首先 将 3 节点加入到队列中，弹出，再将3的子节点 9 20 加入队列，弹出，再将9 20 的子节点加入队列，弹出~，就是酱紫 /** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode() {} * TreeNode(
【LeetCode】二叉树的广度优先遍历
qq_41959920的博客
07-17 591
前言 本文展示LeetCode中与二叉树广度优先遍历（层序遍历）的变体相关的题目，读者可以用来借此默写以检验是否熟悉相关算法，其难度为简单或中等，我们会给出最基础的层序遍历算法，然后推荐读者熟练掌握相关变体算法。 LeetCode题目 相关题目类型 相关链接 102 二叉树的层序遍历-按层输出（中等难度） https://leetcode-cn.com/problems/binary-tr
二叉树的遍历(深度优先/广度优先 递归/非递归 层序遍历)详解
bitkevin的博客
09-12 1497
目录 1.简介 2.二叉树的深度优先遍历 2.1 二叉树的前序遍历 2.2 二叉树的中序遍历 2.3 二叉树的后序遍历 3. 二叉树的广度优先搜索 3.1 二叉树广度优先搜索 3.2 二叉树的层序遍历 3.3 二叉树自底向上层序遍历 3.4 二叉树的锯齿形层序遍历 二叉树是一种很常用的基本数据结构，它可以看做一种特殊的图(一个节点只有一个入度和最多两个出度)，因此二叉树的的遍历要比图简单很多，学好二叉树也能较容易掌握图的遍历。 1.简介 我们...
【二叉树】- 层序遍历（ js 实现）
yan的秘密基地
08-07 1490
层序遍历一个二叉树。就是从左到右一层一层的去遍历二叉树。 这种遍历的方式和我们之前学习的都不太一样。 需要借用一个辅助数据结构即队列来实现，队列先进先出，符合一层一层遍历的逻辑，而用栈先进后出适合模拟深度优先遍历也就是递归的逻辑。 而这种层序遍历方式就是图论中的广度优先遍历，只不过我们应用在二叉树上。 使用队列实现二叉树广度优先遍历...
C++二叉树的层序遍历（广度优先搜索）借助 队列 实现
bulangman277的博客
12-13 1027
这篇博客是关于二叉树的层序遍历详解，但是不涉及二叉树的基本定义及原理。 通过队列实现二叉树的层序遍历的各类题型，总结出来二叉树层序遍历的模板C++代码。个人认为非常有价值
记录关于二叉树中的广度优先搜索（遍历）方法及相关算法题目
weixin_43679674的博客
02-11 753
关于二叉树按广度优先搜索需要使用一个辅助队列数据结构来存储树的每层节点信息，主要原因是队列具有first in first out 性质，及符合一层层遍历树的逻辑，而栈结构具有first in last out即符合深度优先搜索策略。 按广度优先搜索策略遍历二叉树代码： class Solution{ public: vector<vector<int> > levelOrder(TreeNode* root){ queue<TreeNode*> que; ...
C/C++：二叉树的各种遍历（前序，中序，后序，层次）（一）
Charles_ke的博客
11-23 6478
所谓的二叉树是指树中所有节点的子节点个数都不超过2的树。对于二叉树，有深度遍历和广度遍历，深度遍历有前序、中序以及后序三种遍历方法，广度遍历即我们平常所说的层次遍历。 前序遍历首先访问根结点然后遍历左子树，最后遍历右子树。在遍历左、右子树时，仍然先访问根结点，然后遍历左子树，最后遍历右子树。 若二叉树为空则结束返回，否则： （1）访问根结点。 （2）前序遍历左子树。 （3）前序遍历右子树
广度优先遍历（BFS）例题
大草的博客
10-17 6901
二叉树的层次遍历     UVa122 题目：   转载：树的层次遍历，紫书P150UVa122 一、输入数据的处理： 此处两次用到的c语言字符串的灵活性——可以把任何指向字符的指针看成一个字符串，从该位置开始直到‘\0’结束的字符串。例如，若读到的字符串节点是“（11，LL）”,则‘&amp;s[1]’代表的含义是字符串“11，LL）”。函数strchr（s,’,’）返回字...
【算法百题之十】二叉树的广度优先遍历
Lampard的博客
10-25 278
【算法百题之十】二叉树的广度优先遍历 大家好，我是Lampard~~ 很高兴又能和大家见面了，接下来准备系列更新的是算法题，一日一练，早日升仙！ 今天的问题是： 实现二叉树的广度优先遍历。 我的思路： 首先要弄清楚什么是广度优先遍历。 我们...
二叉树的广度优先搜索（BFS）和例题
qq_45066013的博客
03-30 839
二叉树广度优先搜索（BFS） 二叉树广度优先搜索意味着对节点的遍历是一层一层的，一层访问完才访问下一层。那么就是说从上往下访问时，父节点总是比子节点先访问。于是可以采用队列，队列的特征就是先进先出，于是可以按父子关系依次入队出队。 想象一下：对于一颗二叉树: ​ a ​ b c d e f 按父节点先入队，子节点后入队时有： a入队，队列：a 检测a的左右孩子，让其入队，同时由于a被访问，a出队，队列：b c 同上，访问b，同时让b的孩子入队
二叉树遍历——深度优先遍历、广度优先遍历
雾幻的博客
10-23 2万+
二叉树遍历简介 深度优先遍历： 对每一个可能的分支路径深入到不能再深入为止，而且每个结点只能访问一次。对每一个可能的分支路径深入到不能再深入为止，而且每个结点只能访问一次。 要特别注意的是，二叉树的深度优先遍历比较特殊，可以细分为先序遍历、中序遍历、后序遍历。具体说明如下： 先序遍历：对任一子树，先访问根，然后遍历其左子树，最后遍历其右子树。 中序遍历：对任一子树，先遍历其左子树，然后访问根，...
图的遍历——深度优先搜索和广度（宽度）优先搜索（含例题）
热门推荐
黑色吊椅的博客
02-01 3万+
专栏导读及目录https://blog.csdn.net/createprogram/article/details/86741044 深度优先搜索 DFS基本思想 基本步骤： 1.从图中某个顶点v0出发，首先访问v0;   2.访问结点v0的第一个邻接点，以这个邻接点vt作为一个新节点，访问vt所有邻接点。直到以vt出发的所有节点都被访问到，回溯到v0的下一个未被访问过的邻接点，以这个...
广度优先遍历二叉树(从上到下遍历二叉树)
吾尝终日而思矣，不如须臾之所学也
06-15 1111
问题描述：从上到下打印出二叉树的每个结点，同一层的结点按照从左到右的顺序打印。例如下图中的二叉树 ，则依次打印出8,6,10,5,7,9,11思路分析：按层打印的顺序决定了应该先打印根节点，所以我们从树的根节点开始分析，为了接下来能够打印值为8的结点的两个子结点，我们应该在遍历到该结点时把值为6和10的两个结点保存到一个容器里，现在容器内就有两个结点了。按照从左到右的打印，我们先取出值为6的结点，打
二叉树的深度优先遍历(DFS)和广度优先遍历(BFS)
best_od的博客
01-11 2万+
二叉树的深度优先遍历(DFS)和广度优先遍历(BFS) 从leetcode的一道题目说起 二叉树的层次遍历 题目链接添加链接描述 给定一个二叉树，返回其按层次遍历的节点值。 （即逐层地，从左到右访问所有节点）。 例如: 给定二叉树: [3,9,20,null,null,15,7], 返回其层次遍历结果： [ [3], [9,20], [15,7] ] 这个题目明显就是广度遍历二叉树，并将树的每一...
二叉树锯齿形层序遍历算法实现
二叉树的锯齿形层序遍历是一种特殊的二叉树遍历方法，它结合了层次遍历（广度优先搜索）和交替左右节点的顺序。在层次遍历的基础上，每一层的节点按照从左到右，然后从右到左的顺序交替进行。这种遍历方式在处理...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值