代码随想录算法训练营第15天 | 二叉树part02：●层序遍历和10道题● 226.翻转二叉树 ● 101.对称二叉树 2
10道层序遍历
关于层序遍历的recursion递归法
！！！尽管层序遍历的recursion方法能够生成按层级组织的输出，但它的遍历方式实际上是dfs
在开头总结下这10道题：
基础模板:102，107，199，429
适合用bfs迭代，不推荐用dfs/递归（因为要同层内操作）:637，515，116，117
bfs dfs都可：找深度 104， 111 （这一章是层次遍历，我们找深度的题都可以直接当层次遍历的模板题，之后博客还会详细讨论“深度”题型）
1. 102 基本款层序遍历
层序遍历-迭代法
注意：用固定大小size来遍历
vector> levelOrder(TreeNode* root) {
vector> res;
queue myq;
if(root!=nullptr) myq.push(root);
while(!myq.empty()){
int size=myq.size();
vector vec;
//此处一定要用固定大小size，因为不断操作myq，用queue.size()会变
for(int i=0;ival);
myq.pop();
if(node->left!=nullptr) myq.push(node->left);
if(node->right!=nullptr) myq.push(node->right);
}
res.push_back(vec);
}
return res;
}
层序遍历-递归法
易错：传入的变量到底是var还是ref
如何想明白：如果depth传的是ref的话，if(node->left!=nullptr)order(node->left,depth+1,res);这个执行完到下一句right那里，depth就会变，但不能让他变
void order(TreeNode* node, int depth, vector> &res){
//depth 不應該傳入ref很重要，因爲遞歸的歸 return
//比如left做完回來的時候，depth不應該變
if(node==nullptr)return;
if(res.size()==depth)res.push_back(vector());
res[depth].push_back(node->val);
if(node->left!=nullptr)order(node->left,depth+1,res);
if(node->right!=nullptr)order(node->right,depth+1,res);
}
vector> levelOrder(TreeNode* root) {
vector> res;
int depth=0;
order(root, depth, res);
return res;
} 
以上是探讨dfs&bfs实现的区别
2. 107 层序遍历从最下层开始 易变体： 迭代ok 递归ok 都是最基本的+vec反一下就行；
vector> levelOrderBottom(TreeNode* root) {
//想到幾種方法：1 放入 stack來反過來
//2 用雙指針把vec 做reverse
//3 用庫函數做reverse
vector> res;
queue myq;
if(root!=nullptr) myq.push(root);
TreeNode *node;
while(!myq.empty()){
int size=myq.size();
vector vec;
for(int i=0;ival);
myq.pop();
if(node->left!=nullptr) myq.push(node->left);
if(node->right!=nullptr) myq.push(node->right);
}
res.push_back(vec);
}
//reverse(res.begin(),res.end());
int i=0; int j=res.size()-1;
while(i 3. 199 层序右视图 易变体，迭代ok：pushback vec改成if(i==size-1) res.push_back(node->val); 即可
vector rightSideView(TreeNode* root) {
vector res;
queuemyq;
TreeNode* node;
if(root!=nullptr) myq.push(root);
while(!myq.empty()){
int size=myq.size();
for(int i=0;ileft!=nullptr) myq.push(node->left);
if(node->right!=nullptr) myq.push(node->right);
if(i==size-1) res.push_back(node->val);
}
}
return res;
}
递归ok
void traverse(TreeNode* node, int depth, vector &res){
if(node==nullptr) return;
if(depth==res.size()) res.push_back(0);
res[depth]=node->val;
//关键是前面这两行，一开始觉得很难找到一层最后一个
//后来发现每个新的来了覆盖就行
if(node->left!=nullptr) traverse(node->left, depth+1, res);
if(node->right!=nullptr) traverse(node->right, depth+1, res);
}
vector rightSideView(TreeNode* root) {
vector res;
traverse(root, 0, res);
return res;
} 4. 637 每层的平均值，易变体，迭代ok
易错需注意：有运算和大的加时，记得type：double、long，反正不能用int了，我这个方面意识薄弱
vector averageOfLevels(TreeNode* root) {
vector res;
queuemyq;
TreeNode* node;
if(root!=nullptr) myq.push(root);
while(!myq.empty()){
int size=myq.size();
long sum=0;
double avg=0;
for(int i=0;ileft!=nullptr) myq.push(node->left);
if(node->right!=nullptr) myq.push(node->right);
sum+=node->val;
}
avg=(double)sum/size;
res.push_back(avg);
}
return res;
}
递归会很复杂，对同层元素之间操作的（求平均值，找最大/小值，放入next）都不适合用recursion-dfs做，会非常复杂。下面是gpt写的，过了，我是懒得写了，复杂而且不适合
void averageOfLevels(TreeNode* node, int depth, vector& sums, vector& counts) {
if (node == nullptr) return;
if (depth >= sums.size()) {
sums.push_back(node->val);
counts.push_back(1);
} else {
sums[depth] += node->val;
counts[depth] += 1;
}
averageOfLevels(node->left, depth + 1, sums, counts);
averageOfLevels(node->right, depth + 1, sums, counts);
}
vector averageOfLevels(TreeNode* root) {
vector sums;
vector counts;
averageOfLevels(root, 0, sums, counts);
vector averages;
for (int i = 0; i < sums.size(); ++i) {
averages.push_back(static_cast(sums[i]) / counts[i]);
}
return averages;
}
5. 429 N叉树的层序遍历，易变体，递归懒得写了，下面是迭代，但思路都是该做左右的时候改成一个for loop做n个崽
vector> levelOrder(Node* root) {
vector> res;
queue myq;
Node* node;
if(root!=nullptr) myq.push(root);
while(!myq.empty()){
int size=myq.size();
vector vec;
for(int i=0;ival);
vector clist=node->children;
for(auto &ele:clist){
myq.push(ele);
}
}
res.push_back(vec);
}
return res;
} 6. 515.在每个树行中找最大值，和取每层最右像
我写的递归，但逻辑上讲不适合递归，虽然也是好写的
void order(int depth, vector &res, TreeNode* node){
if(node==nullptr) return;
// 当这一层还没有值时，将节点的值添加到结果中
if(res.size() == depth) res.push_back(node->val);
// 否则，更新这一层的最大值
else res[depth] = std::max(res[depth], node->val);
if(node->left!=nullptr) order(depth+1, res, node->left);
if(node->right!=nullptr) order(depth+1, res, node->right);
}
vector largestValues(TreeNode* root) {
vector res;
int depth=0;
order(depth, res, root);
return res;
} 代码随想录的迭代，就是基本迭代加了一点点取max
vector largestValues(TreeNode* root) {
queue que;
if (root != NULL) que.push(root);
vector 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;
} 7.8. 116.填充每个节点的下一个右侧节点指针，117 II 两题没差
这个不完全算简单变体，我做的时候遇到点麻烦：原来是这么写的
修改正确后：
Node* connect(Node* root) {
queue myq;
Node* node;
Node* prev=nullptr;
if(root!=nullptr) myq.push(root);
while(!myq.empty()){
int size=myq.size();
for(int i=0;i0) prev->next=node;
if(node->left!=nullptr) myq.push(node->left);
if(node->right!=nullptr) myq.push(node->right);
prev=node;
}
node->next=nullptr;
}
return root;
} 这题也不适合递归做，所以没做递归
做深度，用recursion ，iteration都行，问题不大
9. 104 最大深度
递归我的
int get_depth(TreeNode* node){
if(node==nullptr) return 0;
int left_d=0; int right_d=0;
if(node->left!=nullptr) left_d=get_depth(node->left);
if(node->right!=nullptr) right_d=get_depth(node->right);
return std::max(left_d,right_d)+1;
}
int maxDepth(TreeNode* root) {
return get_depth(root);
}void order(int depth, TreeNode * node, int &max){
if(node==nullptr) return;
max=std::max(max,depth);
if(node->left!=nullptr) order(depth+1,node->left,max);
if(node->right!=nullptr) order(depth+1,node->right,max);
}
int maxDepth(TreeNode* root) {
int depth=1;
int max=0;
order(depth, root, max);
return max;
}递归简洁版
int maxDepth(TreeNode* root) {
if(root == nullptr)
return 0;
else
return max(maxDepth(root->left), maxDepth(root->right)) + 1;
}
迭代（基础版迭代加个depth就行）
int maxDepth(TreeNode* root) {
if(root == nullptr)
return 0;
queue que;
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;
}
10. 111 最小深度
我的递归（基础款不用动脑改）
void order(TreeNode * node, int &min, int depth){
if(node==nullptr){
min=0;
return;
}
if(node->left==nullptr && node->right==nullptr){
min=std::min(min,depth);
}
if(node->left!=nullptr) order(node->left,min,depth+1);
if(node->right!=nullptr) order(node->right,min,depth+1);
}
int minDepth(TreeNode* root) {
int depth=1;
int min=INT_MAX;
order(root, min, depth );
return min;
}迭代gpt：走到第一个leaf node就可以结束啦！！会更有效率
int minDepth(TreeNode* root) {
if(root == nullptr)
return 0;
queue 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 == nullptr && node->right == nullptr)
return depth;
if(node->left) que.push(node->left);
if(node->right) que.push(node->right);
}
}
return depth;
}
226.翻转二叉树
方法包括：
dfs recursion：前后就是套模板加swap，中序需要两次left中间夹swap
void order(TreeNode * node){
if(node==nullptr) return;
//这是很特殊的中序，swap后左右换了所以再一次左
if(node->left!=nullptr) order(node->left);
swap(node->left,node->right);
if(node->left!=nullptr) order(node->left);
//前序和后续就是普通：like this
//if(node->left!=nullptr) order(node->left);
//if(node->right!=nullptr) order(node->right);
//swap(node->left,node->right);
}
TreeNode* invertTree(TreeNode* root) {
order(root);
return root;
}dfs iteration：直接套统一迭代的模板，加一句swap
TreeNode* invertTree(TreeNode* root) {
stack 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();
swap(node->left, node->right); // 节点处理逻辑
}
}
return root;
} bfs iteration：套层序遍历的模板
TreeNode* invertTree(TreeNode* root) {
queue que;
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();
swap(node->left, node->right);
if (node->left) que.push(node->left);
if (node->right) que.push(node->right);
}
}
return root;
} 101 对称二叉树2
第一次做想了好久
bool isSymmetric(TreeNode* root) {
queue myq1;
queue myq2;
if(root!=nullptr){
myq1.push(root);
myq2.push(root);
}
TreeNode *node1, *node2;
while(!(myq1.empty() ||myq2.empty())){
int size1=myq1.size();
int size2=myq2.size();
if(size1!=size2) return false;
for(int i=0;ival!=node2->val) return false;
if(node1->left!=nullptr){
if(node2->right==nullptr) return false;
myq1.push(node1->left);
}
if(node1->right!=nullptr){
if(node2->left==nullptr) return false;
myq1.push(node1->right);
}
if(node2->right!=nullptr){
if(node1->left==nullptr) return false;
myq2.push(node2->right);
}
if(node2->left!=nullptr){
if(node1->right==nullptr) return false;
myq2.push(node2->left);
}
}
}
if(!(myq1.empty()&&myq2.empty())) return false;
return true;
} 自己想的过于复杂，参考答案很简单的：
关键是：return compare(left->left,right->right)&&compare(left->right,right->left);
bool compare(TreeNode* left, TreeNode* right){
if(left==nullptr && right==nullptr) return true;
if(left==nullptr) return false;
if(right==nullptr) return false;
if(left->val!=right->val) return false;
return compare(left->left,right->right)&&compare(left->right,right->left);
}
bool isSymmetric(TreeNode* root) {
if(root==nullptr) return true;
return compare(root->left,root->right);
}