目录
前言
本文总结了通过广度优先遍历实现二叉树的相关问题。
一、二叉树的遍历
1.1 二叉树的层序遍历I
题目描述：给定二叉树的根节点 root ，返回其节点值的层序遍历 ，即逐层地从左到右访问所有节点。
题目分析：二叉树的层序遍历要求逐层访问节点，该过程可借助队列来实现。该队列保存每一层的节点值，队列的长度为该层的节点数。当在队列中遍历该层节点时时，将节点的下一层入队列。算法流程如下：
1、根节点入队；
2、while(队列不为空){
计算队列长度n；
定义新的节点node;
for(int i=0;i<n;i++){
从队列中取出节点；
处理该节点；
将该节点的左右孩子入队；
}
}
其实现代码如下：
/**
* 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) {
if(root==nullptr)
return {}; //如果根节点不存在，返回空值
vector<vector<int>> res; //定义结果向量
queue<TreeNode*> que; //定义队列
que.push(root); //根节点入队
while(!que.empty()){ //当队列不为空，即该层有节点时
int n=que.size(); //计算该层节点数
TreeNode* node; //定义节点，作为队列中树节点与整型向量之间的桥梁
vector<int> tmp; //定义整型向量，用来存储该层所有节点的值
for(int i=0;i<n;i++){
node=que.front(); //取出节点
que.pop();
tmp.push_back(node->val); //将节点值放入向量中
if(node->left) que.push(node->left); //如果该节点存在左孩子，则将它的左孩子入队
if(node->right) que.push(node->right); //如果该节点存在右孩子，则将它的右孩子入队
}
res.push_back(tmp); //将每层的节点值加入最终的结果向量中
}
return res;
}
};
1.2 二叉树的层序遍历II
题目描述：给定二叉树的根节点root ，返回其节点值自底向上的层序遍历 ，即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历。
题目分析：该题与上一题的不同之处在于返回值是自低向上的遍历，而上一题的返回值是自顶向下的遍历。因此，在上一题的基础上对返回值进行反转，或者将每一层的遍历结果进行头插即可。
/**
* 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) {
if(root==nullptr)
return {};
vector<vector<int>> res;
queue<TreeNode*> que;
que.push(root);
while(!que.empty()){
int n=que.size();
vector<int> tmp;
TreeNode* node;
for(int i=0;i<n;i++){
node=que.front();
que.pop();
tmp.push_back(node->val);
if(node->left) que.push(node->left);
if(node->right) que.push(node->right);
}
res.push_back(tmp);
}
reverse(res.begin(),res.end()); //向量反转
//res.insert(res.begin(),tmp); //向量头插
return res;
}
};
1.3 二叉树的层平均值
题目描述：给定一个非空二叉树的根节点root , 以数组的形式返回每一层节点的平均值。与实际答案相差10^(-5)以内的答案可以被接受。
/**
* 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) {
if(root==nullptr)
return {};
vector<double> res;
queue<TreeNode*> que;
que.push(root);
while(!que.empty()){
int n=que.size();
TreeNode* node;
double levSum=0; //该值为每层节点值的和
for(int i=0;i<n;i++){
node=que.front();
que.pop();
levSum+=node->val;
if(node->left) que.push(node->left);
if(node->right) que.push(node->right);
}
res.push_back(levSum/n);
}
return res;
}
};
1.4 二叉树的锯齿形层序遍历
题目描述：给定二叉树的根节点root ，返回其节点值的锯齿形层序遍历 。即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。
题目分析：锯齿形层序遍历的特点是相邻层遍历的顺序相反。在<二叉树层序遍历>的基础上，为实现相邻层遍历顺序相反，可设置标志flag。当flag=true时，从左往右遍历；当flag=false时，从右往左遍历。为实现某一层从右往左遍历，可在处理该层节点时，将其头插至层节点存储向量。
/**
* 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>> zigzagLevelOrder(TreeNode* root) {
if(root==nullptr)
return {};
vector<vector<int>> res;
queue<TreeNode*> que;
bool flag=true; //flag为真，从左往右遍历；flag为假，从右往左遍历
que.push(root);
while(!que.empty()){
int n=que.size();
vector<int> tmp;
TreeNode* node;
for(int i=0;i<n;i++){
node=que.front();
que.pop();
if(flag==true) tmp.push_back(node->val);
if(flag==false) tmp.insert(tmp.begin(),node->val);
if(node->left) que.push(node->left);
if(node->right) que.push(node->right);
}
flag=!flag;
res.push_back(tmp);
}
return res;
}
};
1.5 二叉树的最小深度
题目描述：给定一个二叉树，找出其最小深度。最小深度是从根节点到最近叶子节点的最短路径上的节点数量。
说明：叶子节点是指没有子节点的节点。
题目分析：用广度优先搜索方法来实现二叉树最小深度查找时，当某一层某节点无孩子节点，则该节点为叶子节点。
/**
* 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==nullptr)
return 0;
if(root->left==nullptr&&root->right==nullptr)
return 1;
int res=0;
queue<TreeNode*> que;
que.push(root);
while(!que.empty()){
res++; //深度加1
int n=que.size();
TreeNode* node;
for(int i=0;i<n;i++){
node=que.front();
que.pop();
if(node->left==nullptr&&node->right==nullptr)
return res;
if(node->left) que.push(node->left);
if(node->right) que.push(node->right);
}
}
return res;
}
};
1.6 二叉树的最大深度
题目描述：给定一个二叉树，找出其最大深度。二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。
说明: 叶子节点是指没有子节点的节点。
/**
* 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 maxDepth(TreeNode* root) {
if(root==nullptr)
return 0;
int res=0;
queue<TreeNode*> que;
que.push(root);
while(!que.empty()){
res++;
TreeNode* node;
int n=que.size();
for(int i=0;i<n;i++){
node=que.front();
que.pop();
if(node->left) que.push(node->left); //如果该节点还有孩子节点，继续将其孩子节点加入队列
if(node->right) que.push(node->right);
}
}
return res;
}
};
二、N叉树的遍历
2.1 N叉树的层序遍历
题目描述：给定一个N叉树，返回其节点值的层序遍历。即从左到右，逐层遍历。
/*
// 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) {
if(root==nullptr)
return {};
vector<vector<int>> res;
queue<Node*> que;
que.push(root);
while(!que.empty()){
vector<int> tmp;
Node* node;
int n=que.size();
for(int i=0;i<n;i++){
node=que.front();
que.pop();
tmp.push_back(node->val);
for(auto child:node->children){ //将该层所有节点的孩子节点入队
que.push(child);
}
}
res.push_back(tmp);
}
return res;
}
};
总结
以上所有问题的求解，均是在<二叉树的层序遍历I>基础上进行的改动。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
