力扣题目链接
class Solution {
public:
int min=INT_MAX;
TreeNode* pre=NULL;
void inorder(TreeNode* root){
if(root==NULL) return;
inorder(root->left);
if(pre!=NULL&&root->val-pre->valval-pre->val;
}
pre=root;
inorder(root->right);
}
int getMinimumDifference(TreeNode* root) {
inorder(root);
return min;
}
};
O(n)
O(n)
class Solution {
public:
int getMinimumDifference(TreeNode* root) {
stack st;
TreeNode* p=root;
TreeNode* pre=NULL;
int min=INT_MAX;
while(p||!st.empty()){
if(p){
st.push(p);
p=p->left;
}
else{
p=st.top();st.pop();
if(pre!=NULL&&p->val-pre->valval-pre->val;
}
pre=p;
p=p->right;
}
}
return min;
}
};
O(n)
O(n)
力扣题目链接
class Solution {
public:
void inorder(TreeNode* root,unordered_map& map){
if(root==NULL) return ;
inorder(root->left,map);
map[root->val]++;
inorder(root->right,map);
}
bool static cmp(const pair& a, const pair& b){
return a.second>b.second;
}
vector findMode(TreeNode* root) {
unordered_map map;
//遍历树,用map统计出现频次
inorder(root,map);
//将map转成vetcor数组
vector> vec(map.begin(),map.end());
//给频率排序
sort(vec.begin(),vec.end(),cmp);
vector res;
//获取频次最高的元素
for(int i=0;i
class Solution {
public:
unordered_map map;
TreeNode* pre=NULL;
void inorder(TreeNode* root,vector &res){
if(root==NULL) return;
inorder(root->left,res);
if(pre!=NULL&&pre->val==root->val){
map[pre->val]++;
}
pre=root;
res.push_back(root->val);
inorder(root->right,res);
}
vector findMode(TreeNode* root) {
int max=0;
vector maxIndex;
vector res;
inorder(root,res);
bool flag=false;
for(auto it=map.begin();it!=map.end();it++){
if(it->second>max){
max=it->second;
}
flag=true;
}
for(auto it=map.begin();it!=map.end();it++){
if(it->second==max){
maxIndex.push_back(it->first);
}
}
if(flag==false) return res;
return maxIndex;
}
};
class Solution {
public:
int count=0,maxCount=0; //当前节点出现频率,最大频率
TreeNode *pre=NULL;
vector res; //存放结果集
void traversal(TreeNode* root){
if(root==NULL) return;
traversal(root->left); //左
if(pre==NULL) count=1; //第一个节点
else if(pre->val==root->val) count++; //与前一个结点数值相同
else count=1; //与前一个结点数值不同
pre=root;//更新结点
if(count==maxCount){ //当前节点出现频率与最大值相同,放入结果集
res.push_back(root->val);
}
if(count>maxCount){ //当前节点
maxCount=count;
res.clear();
res.push_back(root->val);
}
traversal(root->right);
}
vector findMode(TreeNode* root) {
traversal(root);
return res;
}
};
O(n)
O(n)
力扣题目链接
如果递归函数有返回值,区分要搜索一条边,还是搜索整个树
搜索一条边的写法:
if (递归函数(root->left)) return ;
if (递归函数(root->right)) return ;
搜索整个树写法:
left = 递归函数(root->left); // 左
right = 递归函数(root->right); // 右
left与right的逻辑处理; // 中
class Solution {
public:
TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
if(root==NULL||root==p||root==q) return root;
//后序遍历
TreeNode* left=lowestCommonAncestor(root->left,p,q);
TreeNode* right=lowestCommonAncestor(root->right,p,q);
//如果左子树为空,返回右子树;如果右子树为空,返回左子树;如果都为空,返回空
if(left==NULL) return right;
if(right==NULL) return left;
//如果都不为空,返回根结点;
return root;
}
};
O(n)
O(n)
class Solution {
public:
TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
TreeNode* cur=root;
TreeNode* r=NULL;
vector st,s;
bool fp1=false,fp2=false;
while(cur||!st.empty()){
if(cur){
st.push_back(cur);
cur=cur->left;
}
else{
cur=st[st.size()-1];
if(cur->right&&cur->right!=r){ //如果右子树不为空且未被访问过
cur=cur->right;
}
else{
if(cur==p) fp1=true; //如果p被访问,置fp1=true
if(cur==q) fp2=true; //如果q被访问,置fp2=true
//当p被访问,q未被访问||当q被访问,p未被访问
//(当第一个结点被访问时,将其祖先元素存储到辅助数组中)
if(cur==p&&fp1&&!fp2||cur==q&&!fp1&&fp2){
for(int i=0;i=0;i--){
for(int j=s.size()-1;j>=0;j--){
if(st[i]==s[j]){
return st[i];
}
}
}
}
st.pop_back();
r=cur;
cur=NULL;
}
}
}
return NULL;
}
};
O(n)
O(n)