Leetcode - 226翻转二叉树
这道题比较简单我第一遍是那层次遍历的迭代法做的也就是bfs做的:
/**
* 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:
TreeNode* invertTree(TreeNode* root) {
queue<TreeNode*> que;
if(root != NULL){
que.push(root);
}
while(!que.empty()){
int size = que.size();
for(int i = 0; i < size; i++){
TreeNode* node = que.front();
que.pop();
if(node != NULL){
TreeNode* x = node -> left;
node -> left = node -> right;
node -> right = x;
if(node -> left) que.push(node -> left);
if(node -> right) que.push(node -> right);
}
}
}
return root;
}
};
递归法:
/**
* 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:
TreeNode* invertTree(TreeNode* root) {
if(root == NULL) return root;
swap(root -> left, root -> right);
invertTree(root -> left);
invertTree(root -> right);
return root;
}
};
dfs:
感觉跟bfs基本一样:
/**
* 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:
TreeNode* invertTree(TreeNode* root) {
stack<TreeNode*> st;
if(root != NULL){
st.push(root);
}
while(!st.empty()){
TreeNode* node = st.top();
st.pop();
swap(node -> right, node -> left);
if(node -> left) st.push(node -> left);
if(node -> right) st.push(node -> right);
}
return root;
}
};
Leetcode-101 对称二叉树:
这道题先去看了视频再来做的,用的递归的方法:
先定义一个比较函数,首先判断左右两字树的节点是否相等以及判空:
/**
* 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:
bool compare(TreeNode* left, TreeNode* right){
if(left == NULL && right == NULL) return true;
else if(left == NULL && right != NULL) return false;
else if(left != NULL && right == NULL) return false;
else if(left -> val != right -> val) return false;
bool outside = compare(right -> right, left -> left);
bool inside = compare(right -> left, left -> right);
bool res = outside && inside;
return res;
}
bool isSymmetric(TreeNode* root) {
if(root == NULL) return true;
return compare(root -> left, root -> right);
}
};
下面使用队列来实现的跟上面的基本一样
class Solution {
public:
bool isSymmetric(TreeNode* root) {
if (root == nullptr) {
return true;
}
std::queue<TreeNode*> que;
que.push(root->left);
que.push(root->right);
while (!que.empty()) {
TreeNode* leftNode = que.front();
que.pop();
TreeNode* rightNode = que.front();
que.pop();
if (leftNode == nullptr && rightNode == nullptr) {
continue;
}
if (leftNode == nullptr || rightNode == nullptr || leftNode->val != rightNode->val) {
return false;
}
que.push(leftNode->left);
que.push(rightNode->right);
que.push(leftNode->right);
que.push(rightNode->left);
}
return true;
}
};
学了一下午加一晚上二叉树了,人都要分叉了.............
2024/3/10 20:36
-------------------------------magixx