代码随想录第二十一天|503.二叉搜索树的最小绝对差、501.二叉搜索树中的众数、二叉树的最近公共祖先

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

给你一棵所有节点为非负值的二叉搜索树，请你计算树中任意两节点的差的绝对值的最小值。

因为该树为二叉搜索树，利用中序遍历将其转换成一个递增数组。再计算两节点之差。

class Solution {
private:
    vector<int> result;
    void traversal(TreeNode* node) {
        if(node==nullptr) return;
        traversal(node->left);
        result.push_back(node->val);
        traversal(node->right);
    }
public:
    int getMinimumDifference(TreeNode* root) {
        result.clear();
        traversal(root);
        int min=INT_MAX;
        for(int j=1;j<result.size();j++) {
            if(result[j]-result[j-1]<min) min=result[j]-result[j-1];
        }
        return min;
    }
};

简化：在二叉搜索树中序遍历的过程中，也可以直接计算。

class Solution {
private:
    int min=INT_MAX;
    TreeNode* pre=nullptr;
    void traversal(TreeNode* cur) {
        if(cur==nullptr) return;
        traversal(cur->left);
        if(pre!=nullptr) {
            min=(cur->val-pre->val)<min?(cur->val-pre->val):min;
        }
        pre=cur;
        traversal(cur->right);
    }
public:
    int getMinimumDifference(TreeNode* root) {
        traversal(root);
        return min;
    }
};

501.二叉搜索树中的众数

给定一个有相同值的二叉搜索树（BST），找出 BST 中的所有众数（出现频率最高的元素）。

假定 BST 有如下定义：

• 结点左子树中所含结点的值小于等于当前结点的值
• 结点右子树中所含结点的值大于等于当前结点的值
• 左子树和右子树都是二叉搜索树

利用unorder_map将二叉树中的数值记录。（对任意二叉树都成立）

class Solution {
private:
    vector<int> result;
    void traversal(TreeNode* node) {
        if(node==nullptr) return;
        traversal(node->left);
        result.push_back(node->val);
        traversal(node->right);
    }
public:
    vector<int> findMode(TreeNode* root) {
        result.clear();
        traversal(root);
        //return result;
        unordered_map<int,int> mode;
        for(int i=0;i<result.size();i++) {
            mode[result[i]]++;
        }
        vector<pair<int, int>> vec(mode.begin(), mode.end());
        vector<int> result1;
        int times=-1;
        int locate=0;
        for(int i=0;i<vec.size();i++) {
            if(vec[i].second>times) {
                times=vec[i].second;
            }     
        }
        for(int i=0;i<vec.size();i++) {
            if(vec[i].second==times) result1.push_back(vec[i].first);
        }
        return result1;
    }
};

仅针对二叉搜索树：

class Solution {
private:
    int count=0;
    int maxCount=0;
    TreeNode* pre=nullptr;
    vector<int> result;
    void searchBST(TreeNode* cur) {
        if (cur==nullptr) return;
        searchBST(cur->left);
        if(pre==nullptr) count=1;
        else if(pre->val==cur->val) count++;
        else count=1;
        pre=cur;
        if(count==maxCount) result.push_back(cur->val);
        if(count>maxCount) {
            maxCount=count;
            result.clear();
            result.push_back(cur->val);
        }
        searchBST(cur->right);
    }

public:
    vector<int> findMode(TreeNode* root) {
        count=0;
        maxCount=0;
        TreeNode* pre=nullptr;
        result.clear();
        searchBST(root);
        return result;
    }
};

236.二叉树的最近公共祖先

给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。

百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”

class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        if(root==p||root==q||root==NULL) return root;
        TreeNode* left=lowestCommonAncestor(root->left,p,q);
        TreeNode* right=lowestCommonAncestor(root->right,p,q);
        if(left!=NULL&&right!=NULL) return root;
        if(left!=NULL&&right==NULL) return left;
        else if(left==NULL&&right!=NULL) return right;
        else return NULL;   
    }
};