讲透二叉树的层序遍历 | 广度优先搜索 | LeetCode:102.二叉树的层序遍历_哔哩哔哩_bilibili
第一眼:不知道为什么很多学过的东西,知道学过但是想不出思路,所以我先打开卡哥的视频,然后自己写了一遍代码
/**
* 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) {
queue<TreeNode*>que;
vector<vector<int>> result;
if(root!=NULL)
que.push(root);
while(!que.empty())
{
int size=que.size();
vector<int> vec;
while(size--)
{
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;
}
};
107. 二叉树的层序遍历 II - 力扣(LeetCode)
跟上一题一样,最后翻转数组,注意翻转数组是reverse(res.begin(),res.end());
/**
* 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) {
queue<TreeNode*> que;
vector<vector<int>> res;
if(root!=NULL)
que.push(root);
while(!que.empty())
{
int size=que.size();
vector<int> vec;
while(size--)
{
TreeNode* node;
node=que.front();
que.pop();
vec.push_back(node->val);
if(node->left)
que.push(node->left);
if(node->right)
que.push(node->right);
}
res.push_back(vec);
}
reverse(res.begin(),res.end());
return res;
}
};
第一眼思路:只存储遍历过程中的右节点,但是只能通过一些案例,后来发现可能会出现右子树无节点,左子树还有节点,这种情况会漏掉:去网上参考了一些大佬的写法,发现是只将每一层的最后一个节点存储起来就好了。
剩下几题由于时间暂时不写啦,有时间补上。
补上如下:
将每一层综合用一个sum统计起来,然后除以size;
/**
* 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) {
queue<TreeNode*> que;
//vector<vector<int>> res;
vector<double> res;
if(root!=NULL)
que.push(root);
while(!que.empty())
{
int size=que.size();
int size1=size;
double sum=0;
while(size--)
{
TreeNode* node;
node=que.front();
que.pop();
sum+=node->val;
if(node->left)
que.push(node->left);
if(node->right)
que.push(node->right);
}
res.push_back(sum/size1);
}
return res;
}
};
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) {
queue<Node*> que;
vector<vector<int>> res;
if(root!=NULL)
que.push(root);
while(!que.empty())
{
int size=que.size();
vector<int> vec;
while(size--)
{
Node* node;
node=que.front();
que.pop();
vec.push_back(node->val);
for(int i=0;i<node->children.size();i++)//为N叉树,结点不为空就把此节点加入到队列里面去
{
if(node->children[i])
que.push(node->children[i]);
}
}
res.push_back(vec);
}
return res;
}
};
515. 在每个树行中找最大值 - 力扣(LeetCode)
先将初始化每一层的最大值为int-min;
116. 填充每个节点的下一个右侧节点指针 - 力扣(LeetCode)
/*
// Definition for a Node.
class Node {
public:
int val;
Node* left;
Node* right;
Node* next;
Node() : val(0), left(NULL), right(NULL), next(NULL) {}
Node(int _val) : val(_val), left(NULL), right(NULL), next(NULL) {}
Node(int _val, Node* _left, Node* _right, Node* _next)
: val(_val), left(_left), right(_right), next(_next) {}
};
*/
class Solution {
public:
Node* connect(Node* root) {
queue<Node*> que;
if(root!=NULL)
que.push(root);
while(!que.empty())
{
Node* nodepre;
Node* node;
int size=que.size();
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;
nodepre=nodepre->next;
}
if(node->left)
que.push(node->left);
if(node->right)
que.push(node->right);
}
nodepre->next=NULL;
}
return root;
}
};
117. 填充每个节点的下一个右侧节点指针 II - 力扣(LeetCode)
116的代码对本题同样适合
其实就是统计层数(内循环的次数)
/**
* 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) {
queue<TreeNode*> que;
if(root!=NULL)
que.push(root);
int depth=0;
while(!que.empty())
{
depth++;
TreeNode* cur;
int size=que.size();
while(size--)
{
cur=que.front();
que.pop();
if(cur->left)
que.push(cur->left);
if(cur->right)
que.push(cur->right);
}
}
return depth;
}
};
如果遍历到叶子节点(即他的左右节点都为null时),即为最小层数
/**
* 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) {
queue<TreeNode*> que;
if(root!=NULL)
que.push(root);
int depth=0;
while(!que.empty())
{
depth++;
TreeNode* cur;
int size=que.size();
while(size--)
{
cur=que.front();
que.pop();
if(cur->left)
que.push(cur->left);
if(cur->right)
que.push(cur->right);
if(cur->left==NULL&&cur->right==NULL)
return depth;
}
}
return depth;
}
};
听说一位巨佬面Google被拒了,因为没写出翻转二叉树 | LeetCode:226.翻转二叉树_哔哩哔哩_bilibili
/**
* 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:
TreeNode* invertTree(TreeNode* root) {
if(root==NULL)
return root;
swap(root->left,root->right);
invertTree(root->left);
invertTree(root->right);
return root;
}
};
新学期要从学习二叉树开始! | LeetCode:101. 对称二叉树_哔哩哔哩_bilibili
/**
* 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:
bool compare(TreeNode* left,TreeNode* right)
{
if(left==NULL&&right==NULL) return true;
else if(left==NULL&&right!=NULL) return false;
else if(left!=NULL&&right==NULL) return false;
else if(left->val!=right->val) return false;
bool out=compare(left->left,right->right);
bool in=compare(left->right,right->left);
bool result=out&∈
return result;
}
bool isSymmetric(TreeNode* root) {
if(root==NULL)
return true;
else
return compare(root->left,root->right);
}
};