Day21 二叉树part07 530.二叉搜索树的最小绝对差 501.二叉搜索树中的众数 236.二叉树的最近公共祖先

二叉树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;
    }
};