二叉树5：二叉树层序遍历
学会二叉树的层序遍历，可以一口气打完以下十题：
强烈建议大家和我一样，先看一下第一道题，大家可以去看看卡哥的哔站视频，理解透。然后后面的九道题自己先动手做一下，别急着看答案，真心不难，做完会很成就感。
102.二叉树的层序遍历
107. 二叉树的层序遍历 II
199.二叉树的右视图
637.二叉树的层平均值
429.N叉树的层序遍历
515.在每个树行中找最大值
116.填充每个节点的下一个右侧节点指针
117.填充每个节点的下一个右侧节点指针II
104.二叉树的最大深度
111.二叉树的最小深度
我自己提前打了一遍在看的解析，感觉确实学完了层序遍历之后就不难。大家也可以试试。
102.二叉树的层序遍历
链接: 102.二叉树的层序遍历
给你一个二叉树，请你返回其按 层序遍历 得到的节点值。 （即逐层地，从左到右访问所有节点）。
示例 1：
输入：root = [3,9,20,null,null,15,7]
输出：[[3],[9,20],[15,7]]
示例 2：
输入：root = [1]
输出：[[1]]
示例 3：
输入：root = []
输出：[]
提示：
树中节点数目在范围 [0, 2000] 内
-1000 <= Node.val <= 1000
层序遍历一个二叉树。就是从左到右一层一层的去遍历二叉树。这种遍历的方式和我们之前讲过的都不太一样。
需要借用一个辅助数据结构即队列来实现，队列先进先出，符合一层一层遍历的逻辑，而是用栈先进后出适合模拟深度优先遍历也就是递归的逻辑。
而这种层序遍历方式就是图论中的广度优先遍历，只不过我们应用在二叉树上。
实现的思路：队列不空的话同时记录队列大小，我们就一次取出头节点，，访问该节点，然后把这个节点的所有孩子节点在加入队列中，
使用队列实现二叉树广度优先遍历，动画如下：
这样就实现了层序从左到右遍历二叉树。
代码如下：这份代码也可以作为二叉树层序遍历的模板，打十个就靠它了。
C++代码：
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
链接: 107. 二叉树的层序遍历 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数组反转一下就可以了。
C++代码：
//递归法
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>> levelOrderBottom(TreeNode* root) {
vector<vector<int>> result;
int depth = 0;
order(root, result, depth);
reverse(result.begin(), result.end());
/*int left=0, right=result.size()-1; //这句代码也可以替换为下面的，不过自己写的执行效率更低
while (left < right)
swap(result[left++], result[right--]);*/
return result;
}
};
//迭代法
class Solution {
public:
vector<vector<int>> levelOrderBottom(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;
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);
}
reverse(result.begin(), result.end()); // 在这里反转一下数组即可
return result;
}
};
199.二叉树的右视图
链接: 199.二叉树的右视图
给定一个二叉树的 根节点 root，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。
示例
示例 1:
输入: [1,2,3,null,5,null,4]
输出: [1,3,4]
示例 2:
输入: [1,null,3]
输出: [1,3]
示例 3:
输入: []
输出: []
提示:
二叉树的节点个数的范围是 [0,100]
-100 <= Node.val <= 100
思路：
- 层序遍历的时候，判断是否遍历到单层的最后面的元素，如果是，就放进result数组中，随后返回result就可以了。
- 每一层在容器中一直维持一个元素，直到他为最右边的节点。
C++代码：
//迭代法
class 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数组中（要找最左边的让他等于0 就好了）
if (node->left) que.push(node->left);
if (node->right) que.push(node->right);
}
}
return result;
}
};
//递归法
class Solution {
public:
void order(TreeNode* cur, vector<int>& result, int depth) {
if (cur == nullptr) return;
if (result.size() == depth)result.push_back(0); //临时的占位符
result[depth]=cur->val; //每一层只保留最后一次处理的节点，即最右边的节点
order(cur->left, result, depth + 1); //处理左孩子 //换一下处理孩子的顺序就可以看左视图，大家可以试试哦
order(cur->right, result, depth + 1); //处理右孩子
}
vector<int> rightSideView(TreeNode* root) {
vector<int> result;
int depth = 0;
order(root, result, depth);
return result;
}
};
637.二叉树的层平均值
链接: 637.二叉树的层平均值
给定一个非空二叉树的根节点 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]
提示：
树中节点数量在 [1, 104] 范围内
-231<= Node.val <= 231 - 1
思路:
本题就是层序遍历的时候把一层求个总和在取一个均值。
其实这个思路不难，但是我刚好复习的时候学到了一个函数对象（总想嘚瑟一下 是吧。大家可以参考一下，毕竟多复习一点知识），就试着用了一下，感觉还行。
C++代码：
//卡哥的代码（一如既往地简单高效）
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;
}
};
//我自己写的代码，有一点点拉胯（迭代法） 时间上击败95.77%
class Solution {
public:
class average { //函数对象：他可以有自己的状态，用起来的时候和函数差不多，但是他实际是一个对象冲在了（）运算符。
private:
vector<double>* result2; //用来存平均值数组
public:
average(vector<double>* result) :result2(result){} //含参构造函数应该不用解释吧
void operator()(const vector<int>& vec){
double sum=0;
for (auto& num : vec) {
sum += num;
}
result2->push_back(sum / vec.size());
}
};
//还是用卡哥的模板，自己尝试了一下for_each函数
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<double> averageOfLevels(TreeNode* root) {
vector<vector<int>> result;
int depth = 0;
order(root, result, depth);
vector<double> result2;
for_each(result.begin(), result.end(), average(&result2));
return result2;
}
};
for_each总结：
void operator()(const vector<int>& vec) 中的const vector<int>& vec其实就是迭代器中的每一个元素，
我这边用引用传递是为了提高效率，避免反复拷贝，const是可以避免修改他的值 。
其实还有一个办法就是 for_each 可以直接返回我们的这个 vector<double>* result2;//用来存平均值数组
下面是我调试这个函数对象的过程，大家看得到他只是走void operator()里面的具体操作过程，因为他默认是每个元素都拿到了，就不用走到void operator()的91行这一步。（不知道这么理解对不对，如果有问题希望大家可以一起在评论区交流）
429.N叉树的层序遍历
链接: 429.N叉树的层序遍历
给定一个 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]]
提示：
树的高度不会超过 1000
树的节点总数在 [0, 104] 之间
思路:
这道题依旧是模板题，只不过一个节点有多个孩子了,大家先看看这个数的结构，使用vector数组来管理孩子节点的。
C++代码:
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);
for (int i = 0; i < node->children.size(); i++) { // 将节点孩子加入队列
if (node->children[i]) que.push(node->children[i]);
}
}
result.push_back(vec);
}
return result;
}
};
//我自己写的和他的差不多，我for循环用的是C++11的范围for循环。
class Solution {
public:
vector<vector<int>> levelOrder(Node* root) {
vector<vector<int>>result;
queue<Node*>myQueue;
Node* cur = root;
if (root != nullptr) myQueue.push(root);
while (!myQueue.empty()) {
int size = myQueue.size();
vector<int>temp;
while (size--) {
Node* tempNode = myQueue.front();
temp.push_back(tempNode->val);
myQueue.pop();
for (Node* tempN : tempNode->children) {
myQueue.push(tempN);
}
}
result.push_back(temp);
}
return result;
}
};
515.在每个树行中找最大值
链接: 515.在每个树行中找最大值
给定一棵二叉树的根节点 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
思路：
层序遍历，取每一层的最大值
C++代码：
//卡哥的代码
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;
}
};
//明明迭代那么简单，我自己还是想玩玩递归走了一点点弯路
class Solution {//这个方法是先遍历所有的节点存起来，然后再找最大值。
public:
void dfs(TreeNode* node, vector<vector<int>>&temp, int dpeth) {
if (node == nullptr) return;
if (temp.size() == dpeth) temp.push_back(vector<int>()); //从第零层开始就放一个空数组
temp[dpeth].push_back(node->val); //处理节点
if (node->left) dfs(node->left, temp, dpeth + 1); //处理子节点
if (node->right) dfs(node->right, temp, dpeth + 1); //处理子节点
}
vector<int> largestValues(TreeNode* root) {
vector<vector<int>>temp;
vector<int>maxVec;
int dpeth=0;
dfs(root, temp, dpeth);
for (auto tempVec : temp) {
int maxval = INT_MIN;
for (auto num : tempVec)
maxval = max(maxval,num);
maxVec.push_back(maxval);
}
return maxVec;
}
};
class Solution {//这个方法是直接遍历的时候找最大值。
public:
void dfs(vector<int>& res, TreeNode* root, int curHeight) {
if (curHeight == res.size())
res.push_back(root->val);
else
res[curHeight] = max(res[curHeight], root->val); //只存最大值。
if (root->left) dfs(res, root->left, curHeight + 1);
if (root->right) dfs(res, root->right, curHeight + 1);
}
vector<int> largestValues(TreeNode* root) {
if (!root) return {};
vector<int> res;
dfs(res, root, 0);
return res;
}
};
116.填充每个节点的下一个右侧节点指针
链接: 116.填充每个节点的下一个右侧节点指针
给定一个 完美二叉树 ，其所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树定义如下：
struct Node {
int val;
Node *left;
Node *right;
Node *next;
}
填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。
初始状态下，所有 next 指针都被设置为 NULL。
示例
示例 1：
输入：root = [1,2,3,4,5,6,7]
输出：[1,#,2,3,#,4,5,6,7,#]
解释：给定二叉树如图 A 所示，你的函数应该填充它的每个 next 指针，以指向其下一个右侧节点，如图 B 所示。序列化的输出按层序遍历排列，同一层节点由 next 指针连接，'#' 标志着每一层的结束。
示例 2:
输入：root = []
输出：[]
提示：
树中节点的数量在 [0, 212 - 1] 范围内
-1000 <= node.val <= 1000
思路:
本题依然是层序遍历，只不过在单层遍历的时候记录一下本层的头部节点，然后在遍历的时候让前一个节点指向本节点就可以了。我的是遍历的时候让本节点指向下一个节点，最后特殊处理尾节点。
C++代码：
//卡哥的代码
class Solution {
public:
Node* connect(Node* root) {
queue<Node*> que;
if (root != NULL) que.push(root);
while (!que.empty()) {
int size = que.size();
// vector 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
}
return root;
}
};
//我的代码逻辑上可能好理解一些，就是每一行中 每次取出元素时候都指向队列的队头元素，同时加入他的子节点进队列中，处理最后一个的时候就不指元素了（他本是就是指向nullptr）
class Solution {
public:
Node* connect(Node* root) {
queue<Node*>myQueue;
if (!root) return nullptr;
else myQueue.push(root);
while (!myQueue.empty()) {
int size = myQueue.size();
while (size--) {
if (size > 0 ) {
Node* tempNode = myQueue.front();
myQueue.pop();
tempNode->next = myQueue.front();
if (tempNode->left) myQueue.push(tempNode->left);
if (tempNode->right) myQueue.push(tempNode->right);
}
else {
Node* tempNode = myQueue.front();
myQueue.pop();
if (tempNode->left) myQueue.push(tempNode->left);
if (tempNode->right) myQueue.push(tempNode->right);
}
}
}
return root;
}
};
117.填充每个节点的下一个右侧节点指针II
链接: 117.填充每个节点的下一个右侧节点指针II
给定一个二叉树
struct Node {
int val;
Node *left;
Node *right;
Node *next;
}
填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。
初始状态下，所有 next 指针都被设置为 NULL。
进阶：
你只能使用常量级额外空间。
使用递归解题也符合要求，本题中递归程序占用的栈空间不算做额外的空间复杂度。
示例：
输入：root = [1,2,3,4,5,null,7]
输出：[1,#,2,3,#,4,5,7,#]
解释：给定二叉树如图 A 所示，你的函数应该填充它的每个 next 指针，以指向其下一个右侧节点，
如图 B 所示。序列化输出按层序遍历顺序（由 next 指针连接），'#' 表示每层的末尾。
提示：
树中的节点数小于 6000
-100 <= node.val <= 100
思路：
这道题目说是二叉树，但116题目说是完整二叉树，其实没有任何差别，一样的代码一样的逻辑一样的味道
C++代码：
//卡哥的代码
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
}
return root;
}
};
class Solution {
public:
Node* connect(Node* root) {
queue<Node*>myQueue;
if (!root) return nullptr;
else myQueue.push(root);
while (!myQueue.empty()) {
int size = myQueue.size();
while (size--) {
if (size > 0 ) {
Node* tempNode = myQueue.front();
myQueue.pop();
tempNode->next = myQueue.front();
if (tempNode->left) myQueue.push(tempNode->left);
if (tempNode->right) myQueue.push(tempNode->right);
}
else {
Node* tempNode = myQueue.front();
myQueue.pop();
if (tempNode->left) myQueue.push(tempNode->left);
if (tempNode->right) myQueue.push(tempNode->right);
}
}
}
return root;
}
};
104.二叉树的最大深度
链接: 104.二叉树的最大深度
给定一个二叉树，找出其最大深度。
二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。
说明: 叶子节点是指没有子节点的节点。
示例：
给定二叉树 [3,9,20,null,null,15,7]，
3
/ \
9 20
/ \
15 7
返回它的最大深度 3 。
思路：
使用迭代法的话，使用层序遍历是最为合适的，因为最大的深度就是二叉树的层数，和层序遍历的方式极其吻合。
在二叉树中，一层一层的来遍历二叉树，记录一下遍历的层数就是二叉树的深度，如图所示：
所以这道题的迭代法就是一道模板题，可以使用二叉树层序遍历的模板来解决的。
C++代码如下：
//卡哥的代码
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 == 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;
}
};
//其实用递归也挺简单的。
class Solution {
public:
void dfs(TreeNode* node, int depth, int& maxdepth) {
if (!node) return;
maxdepth = max(maxdepth, depth); //最大深度和当前深度比 取最大
if(node->left) dfs(node->left, depth+1, maxdepth);
if (node->right) dfs(node->right, depth + 1, maxdepth);
}
int maxDepth(TreeNode* root) {
if (!root) return 0;
int depth = 1;
int maxdepth = 1;
dfs(root, depth, maxdepth);
return maxdepth;
}
};
111.二叉树的最小深度
链接: 111.二叉树的最小深度
给定一个二叉树，找出其最小深度。
最小深度是从根节点到最近叶子节点的最短路径上的节点数量。
说明：叶子节点是指没有子节点的节点。
示例
示例 1：
输入：root = [3,9,20,null,null,15,7]
输出：2
示例 2：
输入：root = [2,null,3,null,4,null,5,null,6]
输出：5
提示：
树中节点数的范围在 [0, 105] 内
-1000 <= Node.val <= 1000
思路
相对于 104.二叉树的最大深度 ，本题还也可以使用层序遍历的方式来解决，思路是一样的。
需要注意的是，只有当左右孩子都为空的时候，才说明遍历的最低点了。如果其中一个孩子为空则不是最低点
代码如下：
//卡哥的代码
class Solution {
public:
int minDepth(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);
if (!node->left && !node->right) { // 当左右孩子都为空的时候，说明是最低点的一层了，退出
return depth;
}
}
}
return depth;
}
};
//力扣的代码，我自己想用上面的104.二叉树的最大深度的递归改出来，没实现。
class Solution {
public:
int minDepth(TreeNode* root) {
if(root == nullptr) return 0;
int m1 = minDepth(root->left);
int m2 = minDepth(root->right);
//1.如果左孩子和右孩子有为空的情况，直接返回m1+m2+1
//2.如果都不为空，返回较小深度+1
return root->left == nullptr || root->right == nullptr ? m1 + m2 + 1 : min(m1,m2) + 1;
}
};
复杂度分析
时间复杂度：O(N)，其中 N是树的节点数。对每个节点访问一次。
空间复杂度：O(H)，其中 H 是树的高度。空间复杂度主要取决于递归时栈空间的开销，最坏情况下，树呈现链状，空间复杂度为 O(N)。
平均情况下树的高度与节点数的对数正相关，空间复杂度为 O(logN)。
总结
二叉树的层序遍历，就是图论中的广度优先搜索在二叉树中的应用，需要借助队列来实现（此时又发现队列的一个应用了）。