二叉树part07 530.二叉搜索树的最小绝对差 501.二叉搜索树中的众数 236.二叉树的最近公共祖先
530. 二叉搜索树的最小绝对差
方法一:递归,利用搜索二叉树特性,中序递归排列,然后数组临近元素两两求差值
class Solution {
public:
vector<int> vec;
void traversal(TreeNode* node) //该方法将二叉树中序排列,输出到int数组
{
if(node==nullptr) return;
traversal(node->left);
vec.emplace_back(node->val);
traversal(node->right);
return;
}
int getMinimumDifference(TreeNode* root) {
traversal(root);
int min = INT_MAX;
for(int i = 1; i<vec.size();i++)
{
min = min<(vec[i]-vec[i-1]) ? min:vec[i]-vec[i-1]; //三元表达式,求最小值
}
return min;
}
};
方法二:递归
需要用一个pre节点记录一下cur节点的前一个节点。
如图:
class Solution {
public:
int result = INT_MAX;
TreeNode* pre = nullptr;
void traversal(TreeNode* cur)
{
if(cur==nullptr) return;
traversal(cur->left);
if(pre!=nullptr) result = min(result, cur->val-pre->val);
pre = cur;
traversal(cur->right);
}
int getMinimumDifference(TreeNode* root) {
traversal(root);
return result;
}
};
方法三:中序迭代法
class Solution {
public:
int getMinimumDifference(TreeNode* root) {
stack<TreeNode*> st;
int result = INT_MAX;
TreeNode* pre = nullptr;
TreeNode* cur = root;
while(cur!=nullptr||!st.empty()){
if(cur!=nullptr)
{
st.push(cur);
cur = cur->left;
}else
{
cur= st.top();
st.pop();
if(pre!=nullptr) result = result<cur->val - pre->val?result:cur->val - pre->val; //这里的pre是上一层迭代的cur
pre = cur;
cur = cur->right;
}
}
return result;
}
};
501. 二叉搜索树中的众数
方法一:常规二叉树
class Solution {
public:
void searchBST(TreeNode* root, unordered_map<int,int>& map)
{
if(root==nullptr) return;
map[root->val]++;
searchBST(root->left,map);
searchBST(root->right,map);
return;
}
bool static rule(pair<int,int>& a, pair<int,int>& b)
{
return a.second > b.second;
}
vector<int> findMode(TreeNode* root) {
unordered_map<int,int> map;
vector<int> result;
searchBST(root,map); //输出map数组,key是元素,value是元素出现次数
vector<pair<int,int>> vec(map.begin(),map.end());
sort(vec.begin(),vec.end(),rule); //从大到小排序
result.emplace_back(vec[0].first);
for(int i= 1; i<vec.size();i++)
{
if(vec[i].second == vec[0].second) result.emplace_back(vec[i].first); //一旦后面出现和result[0]相等的频率元素,添加进容器result
}
return result;
}
};
方法二:针对搜索二叉树进行递归
class Solution {
public:
int maxCount = 0; // 最大频率
int count = 0; // 统计频率
TreeNode* pre = NULL;
vector<int> result;
void traversal(TreeNode* cur)
{
if(cur==nullptr) return;
traversal(cur->left);
if(pre==nullptr) count = 1;
else if(pre->val==cur->val) count++;
else count =1;
pre = cur;
if (count == maxCount) { // 如果和最大值相同,放进result中
result.push_back(cur->val);
}
if (count > maxCount) { // 如果计数大于最大值频率
maxCount = count; // 更新最大频率
result.clear(); // 很关键的一步,不要忘记清空result,之前result里的元素都失效了
result.push_back(cur->val);
}
traversal(cur->right);
}
vector<int> findMode(TreeNode* root) {
//初始化变量
count = 0;
maxCount = 0;
pre = NULL; // 记录前一个节点
result.clear();
traversal(root);
return result;
}
};
方法三:迭代法
class Solution {
public:
TreeNode* pre = nullptr;
vector<int> result;
int count = 0;
int maxCount = 0;
void traversal(TreeNode* cur){
stack<TreeNode*> st;
while(cur!=nullptr||!st.empty()){
if(cur!=nullptr)
{
st.push(cur);
cur = cur->left;
}else{
cur= st.top();
st.pop();
if(pre==nullptr) count =1;
else if(pre!=nullptr&&pre->val==cur->val) count++;
else count = 1;
if(count == maxCount){
result.push_back(cur->val);
}
if(count>maxCount){
result.clear();
maxCount = count;
result.push_back(cur->val);
}
pre = cur;
cur = cur->right;
}
}
}
vector<int> findMode(TreeNode* root) {
TreeNode* pre = nullptr;
result.clear();
int count = 0;
int maxCount = 0;
traversal(root);
return result;
}
};
236. 二叉树的最近公共祖先
class Solution {
public:
TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
if(root ==nullptr) return root;
if(root==p||root==q) return root;
TreeNode* left = lowestCommonAncestor(root->left,q,p);//左
TreeNode* right = lowestCommonAncestor(root->right,q,p); //右
if(left!=nullptr&&right!=nullptr) return root; //中
else if(left==nullptr&&right!=nullptr) return right; //中
else if(left!=nullptr&&right==nullptr) return left; //中
else return nullptr;
}
};