代码随想录算法训练营第十五天 |102. 二叉树的层序遍历 、107. 二叉树的层序遍历 II、199. 二叉树的右视图、637. 二叉树的层平均值、429. N 叉树的层序遍历、515. 在每个树行中找最大值、116. 填充每个节点的下一个右侧节点指针、117. 填充每个节点的下一个右侧节点指针 II、104. 二叉树的最大深度、111. 二叉树的最小深度、226. 翻转二叉树、101.对称二叉树 2
102. 二叉树的层序遍历
题目
解法
- 层序遍历
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;
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;
}
};
2.递归
class Solution {
public:
void order(TreeNode* cur, vector<vector<int>>& result, int depth) {
if(cur == nullptr) return; // 结束递归
if(result.size() == depth) 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;
order(root, result, 0);
return result;
}
};
107. 二叉树的层序遍历 II
题目
解法
- 层序遍历
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()) {
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);
}
reverse(result.begin(),result.end());
return result;
}
};
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;
}
};
637. 二叉树的层平均值
题目
解法
class Solution {
public:
vector<double> averageOfLevels(TreeNode* root) {
queue<TreeNode*> que;
if(root != nullptr) que.push(root);
vector<double> result;
while(!que.empty()) {
int size = que.size();
double sum = 0.0; // 需要双浮点数型，int会整除
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 叉树的层序遍历
题目
解法
class Solution {
public:
vector<vector<int>> levelOrder(Node* root) {
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);
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. 在每个树行中找最大值
题目
解法
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 MAX = INT_MIN;
for(int i = 0; i < size; i++) {
TreeNode* node = que.front();
que.pop();
MAX = node->val > MAX ? node->val : MAX ;
if(node->left) que.push(node->left);
if(node->right) que.push(node->right);
}
result.push_back(MAX);
}
return result;
}
};
116. 填充每个节点的下一个右侧节点指针、117. 填充每个节点的下一个右侧节点指针 II
题目
解法
class Solution {
public:
Node* connect(Node* root) {
queue<Node*> que;
if(root != nullptr) que.push(root);
Node* node;
Node* nodePre;
while(!que.empty()) {
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 = node;
}
if(node->left) que.push(node->left);
if(node->right) que.push(node->right);
}
nodePre->next = nullptr;
}
return root;
}
};
104. 二叉树的最大深度
题目
解法
class Solution {
public:
int maxDepth(TreeNode* root) {
queue<TreeNode*> que;
if(root != nullptr) 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) que.push(node->left);
if(node->right) que.push(node->right);
}
}
return depth;
}
};
- 后序遍历：递归
class Solution {
public:
int order(TreeNode* root) {
if(root == NULL) return 0;
int rightDepth = order(root->right);
int leftDepth = order(root->left);
int depth = 1 + max(rightDepth, leftDepth);
return depth;
}
int maxDepth(TreeNode* root) {
return order(root);
}
};
111. 二叉树的最小深度
题目
解法
- 迭代：层序遍历
class Solution {
public:
int minDepth(TreeNode* root) {
queue<TreeNode*> que;
if(root != nullptr) 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) que.push(node->left);
if(node->right) que.push(node->right);
if(!node->left && !node->right) return depth;
}
}
return depth;
}
};
2.递归：后序遍历
class Solution {
public:
int getDepth(TreeNode* root) {
if(root == nullptr) return 0;
int leftDepth = getDepth(root->left); // 向左递归
int rightDpeth = getDepth(root->right);// 向右递归
if(root->left != nullptr && root->right == nullptr){ //如果左边结束了，保存值并返回
return 1 + leftDepth;
}
if(root->left == nullptr && root->right != nullptr){ // 如果右边结束了，保存并返回
return 1 + rightDpeth;
}
return 1 + min(leftDepth, rightDpeth);
}
int minDepth(TreeNode* root) {
return getDepth(root);
}
};
226. 翻转二叉树
题目
解法
- 递归法
class Solution {
public:
TreeNode* invertTree(TreeNode* root) {
if(root == nullptr) return root;
stack<TreeNode*> sta;
sta.push(root);
while(!sta.empty()) {
TreeNode* node = sta.top();
sta.pop();
swap(node->left, node->right);
if(node->right) sta.push(node->right);
if(node->left) sta.push(node->left);
}
return root;
}
};
101.对称二叉树 2
题目
解法
class Solution {
public:
bool compare(TreeNode* left, TreeNode* right) {
if (left == nullptr && right != nullptr ) return false;
else if (left != nullptr && right == nullptr) return false;
else if (left == nullptr && right == nullptr) return true;
else if (left->val != right->val) return false; //需要用else if 因为还有值相等的情况，接着递归
bool outside = compare(left->left, right->right);
bool inside = compare(left->right, right->left);
return inside && outside;
}
bool isSymmetric(TreeNode* root) {
if(root == nullptr) return true;
return compare(root->left, root->right);
}
};
感悟
今天题好多
521
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
