我这个小垃圾,按照模板做,感觉真不错 举一反三,天天都有着感觉就好,随缘刷题,哪天想起就哪天刷,真的太容易忘记了。
leetcode 102 二叉树的层序遍历
class Solution {
public:
vector<vector<int>> levelOrder(TreeNode* root) {
queue<TreeNode*>que;
if(root!=nullptr)
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);
}
return result;
}
};
leetcode 107 二叉树的层序遍历2
class Solution {
public:
vector<vector<int>> levelOrderBottom(TreeNode* root) {
queue<TreeNode*>que;
if(root!=nullptr)
que.push(root);
vector<vector<int>>result;//结果数组
while(!que.empty())
{
vector<int>vec;
int size=que.size();//因为que的size是不断变化的
for(int i=0;i<size;++i)
{
//层序遍历,我们先定义一个指针,指向que的头
TreeNode*node=que.front();
//头节点出队列
que.pop();
//将头节点的值存入vec
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翻转
reverse(result.begin(),result.end());
return result;
}
};
leetcode 199 二叉树的右视图
class Solution {
public:
vector<int> rightSideView(TreeNode* root) {
//使用层序遍历,右侧的元素就是最后一个元素,所以我们只需要再基础的层序遍历上判断,这是否是这一层的最后一个元素,将他放入结果数组
queue<TreeNode*>que;
if(root!=nullptr)
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);
//将左右孩子入队列
if(node->left)
que.push(node->left);
if(node->right)
que.push(node->right);
}
}
return result;
}
leetcode 637 二叉树的层平均值
class Solution {
public:
vector<double> averageOfLevels(TreeNode* root) {
queue<TreeNode*>que;
if(root!=nullptr)
que.push(root);
vector<double>result;
while(!que.empty())
{
double sum=0;
int size=que.size();
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数组
result.push_back(sum/size);
}
return result;
}
};
leetcode 429 n叉树的层序遍历
class Solution {
public:
vector<vector<int>> levelOrder(Node* root) {
//n叉树,说明可以不止2个孩子,可以多个孩子,我们只要增加一个for循环即可
queue<Node*>que;
//判断头节点是否存在
if(root!=nullptr)
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);
//因为n叉树,所以右n个孩子,所以我们不能用二叉树的模板来做了
for(int i=0;i<node->children.size();++i)
{
//将每个孩子入队列
if(node->children[i])
que.push(node->children[i]);
}
}
result.push_back(vec);
}
return result;
}
leetcode 515 在每个树行中找最大值
class Solution {
public:
vector<int> largestValues(TreeNode* root) {
//树行 层序遍历,比较左右孩子的大小,入数组
queue<TreeNode*>que;
if(root!=nullptr)
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;
}
};
leetcode 116 填充每个节点的下一个右侧点指针
class Solution {
public:
Node* connect(Node* root) {
queue<Node*>que;
if(root!=NULL)
que.push(root);
while(!que.empty())
{
int size=que.size();
Node* nodepro=NULL;
Node* node=NULL;
//声明结果数组
vector<int>result;
for(int i=0;i<size;++i)
{
//记录头节点
if(i==0)
{
nodepro=que.front();
que.pop();
node=nodepro;
}
else
{
node=que.front();
que.pop();
nodepro->next=node;//本层前一个结点next指向本结点
nodepro=nodepro->next;
}
if(node->left)
que.push(node->left);
if(node->right)
que.push(node->right);
}
nodepro->next=NULL;
}
return root;
}
};
leetcode117 填充每个节点的下一个右侧点指针2 代码没有变
class Solution {
public:
Node* connect(Node* root) {
queue<Node*>que;
if(root!=NULL)
que.push(root);
while(!que.empty())
{
Node*nodepro=NULL;
Node*node=NULL;
int size=que.size();
for(int i=0;i<size;++i)
{
if(i==0)
{
nodepro=que.front();
que.pop();
node=nodepro;
}
else
{
node=que.front();
que.pop();
//将nodepro指向这个
nodepro->next=node;
nodepro=node;
}
if(node->left)
que.push(node->left);
if(node->right)
que.push(node->right);
}
nodepro->next=NULL;
}
return root;
}
};
leetcode 104 二叉树的最大深度
class Solution {
public:
int maxDepth(TreeNode* root) {
queue<TreeNode*>que;
if(root!=nullptr)
que.push(root);
//定义一个变量记录深度
int deepth=0;
while(!que.empty())
{
int size=que.size();
deepth++;
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 deepth;
}
};
leetcode111 二叉树的最小深度
class Solution {
public:
int minDepth(TreeNode* root) {
queue<TreeNode*>que;
if(root!=nullptr)
que.push(root);
//定义一个变量记录深度
int deepth=0;
while(!que.empty())
{
int size=que.size();
deepth++;
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)//计算最小深度,找到没有左右孩子的,直接break
return deepth;
}
}
return deepth;
}
};