一、反转二叉树
递归法,类似直接遍历。swap的位置就是“中”的位置,inverval(cur->left)就是“左”的位置。因为swap是针对父节点的操作,所以可以吧swap的位置等效替换成“中”的位置。
/**
* 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:
void interval(TreeNode*&root){
TreeNode*cur=root;
if(root==nullptr)return;
swap(cur->left,cur->right);
interval(cur->left);
interval(cur->right);
}
TreeNode* invertTree(TreeNode* root) {
interval(root);
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:
bool compare(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!=nullptr&&right!=nullptr&&left->val!=right->val)return false;
else{
bool outside=compare(left->left,right->right);
bool inside=compare(left->right,right->left);
bool result=outside&&inside;
return result;
}
}
bool isSymmetric(TreeNode* root) {
if(root==nullptr)return true;
return compare(root->left,root->right);
}
};
三、二叉树的最大深度
记录一下这个令人感动的时刻!!!T.T第一次自己AC了二叉树这里的题,虽然不是用递归,用层序遍历做的
/**
* 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:
int maxDepth(TreeNode* root) {
if(root==nullptr)return 0;
int returnsize=0;
queue<TreeNode*>que;
que.push(root);
while(!que.empty()){
int size=que.size();
for(int i=0;i<size;i++){
TreeNode*temp=que.front();
if(temp->left)que.push(temp->left);
if(temp->right)que.push(temp->right);
que.pop();
}
returnsize++;
}
return returnsize;
}
};
递归方法:
深度和高度一样都是采用后序遍历,在每一层节点中,先去探索左子树的最大深度,再探索右子树的最大深度,让二者比较取一个更大值+1(+1代表遍历过了一层)
/**
* 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:
int maxDepth(TreeNode* root) {
TreeNode*node=root;
if(node==nullptr)return 0;
int leftdepth=maxDepth(node->left);
int rightdepth=maxDepth(node->right);
int depth=1+max(leftdepth,rightdepth);
return depth;
}
};
四、最小深度
这里的特殊处理有点懵,也就是说,求最小深度是遇到了nullptr要给它特殊标记,左侧如果为空,右侧依然需要算。
递归写法: 后序遍历
/**
* 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:
int minDepth(TreeNode* root) {
int result=0;
TreeNode*node=root;
if(node==nullptr)return 0;
int leftmindepth=minDepth(node->left);
int rightmindepth=minDepth(node->right);
if(node->left==nullptr&&node->right!=nullptr){
return 1+rightmindepth;
}
if(node->left!=nullptr&&node->right==nullptr){
return 1+leftmindepth;
}
int minresult=1+min(leftmindepth,rightmindepth);
return minresult;
}
};