代码随想录算法训练营第十五天 | 层序遍历、226. 翻转二叉树101. 对称二叉树
层序遍历
102. 二叉树的层序遍历
队列先进先出，符合一层一层遍历的逻辑，借助队列的特点，每当有元素弹出时，观察该节点是否有孩子节点，如果有则压入到队列中
class Solution {
public:
vector> levelOrder(TreeNode* root) {
vector> result;
queue queue;
if (root != nullptr) queue.push(root);
while (!queue.empty()) {
//用size存储队列长度，因为下面每次从队列中弹出元素后，队列长度发生变化
int size = queue.size();
vector temp; //把该层元素存储起来
for (int i = 0; i < size; i++) {
TreeNode* node = queue.front();
queue.pop();
temp.push_back(node->val);
if (node->left) queue.push(node->left);
if (node->right) queue.push(node->right);
}
result.push_back(temp);
}
return result;
}
}; 107. 二叉树的层序遍历 II
实现自底向上的遍历，在层序遍历的基础上，把每一层的值存到数组中，最后对数组执行reverse操作
class Solution {
public:
vector> levelOrderBottom(TreeNode* root) {
vector> result;
queue queue;
if (root != nullptr) queue.push(root);
while (!queue.empty()) {
//用size存储队列长度，因为下面每次从队列中弹出元素后，队列长度发生变化
int size = queue.size();
vector temp; //把该层元素存储起来
for (int i = 0; i < size; i++) {
TreeNode* node = queue.front();
queue.pop();
temp.push_back(node->val);
if (node->left) queue.push(node->left);
if (node->right) queue.push(node->right);
}
result.push_back(temp);
}
reverse(result.begin(), result.end()); //将结果反转
return result;
}
}; 199. 二叉树的右视图
层序遍历，当每一层遍历到最后一个节点时，注意对最后一个结点的特殊处理
class Solution {
public:
vector rightSideView(TreeNode* root) {
vector result;
queue queue;
if(root != nullptr) queue.push(root);
while (!queue.empty()) {
int size = queue.size();
while (size != 1) {
TreeNode* temp = queue.front();
queue.pop();
if (temp->left) queue.push(temp->left);
if (temp->right) queue.push(temp->right);
size--;
}
TreeNode* temp = queue.front();
queue.pop();
if (temp->left) queue.push(temp->left);
if (temp->right) queue.push(temp->right);
result.push_back(temp->val);
}
return result;
}
}; 637. 二叉树的层平均值
借助层序遍历，注意对精确度的把控
class Solution {
public:
vector averageOfLevels(TreeNode* root) {
vector result;
queue queue;
if (root != nullptr) queue.push(root);
while (!queue.empty()) {
double sum = 0;
int size = queue.size();
int length = size;
while (size != 0) {
TreeNode* tmp = queue.front();
queue.pop();
if (tmp->left) queue.push(tmp->left);
if (tmp->right) queue.push(tmp->right);
sum += tmp->val;
size--;
}
result.push_back(sum/length*1.00000);
}
return result;
}
}; 429. N 叉树的层序遍历
N叉树的层序遍历，注意C++中定义的孩子结点的数据结构，因为是vector，所以在知道长度时进行顺序遍历即可
class Solution {
public:
vector> levelOrder(Node* root) {
vector> result;
queue queue;
if (root != NULL) queue.push(root);
while (!queue.empty()) {
int size = queue.size();
vector vec;
for (int i = 0; i < size; i++) {
Node* temp = queue.front();
queue.pop();
vec.push_back(temp->val);
for (int j = 0; j < temp->children.size(); j++) {
if (temp->children[j]) queue.push(temp->children[j]);
}
}
result.push_back(vec);
}
return result;
}
}; 515. 在每个树行中找最大值
设置size记录每行的元素个数，结合层序遍历实现寻找到最大值
class Solution {
public:
vector largestValues(TreeNode* root) {
vector result;
queue queue;
if (root != nullptr) queue.push(root);
while (!queue.empty()) {
int max = INT_MIN;
int size = queue.size();
for (int i = 0; i < size; i++) {
TreeNode* tmp = queue.front();
queue.pop();
max = max > tmp->val ? max : tmp->val;
if (tmp->left) queue.push(tmp->left);
if (tmp->right) queue.push(tmp->right);
}
result.push_back(max);
}
return result;
}
}; 104. 二叉树的最大深度
与最小深度不同的是，要遍历到最底层
class Solution {
public:
int maxDepth(TreeNode* root) {
int deepth = 0;
queue queue;
if (root != nullptr) queue.push(root);
while (!queue.empty()) {
deepth++;
int size = queue.size();
for (int i = 0; i < size; i++) {
TreeNode* tmp = queue.front();
queue.pop();
if (tmp->left) queue.push(tmp->left);
if (tmp->right) queue.push(tmp->right);
}
}
return deepth;
}
}; 111. 二叉树的最小深度
当层序遍历到出现左右节点为空时，即可返回深度
class Solution {
public:
int minDepth(TreeNode* root) {
int deepth = 0;
queue queue;
if (root != nullptr) queue.push(root);
while (!queue.empty()) {
int size = queue.size();
deepth++;
for (int i = 0; i < size; i++) {
TreeNode* tmp = queue.front();
queue.pop();
if (tmp->left) queue.push(tmp->left);
if (tmp->right) queue.push(tmp->right);
if (!tmp->left && !tmp->right) return deepth;
}
}
return deepth;
}
}; 226. 翻转二叉树
本体我的做法是采用递归前序遍历的实现了二叉树的反转，对于反转时刻记住C++自带的reverse函数
递归三部曲：1、确定递归函数的参数和返回值：
参数就是要传入节点的指针，不需要其他参数了，通常此时定下来主要参数，如果在写递归的逻辑中发现还需要其他参数的时候，随时补充。
返回值的话其实也不需要，但是题目中给出的要返回root节点的指针，可以直接使用题目定义好的函数，所以就函数的返回类型为TreeNode*
TreeNode* invertTree(TreeNode* root)2、确定终止条件：当前节点为空的时候，就返回
if (root == nullptr) return root;3、确定单层递归的逻辑：因为是先前序遍历，所以先进行交换左右孩子节点，然后反转左子树，反转右子树
swap(root->left, root->right);
invertTree(root->left);
invertTree(root->right);最终代码如下：
class Solution {
public:
TreeNode* invertTree(TreeNode* root) {
if (root == nullptr) return root;
swap(root->left, root->right);
invertTree(root->left);
invertTree(root->right);
return root;
}
};101. 对称二叉树
本题最初的思路是借助层序遍历队列，把每层的节点都存入队列中，然后借助for循环遍历，i=0,j=size-1，但是网上并没有发现可以获取队列第i个位置的方法，所以放弃了
卡哥给的思路是每次把两个对称位置的节点存储到队列中，然后从队列中弹出这两个节点，对这两个节点的情况进行分析，其中当两个节点都为空时依然是成立的，开始时忽略了这种情况的考虑
代码如下：
class Solution {
public:
bool isSymmetric(TreeNode* root) {
queue queue;
if (root == nullptr) {
return true;
} else {
queue.push(root->left);
queue.push(root->right);
}
while (!queue.empty()) {
TreeNode* tmp1 = queue.front();
queue.pop();
TreeNode* tmp2 = queue.front();
queue.pop();
// 左节点为空、右节点为空，此时依然是对称的
if (!tmp1 && !tmp2) {
continue;
}
// 左右一个节点不为空，或者都不为空但数值不相同，返回false
if (!tmp1 || !tmp2 || tmp1->val != tmp2->val) {
return false;
}
queue.push(tmp1->left);
queue.push(tmp2->right);
queue.push(tmp1->right);
queue.push(tmp2->left);
}
return true;
}
};