代码随想录算法训练营第十二天
226.翻转二叉树
//递归遍历(前序)
class Solution {
public:
void traverser(TreeNode* node) {
if(node == nullptr) return;
swap(node->left, node->right);
traverser(node->left);
traverser(node->right);
}
TreeNode* invertTree(TreeNode* root) {
traverser(root);
return root;
}
};
//迭代遍历(前序)
class Solution {
public:
TreeNode* invertTree(TreeNode* root) {
stack<TreeNode*> st;
if(root != nullptr) st.push(root);
while(!st.empty()) {
TreeNode* node = st.top();
st.pop();
swap(node->left, node->right);
if(node->right) st.push(node->right);
if(node->left) st.push(node->left);
}
return root;
}
};
//层序遍历
class Solution {
public:
TreeNode* invertTree(TreeNode* root) {
queue<TreeNode*> que;
if(root == nullptr) return root;
que.push(root);
while(!que.empty()) {
TreeNode* node = que.front();
swap(node->left, node->right);
que.pop();
if(node->left) que.push(node->left);
if(node->right) que.push(node->right);
}
return root;
}
};
101. 对称二叉树
//递归法
class Solution {
public:
bool traverser(TreeNode* left, TreeNode* right) {
if(left == nullptr && right == nullptr) return true;
else if(left != nullptr && right == nullptr) {
return false;
}
else if(left == nullptr && right != nullptr) {
return false;
}
else if(left->val != right->val) return false;
bool outside = traverser(left->left, right->right);
bool inside = traverser(left->right, right->left);
return outside && inside;
}
bool isSymmetric(TreeNode* root) {
if(root == nullptr) return true;
return traverser(root->left, root->right);
}
};
//迭代法
class Solution {
public:
bool isSymmetric(TreeNode* root) {
queue<TreeNode*> que;
if(root != nullptr) {
que.push(root->left);
que.push(root->right);
}
while(!que.empty()) {
TreeNode* left = que.front();
que.pop();
TreeNode* right = que.front();
que.pop();
if(left == nullptr && right != nullptr) {
return false;
}
else if(left != nullptr && right == nullptr) {
return false;
}
else if(left == nullptr && right == nullptr) {
continue;
}
else if(left->val != right->val) {
return false;
}
que.push(left->left);
que.push(right->right);
que.push(left->right);
que.push(right->left);
}
return true;
}
};
104.二叉树的最大深度
心得
//递归法(后序)
class Solution {
public:
int getDepth(TreeNode* root) {
if(root == nullptr) return 0;
int left = getDepth(root->left);
int right = getDepth(root->right);
return 1 + max(left, right);
}
int maxDepth(TreeNode* root) {
return getDepth(root);
}
};
//迭代法
class Solution {
public:
int maxDepth(TreeNode* root) {
if(root == nullptr) return 0;
int max = 0;
queue<TreeNode*> que;
que.push(root);
while(!que.empty()) {
int size = que.size();
max += 1;
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 max;
}
};