代码随想录算法训练营33期 第二十一天| 530.二叉搜索树的最小绝对差、501.二叉搜索树中的众数、236. 二叉树的最近公共祖先

530.二叉搜索树的最小绝对差

class Solution {
public:
    int result=INT_MAX;
    TreeNode* pre = nullptr;
    void traversal(TreeNode* cur){
        if (cur==nullptr) return ;
        traversal(cur->left);//中序遍历pre->val和cur->val的关系是递增的
        if (pre!=nullptr){
            if (abs(pre->val-cur->val)<result) result = abs(pre->val-cur->val);
        }
        pre = cur;
        traversal(cur->right);
    }
    int getMinimumDifference(TreeNode* root) {
        traversal(root);
        return result;
    }
};

这里有一个容易疑惑的点就是并没有显式的回溯。
对于下列二叉树，使用上述算法搜索最小绝对差。


实际上的参数。

501.二叉搜索树中的众数

// 自己写的
class Solution {
public:
    std::unordered_map<int, int> map;
    int maxCount = 0;
    void traversal(TreeNode* cur, std::unordered_map<int, int>& map){
        if (cur==nullptr) return ;
        traversal(cur->left, map);
        auto iter = map.find(cur->val);
        if (iter!=map.end()){//找到了已有元素
            iter->second++;
            if (iter->second>=maxCount){
                maxCount = iter->second;
            }
        }
        else{
            map.insert(pair<int, int>(cur->val, 1));
            if (maxCount == 0) {
                maxCount = 1; // 初始化 maxCount 为 1
        }
        }
        traversal(cur->right, map);
    }
    vector<int> findMode(TreeNode* root) {
        traversal(root, map);
        vector<int> mode;
        for (auto iter : map){
            if (iter.second == maxCount){
                mode.push_back(iter.first); 
            }
        }
        return mode;
    }
};

二叉树的最近公共祖先

class Solution {
public:
    TreeNode* father = new TreeNode(0);
    bool traversal(TreeNode* cur, TreeNode* p, TreeNode* q){
        if (cur==nullptr) return false;//到叶子节点都没找到那肯定返回false
        
        bool leftResult = traversal(cur->left, p, q);
        bool rightResult = traversal(cur->right, p, q);

        //如果p和q中的一个是另一个的祖先，那么该节点也是它们的最近公共祖先。
        //所以当(cur == p || cur == q)时也要将father=cur;
        //leftResult && rightResult判断的是p和q分别位于cur的左右两侧的情况。
        if ((cur == p || cur == q) || (leftResult && rightResult)) {
            father = cur;
            return true;
        }
        return cur == p || cur == q || leftResult || rightResult;;
    }
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        if (!traversal(root, p, q)) return nullptr;

        return father;
    }
};