102. 二叉树的层序遍历
/**
* 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) {
vector<vector<int>> result;
queue<TreeNode*> que;
if(root == nullptr) return result;
que.push(root);
while(!que.empty()){
//size一定要在这里定义,这个size代表现在队列中这一层的节点总数
int size = que.size();
vector<int> vec;
for(int i = 0; i < size; i++){
TreeNode* tmp = que.front();
que.pop();
vec.push_back(tmp->val);
if(tmp->left) que.push(tmp->left);
if(tmp->right) que.push(tmp->right);
}
result.push_back(vec);
}
return result;
}
};
107. 二叉树的层序遍历 II
/**
* 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) {
vector<vector<int>> result;
queue<TreeNode*> que;
if(root == nullptr) return result;
que.push(root);
while(!que.empty()){
vector<int> vec;
int size = que.size();
for(int i = 0; i < size; i++){
TreeNode* tmp = que.front();
que.pop();
vec.push_back(tmp->val);
if(tmp->left) que.push(tmp->left);
if(tmp->right) que.push(tmp->right);
}
result.push_back(vec);
}
reverse(result.begin(), result.end());
return result;
}
};
199. 二叉树的右视图
/**
* 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<int> rightSideView(TreeNode* root) {
vector<int> result;
queue<TreeNode*> que;
if(root == nullptr) return result;
que.push(root);
while(!que.empty()){
int size = que.size();
for(int i = 0; i < size; i++){
TreeNode* tmp = que.front();
que.pop();
if(i == size-1){
result.push_back(tmp->val);
}
if(tmp->left) que.push(tmp->left);
if(tmp->right) que.push(tmp->right);
}
}
return result;
}
};
637. 二叉树的层平均值
/**
* 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) {
vector<double> result;
queue<TreeNode*> que;
if(root == nullptr) return result;
que.push(root);
while(!que.empty()){
double ans = 0;
double size = que.size();
for(int i = 0; i < size; i++){
TreeNode* tmp = que.front();
que.pop();
ans+=tmp->val;
if(tmp->left) que.push(tmp->left);
if(tmp->right) que.push(tmp->right);
}
result.push_back(ans/size);
}
return result;
}
};
429. 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) {
//此题还是二叉树的层序遍历,只是把二叉树变成了多叉树
vector<vector<int>> result;
queue<Node*> que;
if(root == nullptr) return result;
que.push(root);
while(!que.empty()){
vector<int> vec;
int size = que.size();
for(int i = 0; i < size; i++){
Node* tmp = que.front();
que.pop();
vec.push_back(tmp->val);
//唯一有区别的就是这里
for(int j = 0; j < tmp->children.size(); j++){
if(tmp->children[j]!=nullptr) que.push(tmp->children[j]);
}
}
result.push_back(vec);
}
return result;
}
};
515. 在每个树行中找最大值
/**
* 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<int> largestValues(TreeNode* root) {
//老规矩,还是二叉树的层序遍历
vector<int> result;
queue<TreeNode*> que;
if(root == nullptr) return result;
que.push(root);
while(!que.empty()){
int ans = INT_MIN;
int size = que.size();
for(int i = 0; i < size; i++){
TreeNode* tmp = que.front();
que.pop();
ans = max(ans, tmp->val);
if(tmp->left) que.push(tmp->left);
if(tmp->right) que.push(tmp->right);
}
result.push_back(ans);
}
return result;
}
};
116. 填充每个节点的下一个右侧节点指针
/*
// 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 == nullptr) return root;
que.push(root);
Node* pre;
Node* cur;
while(!que.empty()){
int size = que.size();
for(int i = 0; i < size; i++){
if(i == 0){
cur = que.front();
que.pop();
pre = cur;
}
else{
cur = que.front();
que.pop();
pre->next = cur;
pre = pre->next;
}
if(cur->left) que.push(cur->left);
if(cur->right) que.push(cur->right);
}
cur->next = nullptr;//把每行的最后一个元素设置为nullptr
}
return root;
}
};
104.二叉树的最大深度
/**
* 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;
int depth = 0;
if(root == nullptr) return depth;
que.push(root);
while(!que.empty()){
int size = que.size();
for(int i = 0; i < size; i++){
TreeNode* tmp = que.front();
que.pop();
if(tmp->left) que.push(tmp->left);
if(tmp->right) que.push(tmp->right);
}
depth++;
}
return depth;
}
};
111. 二叉树的最小深度
求一棵树的最小深度判断条件是,当一个点率先没有左右节点的时候,直接返回
/**
* 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) {
//最小深度应该是哪个点最先左右都没有节点了,就返回然后记录深度
int depth = 0;
queue<TreeNode*> que;
if(root == nullptr) return depth;
que.push(root);
while(!que.empty()){
int size = que.size();
depth++;
for(int i = 0; i < size; i++){
TreeNode* tmp = que.front();
que.pop();
if(!tmp->left && !tmp->right) return depth;
if(tmp->left) que.push(tmp->left);
if(tmp->right) que.push(tmp->right);
}
}
return depth;
}
};