层序遍历
文档讲解:代码随想录
视频讲解:讲透二叉树的层序遍历 | 广度优先搜索 | LeetCode:102.二叉树的层序遍历_哔哩哔哩_bilibili
状态:通过
非递归法代码实现:
class Solution{
public:
vector<vector<int>> levelOrder(TreeNode* root){
queue<TreeNode*> que;
if(root != NULL){
que.push(root);
}
vector<vector<int>> result;
while(!que.empty()){
vector<int> vec;
int size = que.size();
for(int i = 0; i < size; i++){
TreeNode* node = que.front();
vec.push_back(node->val);
que.pop();
if(node->left) que.push(node->left);
if(node->right) que.push(node->right);
}
result.push_back(vec);
}
return result;
}
};
226.翻转二叉树
题目链接:. - 力扣(LeetCode)
文档讲解:代码随想录
视频讲解:听说一位巨佬面Google被拒了,因为没写出翻转二叉树 | LeetCode:226.翻转二叉树_哔哩哔哩_bilibili
状态:未通过
递归写法:
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;
}
};
迭代法:
class Solution {
public:
TreeNode* invertTree(TreeNode* root) {
if(root == NULL){
return root;
}
stack<TreeNode*> st;
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) {
if(root == NULL){
return root;
}
queue<TreeNode*> que;
que.push(root);
while(!que.empty()){
int size = que.size();
while(size--){
TreeNode* node = que.front();
que.pop();
swap(node->left, node->right);
if(node->left) que.push(node->left);
if(node->right) que.push(node->right);
}
}
return root;
}
};
101.对称二叉树
题目链接:. - 力扣(LeetCode)
文档讲解:代码随想录
视频讲解:新学期要从学习二叉树开始! | LeetCode:101. 对称二叉树_哔哩哔哩_bilibili
状态:未通过
解题思路:需要使用后续遍历的方法,先判断左右子树是否对称,然后根据子树的对称结果再进一步判断整个树是否对称。
递归写法代码实现:
class Solution {
public:
bool compare(TreeNode* left, TreeNode* right){
if(left == NULL && right != NULL) return false;
else if(left != NULL && right == NULL) return false;
else if(left == NULL && right == NULL) return true;
else if(left->val != right->val) return false;
bool out = compare(left->left, right->right);
bool in = compare(left->right, right->left);
return out && in;
}
bool isSymmetric(TreeNode* root) {
if(root == NULL) return true;
bool isSym = compare(root->left, root->right);
return isSym;
}
};
非递归写法代码实现(队列):
class Solution {
public:
bool isSymmetric(TreeNode* root) {
if(root == NULL) return true;
queue<TreeNode*> que;
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 && !right) continue;
if(!left || !right || left->val != right->val) return false;
que.push(left->left);
que.push(right->right);
que.push(left->right);
que.push(right->left);
}
return true;
}
};
非递归写法代码实现(栈):
class Solution {
public:
bool isSymmetric(TreeNode* root) {
if(root == NULL) return true;
stack<TreeNode*> st;
st.push(root->left);
st.push(root->right);
while(!st.empty()){
TreeNode* left = st.top();
st.pop();
TreeNode* right = st.top();
st.pop();
if(!left && !right) continue;
if(!left || !right || left->val != right->val) return false;
st.push(left->left);
st.push(right->right);
st.push(left->right);
st.push(right->left);
}
return true;
}
};