目录
一、102.二叉树的层序遍历
1.题目描述
给你二叉树的根节点 root
,返回其节点值的 层序遍历 。 (即逐层地,从左到右访问所有节点)。
示例 1:
输入:root = [3,9,20,null,null,15,7] 输出:[[3],[9,20],[15,7]]
示例 2:
输入:root = [1] 输出:[[1]]
示例 3:
输入:root = [] 输出:[]
2.解题思路
利用队列先进先出的特性,完成层序遍历。
- 定义二维数组result用来存放结果,其中每一个一维数组代表一层的节点值
- 先判断题目所给根节点是否为空。不为空,则将其添加到队列que中
- 开始进入while循环,循环结束条件:队列中为空(这也意味着没有新的左右孩子节点添加进来了)
- 先记录当前层的节点个数,每次只pop当前层的所有节点:int size = que.size()
- 将遍历的本层节点值添加到一维数组vec中,然后将它左右孩子push到队列中(如果左右孩子存在)
3.代码实现
/**
* 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>> levelOrder(TreeNode* root) {
vector<vector<int>> result;//二维数组--结果集
queue<TreeNode*> que;//利用队列先进先出的特性完成层序遍历
if(root != NULL) que.push(root);//先判断root不为空,才添加进去
while(!que.empty()){//只要队列不为空,就继续循环
//先记录当前层有多少节点
int size = que.size();
vector<int> vec;//一维数组,记录当前层的所有节点
//只弹出当前层的节点数量
for(int i = 0;i < size;i++){
TreeNode* node = que.front();
que.pop();
vec.push_back(node->val);
//然后将这个节点的左右孩子push进去
if(node->left != NULL) que.push(node->left);
if(node->right != NULL) que.push(node->right);
}
//将当前层的节点值保存到result结果集中
result.push_back(vec);
}
return result;
}
};
二、107. 二叉树的层序遍历 II
1.题目描述
给你二叉树的根节点 root
,返回其节点值 自底向上的层序遍历 。 (即按从叶子节点所在层到根节点所在的层,逐层从左向右遍历)
示例 1:
输入:root = [3,9,20,null,null,15,7] 输出:[[15,7],[9,20],[3]]
示例 2:
输入:root = [1] 输出:[[1]]
示例 3:
输入:root = [] 输出:[]
2.解题思路
本题和LeetCode上102.二叉树的层序遍历几乎一模一样,只不过这里要求最后返回的结果是从最后一层到顶层。也就是将102那题的result结果提reverse一下即可。
3.代码实现
/**
* 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;//二维数组result结果集
//利用队列实现层序遍历
queue<TreeNode*> que;
if(root != NULL) que.push(root);
while(!que.empty()){//队列不为空就继续
vector<int> vec;//记录单层的节点值
int size = que.size();//记录当前层有多少个节点
for(int i = 0;i < size;i++){
TreeNode* node = que.front();
que.pop();
vec.push_back(node->val);
if(node->left != NULL) que.push(node->left);
if(node->right != NULL) que.push(node->right);
}
//将当前层遍历的节点值保存到二维数组中
result.push_back(vec);
}
//题目要求先输出最底层的节点值
reverse(result.begin(),result.end());
return result;
}
};
三、199.二叉树的右视图
1.题目描述
给定一个二叉树的 根节点 root
,想象自己站在它的右侧,按照从顶部到底部的顺序,返回从右侧所能看到的节点值。
示例 1:
输入: [1,2,3,null,5,null,4] 输出: [1,3,4]
示例 2:
输入: [1,null,3] 输出: [1,3]
示例 3:
输入: [] 输出: []
2.解题思路
题目要求我们从最右侧能看到的节点值,也就是要我们保存每层最后一个节点值。
- 层序遍历的时候,当i == size - 1的时候,说明遇到了当前层的最后一个节点,保存到result结果集中。
3.代码实现
/**
* 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<int> rightSideView(TreeNode* root) {
//利用队列的特性完成层序遍历
queue<TreeNode*> que;
vector<int> result;//题目要求返回每层最右侧的节点值,一维数组即可
//开始对题目所给的根节点进行判断,非空则入队
if(root != NULL) que.push(root);
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);//每层的最右边一个节点就是我们要的节点值
if(node->left != NULL) que.push(node->left);
if(node->right != NULL) que.push(node->right);
}
}
return result;
}
};
四、637. 二叉树的层平均值
1.题目描述
给定一个非空二叉树的根节点 root
, 以数组的形式返回每一层节点的平均值。与实际答案相差 10-5
以内的答案可以被接受。
示例 1:
输入:root = [3,9,20,null,null,15,7] 输出:[3.00000,14.50000,11.00000] 解释:第 0 层的平均值为 3,第 1 层的平均值为 14.5,第 2 层的平均值为 11 。 因此返回 [3, 14.5, 11] 。
示例 2:
输入:root = [3,9,20,15,7] 输出:[3.00000,14.50000,11.00000]
2.解题思路
层序遍历的时候,定义一个浮点型变量保存当前层的节点值总和,然后将平均值push到结果集即可。
3.代码实现
/**
* 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<double> averageOfLevels(TreeNode* root) {
//层序遍历的时候,定义一个浮点型变量sum计算当前层的节点值和
queue<TreeNode*> que;
vector<double> result;
//题目已经告诉root非空,直接入队就行
que.push(root);
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 != NULL) que.push(node->left);
if(node->right != NULL) que.push(node->right);
}
//将当前层的总和平均值保存到数组里
result.push_back(sum / size);
}
return result;
}
};
五、429. N 叉树的层序遍历
1.题目描述
给定一个 N 叉树,返回其节点值的层序遍历。(即从左到右,逐层遍历)。
树的序列化输入是用层序遍历,每组子节点都由 null 值分隔(参见示例)。
示例 1:
输入:root = [1,null,3,2,4,null,5,6] 输出:[[1],[3,2,4],[5,6]]
示例 2:
输入:root = [1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,null,13,null,null,14] 输出:[[1],[2,3,4,5],[6,7,8,9,10],[11,12,13],[14]]
2.解题思路
和二叉树的层序遍历大同小异。只不过这里pop一个节点出去时,要多push几个孩子节点进来
3.代码实现
/*
// 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) {
//和二叉树的层序遍历大同小异。只不过这里pop一个节点出去时,要多push几个孩子节点进来
queue<Node*> que;
vector<vector<int>> result;//二维数组结果集
//根节点入队,先判断非空
if(root != NULL) que.push(root);
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);
//开始将node节点的所有孩子节点入队
for(int j = 0;j < node->children.size();j++){
if(node->children[j] != NULL) que.push(node->children[j]);
}
}
//将单层的一维数组保存到二维结果集中
result.push_back(vec);
}
return result;
}
};
六、515. 在每个树行中找最大值
1.题目描述
给定一棵二叉树的根节点 root
,请找出该二叉树中每一层的最大值。
示例1:
输入: root = [1,3,2,5,3,null,9] 输出: [1,3,9]
示例2:
输入: root = [1,2,3] 输出: [1,3]
提示:
- 二叉树的节点个数的范围是
[0,104]
-231 <= Node.val <= 231 - 1
2.解题思路
层序遍历的时候,定义一个整型变量max保存最大节点值。
3.代码实现
/**
* 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<int> largestValues(TreeNode* root) {
vector<int> result;
queue<TreeNode*> que;
//根节点入队,先判断非空
if(root != NULL) que.push(root);
while(!que.empty()){
int size = que.size();
int max = INT_MIN;
for(int i = 0;i < size;i++){
TreeNode* node = que.front();
que.pop();
max = node->val > max ? node->val : max;//保存最大值
if(node->left != NULL) que.push(node->left);
if(node->right != NULL) que.push(node->right);
}
//将最大值保存到结果集
result.push_back(max);
}
return result;
}
};