跟着代码随想录博主在leetcode上刷题并学习二叉树相关知识点，二叉树的类型和相关的操作比较多，所以这部分需要做的题也比较多，后面会随着做题的进度更新该篇文章，如果有该博主不涉及的题目但和二叉树是相关的，也会加入到这篇文章中。秉持着【学有留痕】的学习方法，所以通过博客的方式来进行记录。与诸君共享并祝学有所成！
目录
二叉树理论基础篇
先给出了题目大纲然后简单地回顾二叉树的理论知识，主要包括了二叉树的定义、分类【满二叉树、完全二叉树、二叉搜索树、平衡二叉搜索树】、存储方式【数组和链表，以链表为主】、遍历方式【深度优先遍历（前序遍历、中序遍历、后续遍历）、广度优先遍历（层次遍历）】等知识点。
题目分类大纲
二叉树的种类
在解题过程中二叉树有两种主要的形式：满二叉树和完全二叉树。
满二叉树
定义：如果一棵二叉树只有度为0的结点和度为2的结点，并且度为0的结点在同一层上，则这棵二叉树为满二叉树。
这棵二叉树为满二叉树，也可以说深度为k，有个节点的二叉树。
完全二叉树
定义：在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层（h从1开始），则该层包含1 ~ 个节点。
【我的理解就是在完全二叉树的基础上，最后一层可以不用填满节点，但是最后一层的节点必须是按顺序从左到右依次填的。如果顺序不对，例如中间空了一个节点没有填，那就不是完全二叉树】
举一个典型的例子如题：
最后一个二叉树是不是完全二叉树都中招了。
之前在栈和对列那里学习过优先级队列其实是一个堆，堆就是一棵完全二叉树，同时保证父子节点的顺序关系。
二叉搜索树
前面介绍的树，都没有数值的，而二叉搜索树是有数值的了，二叉搜索树是一个有序树。
-
若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；
-
若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；
-
它的左、右子树也分别为二叉排序树
【所以该种类型的二叉树的中序遍历结果是从从小到大的有序的一串数值】
下面这两棵树都是搜索树
平衡二叉搜索树
平衡二叉搜索树：又被称为AVL（Adelson-Velsky and Landis）树，且具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。
如图：
最后一棵 不是平衡二叉树，因为它的左右两个子树的高度差的绝对值超过了1。
C++中map、set、multimap，multiset的底层实现都是平衡二叉搜索树，所以map、set的增删操作时间时间复杂度是logn，注意这里没有说unordered_map、unordered_set，unordered_map、unordered_set底层实现是哈希表。
所以使用自己熟悉的编程语言写算法，一定要知道常用的容器底层都是如何实现的，最基本的就是map、set等等，否则自己写的代码，自己对其性能分析都分析不清楚！
二叉树的存储方式
二叉树可以链式存储，也可以顺序存储。链式存储方式用指针， 顺序存储的方式用数组。
顾名思义就是顺序存储的元素在内存是连续分布的，而链式存储则是通过指针把分布在各个地址的节点串联一起。
链式存储如图：
其实就是用数组来存储二叉树，顺序存储的方式如图：
如果父节点的数组下标是 i，那么它的左孩子就是 i * 2 + 1，右孩子就是 i * 2 + 2。
用链式表示的二叉树，更有利于理解，所以一般都是用链式存储二叉树。
这里的介绍主要是要知道用数组依然可以表示二叉树。
二叉树的遍历方式
二叉树主要有两种遍历方式：
-
深度优先遍历：先往深走，遇到叶子节点再往回走。
-
广度优先遍历：一层一层的去遍历。
这两种遍历是图论中最基本的两种遍历方式，后面在介绍图论的时候还会介绍到。
那么从深度优先遍历和广度优先遍历进一步拓展，才有如下遍历方式：
-
深度优先遍历
-
前序遍历（递归法，迭代法）
-
中序遍历（递归法，迭代法）
-
后序遍历（递归法，迭代法）
-
-
广度优先遍历
-
层次遍历（迭代法）
-
在深度优先遍历中：有三个顺序，前中后序遍历， 如果分不清这三个顺序，可以通过中间节点的位置来记。
这里前中后，其实指的就是中间节点的遍历顺序，只要记住前中后序指的就是中间节点的位置就可以了。看如下中间节点的顺序，就可以发现，中间节点的顺序就是所谓的遍历方式
-
前序遍历：中左右
-
中序遍历：左中右
-
后序遍历：左右中
之前我们讲栈与队列的时候，就说过栈其实就是递归的一种实现结构，也就说前中后序遍历的逻辑其实都是可以借助栈使用递归的方式来实现的。
而广度优先遍历的实现一般使用队列来实现，这也是队列先进先出的特点所决定的，因为需要先进先出的结构，才能一层一层的来遍历二叉树。
二叉树的定义
二叉树有两种存储方式顺序存储和链式存储，顺序存储就是用数组来存，主要学习链式存储的二叉树节点的定义方式。
C++代码如下：
struct TreeNode {
int val;
TreeNode *left;
TreeNode *right;
TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};
发现二叉树的定义和链表是差不多的，相对于链表 ，二叉树的节点里多了一个指针， 有两个指针，指向左右孩子。
leetcode里面给出的二叉树定义
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) {}
};
在现场面试的时候 面试官可能要求手写代码，所以数据结构的定义以及简单逻辑的代码一定要锻炼白纸写出来。因为我们在刷leetcode的时候，节点的定义默认都定义好了，真到面试的时候，需要自己写节点定义的时候，有时候会一脸懵逼！
二叉树基础知识总结
二叉树是一种基础数据结构，在算法面试中都是常客，也是众多数据结构的基石。
本篇我们介绍了二叉树的种类、存储方式、遍历方式以及定义，比较全面的介绍了二叉树各个方面的重点，帮助大家扫一遍基础。说到二叉树，就不得不说递归，递归的代码一般很简短，但每次都是一看就会，一写就废。
二叉树的递归遍历
三种遍历方法的学习
为什么容易对递归算法都是“一看就会，一写就废”。主要是对递归不成体系，没有方法论，每次写递归算法 ，都是靠玄学来写代码，代码能不能编过都靠运气。
本篇将介绍前后中序的递归写法，通过简单题目把方法论确定下来，有了方法论，后面才能应付复杂的递归。
这里帮助大家确定下来递归算法的三个要素。每次写递归，都按照这三要素来写，可以保证大家写出正确的递归算法！
-
确定递归函数的参数和返回值： 确定哪些参数是递归的过程中需要处理的，那么就在递归函数里加上这个参数， 并且还要明确每次递归的返回值是什么进而确定递归函数的返回类型。
-
确定终止条件： 写完了递归算法, 运行的时候，经常会遇到栈溢出的错误，就是没写终止条件或者终止条件写的不对，操作系统也是用一个栈的结构来保存每一层递归的信息，如果递归没有终止，操作系统的内存栈必然就会溢出。
-
确定单层递归的逻辑： 确定每一层递归需要处理的信息。在这里也就会重复调用自己来实现递归的过程。
确认了递归的三要素，接下来就来练练手：
以前序遍历为例：
- 确定递归函数的参数和返回值：因为要打印出前序遍历节点的数值，所以参数里需要传入vector来放节点的数值，除了这一点就不需要再处理什么数据了也不需要有返回值，所以递归函数返回类型就是void，代码如下：
void traversal(TreeNode* cur, vector<int>& vec)
- 确定终止条件：在递归的过程中，如何算是递归结束了呢，当然是当前遍历的节点是空了，那么本层递归就要结束了，所以如果当前遍历的这个节点是空，就直接return，代码如下：
if (cur == nullptr) return;
- 确定单层递归的逻辑：前序遍历是中左右的循序，所以在单层递归的逻辑，是要先取中节点的数值，代码如下：
vec.push_back(cur->val); // 中
traversal(cur->left, vec); // 左
traversal(cur->right, vec); // 右
单层递归的逻辑就是按照中左右的顺序来处理的，这样二叉树的前序遍历，基本就写完了，再看一下完整代码：
前序遍历：
class Solution {
public:
void traversal(TreeNode* cur, vector<int>& vec) {
if (cur == NULL) return;
vec.push_back(cur->val); // 中
traversal(cur->left, vec); // 左
traversal(cur->right, vec); // 右
}
vector<int> preorderTraversal(TreeNode* root) {
vector<int> result;
traversal(root, result);
return result;
}
};
那么前序遍历写出来之后，中序和后序遍历就不难理解了，代码如下：
中序遍历：
void traversal(TreeNode* cur, vector<int>& vec) {
if (cur == NULL) return;
traversal(cur->left, vec); // 左
vec.push_back(cur->val); // 中
traversal(cur->right, vec); // 右
}
后序遍历：
void traversal(TreeNode* cur, vector<int>& vec) {
if (cur == NULL) return;
traversal(cur->left, vec); // 左
traversal(cur->right, vec); // 右
vec.push_back(cur->val); // 中
}
此时可以做一做leetcode上三道题目，分别是：
二叉树三种遍历方式的完整代码
前序遍历【144. 二叉树的前序遍历】
class Solution {
public:
// 第一个参数为需要遍历的根节点，第二个数组用来此次存储遍历节点的值
void traversal(TreeNode* cur, vector<int>&result) {
// 前序遍历：中 ——> 左 ——> 右
if (cur == nullptr) return; // 注意递归结束的条件
result.push_back(cur->val);
traversal(cur->left, result);
traversal(cur->right, result);
}
vector<int> preorderTraversal(TreeNode* root) {
vector<int> result;
traversal(root, result);
return result;
}
};中序遍历【94. 二叉树的中序遍历】
class Solution {
public:
void traversal(TreeNode* cur, vector<int>& result) {
if (cur == nullptr) return ;
traversal(cur->left, result);
result.push_back(cur->val);
traversal(cur->right, result);
}
vector<int> inorderTraversal(TreeNode* root) {
vector<int> result;
traversal(root, result);
return result;
}
};后序遍历【145. 二叉树的后序遍历】
class Solution {
public:
void traversal(TreeNode* cur, vector<int> & result) {
if (cur == nullptr) return;
traversal(cur->left, result);
traversal(cur->right, result);
result.push_back(cur->val);
}
vector<int> postorderTraversal(TreeNode* root) {
vector<int> result;
traversal(root, result);
return result;
}
};二叉树的迭代遍历
本节主要学习如果使用迭代法来完成二叉树的前、中、后三种遍历。
前面已经学习了递归的实现就是：每一次递归调用都会把函数的局部变量、参数值和返回地址等压入调用栈中，然后递归返回的时候，从栈顶弹出上一次递归的各项参数，所以这就是递归为什么可以返回上一层位置的原因。
所以用栈也可以是实现二叉树的前后中序遍历。
前序遍历（迭代法）
题目链接：144. 二叉树的前序遍历
前序遍历是中左右，每次先处理的是中间节点，那么先将根节点放入栈中，然后将右孩子加入栈，再加入左孩子。
为什么要先加入 右孩子，再加入左孩子呢？ 因为这样出栈的时候才是中左右的顺序。
动画如下
不难写出如下代码: （注意代码中空节点不入栈）
class Solution {
public:
vector<int> preorderTraversal(TreeNode* root) {
stack<TreeNode*> st;
vector<int> result;
if (root == nullptr) return result;
st.push(root);
// 一直循环知道栈为空
while(!st.empty()) {
TreeNode* node = st.top();
st.pop();
result.push_back(node->val);//中
// 因为栈先进后出的特性，所以下面试先存右再存左
// 这样取元素进行判断的时候就是先左后右啦！
if (node->right) st.push(node->right);
if (node->left) st.push(node->left);
}
return result;
}
};此时是不是想改一点前序遍历代码顺序就把中序遍历搞出来了？
其实还真不行！接下来，再用迭代法写中序遍历的时候，会发现套路又不一样了，目前的前序遍历的逻辑无法直接应用到中序遍历上。
中序遍历（迭代法）
题目链接：94. 二叉树的中序遍历
在迭代的过程中，其实有两个操作：
- 处理：将元素放进result数组中
- 访问：遍历节点
分析一下为什么刚刚写的前序遍历的代码，不能和中序遍历通用呢，因为前序遍历的顺序是中左右，先访问的元素是中间节点，要处理的元素也是中间节点，所以刚刚才能写出相对简洁的代码，因为要访问的元素和要处理的元素顺序是一致的，都是中间节点。
那么再看看中序遍历，中序遍历是左中右，先访问的是二叉树顶部的节点，然后一层一层向下访问，直到到达树左面的最底部，再开始处理节点（也就是在把节点的数值放进result数组中），这就造成了处理顺序和访问顺序是不一致的。
那么在使用迭代法写中序遍历，就需要借用指针的遍历来帮助访问节点，栈则用来处理节点上的元素。
动画如下：
可以写出如下代码：
class Solution {
public:
vector<int> inorderTraversal(TreeNode* root) {
vector<int> result;
stack<TreeNode*> st;
TreeNode* cur = root;
while (cur != NULL || !st.empty()) {
if (cur != NULL) { // 指针来访问节点，访问到最底层
st.push(cur); // 将访问的节点放进栈
cur = cur->left; // 左
} else {
cur = st.top(); // 从栈里弹出的数据，就是要处理的数据（放进result数组里的数据）
st.pop();
result.push_back(cur->val); // 中
cur = cur->right; // 右
}
}
return result;
}
};
- 时间复杂度：O(n)
- 空间复杂度：O(n）
后序遍历（迭代法）
题目链接：145. 二叉树的后序遍历
再来看后序遍历，先序遍历是中左右，后续遍历是左右中，那么我们只需要调整一下先序遍历的代码顺序，就变成中右左的遍历顺序，然后在反转result数组，输出的结果顺序就是左右中了。
如下图：
所以后序遍历只需要前序遍历的代码稍作修改就可以了，代码如下：
class Solution {
public:
vector<int> postorderTraversal(TreeNode* root) {
stack<TreeNode*> st;
vector<int> result;
if (root == nullptr) return result;
st.push(root);
// 一直循环知道栈为空
while(!st.empty()) {
TreeNode* node = st.top();
st.pop();
result.push_back(node->val);//中
// 先左后右，因为后面有翻转操作
if (node->left) st.push(node->left);
if (node->right) st.push(node->right);
}
reverse(result.begin(), result.end());
return result;
}
};- 时间复杂度：O(n)
- 空间复杂度：O(n）
总结
用迭代法写出了二叉树的前后中序遍历，可以看出前序和中序是完全两种代码风格，并不像递归写法那样代码稍做调整，就可以实现前后中序。
这是因为前序遍历中访问节点（遍历节点）和处理节点（将元素放进result数组中）可以同步处理，但是中序就无法做到同步！
二叉树的统一迭代法
难道二叉树前后中序遍历的迭代法实现，就不能风格统一么（即前序遍历改变代码顺序就可以实现中序和后序）？
答案是可以的，开始这一节的内容，使用风格统一的迭代法来完成二叉树前、中、后三种方式的遍历。
其实针对三种遍历方式，使用迭代法是可以写出统一风格的代码！
我们以中序遍历为例，在前面的迭代法中提到说使用栈的话，无法同时解决访问节点（遍历节点）和处理节点（将元素放进结果集）不一致的情况。
那我们就将访问的节点放入栈中，把要处理的节点也放入栈中但是要做标记。
如何标记呢，就是要处理的节点放入栈之后，紧接着放入一个空指针作为标记。 这种方法也可以叫做标记法。
迭代法中序遍历
题目链接：94. 二叉树的中序遍历
解题思路：将访问的节点直接加入到栈中，但如果是处理的节点则后面放入一个空节点， 这样只有空节点弹出的时候，才将下一个节点放进结果集。result数组就是最终结果集。
中序遍历代码如下：
class Solution {
public:
vector<int> inorderTraversal(TreeNode* root) {
vector<int> result;
stack<TreeNode*> st;
if (root != NULL) st.push(root);
while (!st.empty()) {
TreeNode* node = st.top();
if (node != NULL) {
st.pop(); // 将该节点弹出，避免重复操作，下面再将右中左节点添加到栈中
if (node->right) st.push(node->right); // 添加右节点（空节点不入栈）
st.push(node); // 添加中节点
st.push(NULL); // 中节点访问过，但是还没有处理，加入空节点做为标记。
if (node->left) st.push(node->left); // 添加左节点（空节点不入栈）
} else { // 只有遇到空节点的时候，才将下一个节点放进结果集
st.pop(); // 将空节点弹出
node = st.top(); // 重新取出栈中元素
st.pop();
result.push_back(node->val); // 加入到结果集
}
}
return result;
}
};
- 时间复杂度：O(n)
- 空间复杂度：O(n）
迭代法前序遍历
题目链接：144. 二叉树的前序遍历
注意和中序遍历相比仅仅改变了两行代码的顺序
class Solution {
public:
vector<int> preorderTraversal(TreeNode* root) {
vector<int> result;
stack<TreeNode*> st;
if (root != NULL) st.push(root);
while (!st.empty()) {
TreeNode* node = st.top();
if (node != NULL) {
st.pop();
if (node->right) st.push(node->right); // 右
if (node->left) st.push(node->left); // 左
st.push(node); // 中
st.push(NULL);
} else {
st.pop();
node = st.top();
st.pop();
result.push_back(node->val);
}
}
return result;
}
};
- 时间复杂度：O(n)
- 空间复杂度：O(n）
迭代法后序遍历
题目链接：145. 二叉树的后序遍历
注意和中序遍历相比仅仅改变了两行代码的顺序
class Solution {
public:
vector<int> postorderTraversal(TreeNode* root) {
vector<int> result;
stack<TreeNode*> st;
if (root != NULL) st.push(root);
while (!st.empty()) {
TreeNode* node = st.top();
if (node != NULL) {
st.pop();
st.push(node); // 中
st.push(NULL);
if (node->right) st.push(node->right); // 右
if (node->left) st.push(node->left); // 左
} else {
st.pop();
node = st.top();
st.pop();
result.push_back(node->val);
}
}
return result;
}
};
- 时间复杂度：O(n)
- 空间复杂度：O(n）
这个版本的我就先不研究了，直接复制了原博主的代码过来，想要了解学习的同学可以参考上面的代码。我个人偏向第一个迭代版本。
总结
写出了统一风格的迭代法，不用在纠结于前序写出来了，中序写不出来的情况了。
但是统一风格的迭代法并不好理解，而且想在面试直接写出来还有难度的。
所以需要根据自己的个人喜好，对于二叉树的前中后序遍历，选择一种自己容易理解的递归和迭代法。
二叉树层序遍历
学会二叉树的层序遍历，可以一口气打完以下十题：
- 102.二叉树的层序遍历
- 107.二叉树的层次遍历II
- 199.二叉树的右视图
- 637.二叉树的层平均值
- 429.N叉树的层序遍历
- 515.在每个树行中找最大值
- 116.填充每个节点的下一个右侧节点指针
- 117.填充每个节点的下一个右侧节点指针II
- 104.二叉树的最大深度
- 111.二叉树的最小深度
以题目102.二叉树的层序遍历为例先学习一下普通的层次遍历写法。有关的题目可以直接套此题的模板。
题目链接：102. 二叉树的层序遍历
题目描述：给你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）。
示例 1：
输入：root = [3,9,20,null,null,15,7] 输出：[[3],[9,20],[15,7]]
示例 2：输入：root = [1] 输出：[[1]]
示例 3：输入：root = [] 输出：[]
层序遍历思路：需要借用一个辅助数据结构即队列来实现，队列先进先出，符合一层一层遍历的逻辑，而用栈先进后出适合模拟深度优先遍历也就是递归的逻辑。
而这种层序遍历方式就是图论中的广度优先遍历，只不过我们应用在二叉树上。
使用队列实现二叉树广度优先遍历，动画如下：
这样就实现了层序从左到右遍历二叉树。
代码如下：这份代码也可以作为二叉树层序遍历的模板，打十个就靠它了。
迭代版代码
class Solution {
public:
vector<vector<int>> levelOrder(TreeNode* root) {
queue<TreeNode*> que;// 定义一个对列用来存储待遍历的节点
vector<vector<int>> result;//用来存储层序遍历的结果
if (root != nullptr) que.push(root);//先存入非空的根节点
while (!que.empty()) {
int size = que.size();
vector<int> vec;//用来存储每一层遍历的结果
//这里不能用que.size()，因为随着遍历，该大小事不断变化的
for (int i = 0; i < size; i++) {
TreeNode* node = que.front();
que.pop();
vec.push_back(node->val);
if (node->left != nullptr) que.push(node->left);
if (node->right != nullptr) que.push(node->right);
}
result.push_back(vec);
}
return result;
}
};- 时间复杂度：O(n)
- 空间复杂度：O(n）
递归版代码
class Solution {
public:
void order(TreeNode* cur, vector<vector<int>>&result, int depth) {
if (cur == nullptr) return;
if (depth == result.size()) 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;
}
};- 时间复杂度：O(n)
- 空间复杂度：O(n）
题目列表
学会二叉树的层序遍历，可以一口气打完以下十题：
- 102.二叉树的层序遍历
- 107.二叉树的层次遍历II
- 199.二叉树的右视图
- 637.二叉树的层平均值
- 429.N叉树的层序遍历
- 515.在每个树行中找最大值
- 116.填充每个节点的下一个右侧节点指针
- 117.填充每个节点的下一个右侧节点指针II
- 104.二叉树的最大深度
- 111.二叉树的最小深度
层序遍历相关题目练习
102.二叉树的层序遍历
题目链接：102. 二叉树的层序遍历 解题如上所示。
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 = [] 输出：[]
解题思路:和上一题102. 二叉树的层序遍历相比只用在最后翻转结果数组即可。
代码
class Solution {
public:
vector<vector<int>> levelOrderBottom(TreeNode* root) {
queue<TreeNode*> que;// 定义一个对列用来存储待遍历的节点
vector<vector<int>> result;//用来存储层序遍历的结果
if (root != nullptr) que.push(root);//先存入非空的根节点
while (!que.empty()) {
int size = que.size();
vector<int> vec;//用来存储每一层遍历的结果
//这里不能用que.size()，因为随着遍历，该大小事不断变化的
for (int i = 0; i < size; i++) {
TreeNode* node = que.front();
que.pop();
vec.push_back(node->val);
if (node->left != nullptr) que.push(node->left);
if (node->right != nullptr) que.push(node->right);
}
result.push_back(vec);
}
// 比上一题只多了下面这一行翻转的操作
reverse(result.begin(), result.end());
return result;
}
};- 时间复杂度：O(n)，其中 n 是二叉树中的节点个数。每个节点访问一次，结果列表使用链表的结构时，在结果列表头部添加一层节点值的列表的时间复杂度是 O(1)，因此总时间复杂度是 O(n)。
- 空间复杂度：O(n)，其中 n是二叉树中的节点个数。空间复杂度取决于队列开销，队列中的节点个数不会超过 n。
使用递归的方法也是一样的，最后翻转一下数组即可。
199.二叉树的右视图
题目链接：199. 二叉树的右视图
题目描述：给定一个二叉树的 根节点 root，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。
示例 1:
输入: [1,2,3,null,5,null,4]输出: [1,3,4]
示例 2:输入: [1,null,3]输出: [1,3]
示例 3:输入: []输出: []
解题思路：层序遍历的时候，判断是否遍历到单层的最后面的元素，如果是，就放进result数组中，随后返回result就可以了。
代码
class Solution {
public:
vector<int> rightSideView(TreeNode* root) {
queue<TreeNode*> que;// 定义一个对列用来存储待遍历的节点
vector<int> result;//用来存储层序遍历的结果
if (root != nullptr) que.push(root);//先存入非空的根节点
while (!que.empty()) {
int size = que.size();
vector<int> vec;//用来存储每一层遍历的结果
//这里不能用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 != nullptr) que.push(node->left);
if (node->right != nullptr) que.push(node->right);
}
}
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]解题思路：统计每层节点的和
代码：
class Solution {
public:
vector<double> averageOfLevels(TreeNode* root) {
vector<double> result;
queue<TreeNode*> que;
if (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) que.push(node->left);
if (node->right) que.push(node->right);
}
result.push_back(sum / size);
}
return result;
}
};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]]解题思路：
先来看看leetcode给出的N叉树的定义
class Node {
public:
int val;
vector<Node*> children;
Node() {}
Node(int _val) {
val = _val;
}
Node(int _val, vector<Node*> _children) {
val = _val;
children = _children;
}
};没有了左右指针，只有一个孩子数组指针。思路和之前层序遍历的一样，只是一个节点有多个孩子指针。
代码：
/*
// 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) {
vector<vector<int>> result;
queue<Node*> que;
if (root) 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);
// 主要是这里不一样 一个节点有多个孩子
for (int j = 0; j < node->children.size(); j++) {
if (node->children[j]) que.push(node->children[j]);
}
}
result.push_back(vec);
}
return result;
}
};515.在每个树行中找最大值
题目链接：515. 在每个树行中找最大值
题目描述：给定一棵二叉树的根节点 root ，请找出该二叉树中每一层的最大值。
示例1：输入: root = [1,3,2,5,3,null,9] 输出: [1,3,9]
示例2：输入: root = [1,2,3] 输出: [1,3]
解题思路：每层取最大值
代码：
class Solution {
public:
vector<int> largestValues(TreeNode* root) {
vector<int> result;
queue<TreeNode*> que;
if (root) que.push(root);
while (!que.empty()) {
int size = que.size();
int max_vals = INT_MIN;//注意最大值的初始值
for (int i = 0; i < size; i++) {
TreeNode* node = que.front();
que.pop();
// 主要是操作这里
max_vals = max(max_vals, node->val);
if (node->left) que.push(node->left);
if (node->right) que.push(node->right);
}
result.push_back(max_vals);
}
return result;
}
};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 = [] 输出：[]
解题思路：判断如果是每层的最后一个节点则指向空指针，否则指向对列的第一个元素，即当前遍历的元素的右邻居。
代码：
class Solution {
public:
Node* connect(Node* root) {
queue<Node*> que;
if (root) que.push(root);
while (!que.empty()) {
int size = que.size();
for (int i = 0; i < size; i++) {
Node* node = que.front();
que.pop();
//如果是每层的最后一个节点则指向空指针
if (i == size - 1) node->next = nullptr;
// 否则指向对列的第一个元素，即当前遍历的元素的右邻居
else node->next = que.front();
if (node->left) que.push(node->left);
if (node->right) que.push(node->right);
}
}
return root;
}
};117.填充每个节点的下一个右侧节点指针II
题目描述：给定一个二叉树：
struct Node {
int val;
Node *left;
Node *right;
Node *next;
}填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL 。
初始状态下，所有 next 指针都被设置为 NULL 。
示例 1：
输入：root = [1,2,3,4,5,null,7]
输出：[1,#,2,3,#,4,5,7,#]
解释：给定二叉树如图 A 所示，你的函数应该填充它的每个 next 指针，以指向其下一个右侧节点，如图 B 所示。序列化输出按层序遍历顺序（由 next 指针连接），'#' 表示每层的末尾。示例 2：输入：root = []输出：[]
解题思路：思路代码和上一题都一模一样。
代码：
class Solution {
public:
Node* connect(Node* root) {
queue<Node*> que;
if (root) que.push(root);
while (!que.empty()) {
int size = que.size();
for (int i = 0; i < size; i++) {
Node* node = que.front();
que.pop();
//如果是每层的最后一个节点则指向空指针
if (i == size - 1) node->next = nullptr;
// 否则指向对列的第一个元素，即当前遍历的元素的右邻居
else node->next = que.front();
if (node->left) que.push(node->left);
if (node->right) que.push(node->right);
}
}
return root;
}
};104.二叉树的最大深度
题目链接：104. 二叉树的最大深度
题目描述：给定一个二叉树 root ，返回其最大深度。
二叉树的 最大深度 是指从根节点到最远叶子节点的最长路径上的节点数。
示例 1：输入：root = [3,9,20,null,null,15,7] 输出：3
示例 2： 输入：root = [1,null,2] 输出：2
解题思路：使用迭代法的话，使用层序遍历是最为合适的，因为最大的深度就是二叉树的层数，和层序遍历的方式极其吻合。
在二叉树中，一层一层的来遍历二叉树，记录一下遍历的层数就是二叉树的深度，如图所示：
代码：
class Solution {
public:
int maxDepth(TreeNode* root) {
queue<TreeNode*> que;
if (root) que.push(root);
int depth = 0;
while (!que.empty()) {
int size = que.size();
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);
}
depth++;//每层遍历完增加一个高度
}
return depth;
}
};其实这道题的递归法也很常用，代码非常简短优雅
class Solution {
public:
int maxDepth(TreeNode* root) {
if (root == nullptr) return 0;
return max(maxDepth(root->left), maxDepth(root->right)) + 1;
}
};111.二叉树的最小深度
题目列表：111. 二叉树的最小深度
题目描述：给定一个二叉树，找出其最小深度。最小深度是从根节点到最近叶子节点的最短路径上的节点数量。
说明：叶子节点是指没有子节点的节点。
示例 1：
输入：root = [3,9,20,null,null,15,7] 输出：2
示例 2： 输入：root = [2,null,3,null,4,null,5,null,6] 输出：5
解题思路：和上一题的解题思路差不多，就是增加一个判断，如果遍历时发现节点没有孩子了，就可以直接返回结果了。
代码：
class Solution {
public:
int minDepth(TreeNode* root) {
queue<TreeNode*> que;
if (root) que.push(root);
int depth = 0;
while (!que.empty()) {
depth++;//每层遍历增加一个高度
int size = que.size();
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;
}
};递归版本
class Solution {
public:
int minDepth(TreeNode* root) {
if (!root) 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;
}
};
1569
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
