代码随想录day21

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

最直白的做法就是中序遍历二叉树，将结果放入vec数组中，然后再遍历一遍数组得到最小绝对差。（代码中不用使用abs函数，因为二叉搜索的中序遍历结果就是有序的）

class Solution {
public:
    vector vec;
    void traversal(TreeNode* node){
        if(node==NULL) return;
        traversal(node->left);
        vec.push_back(node->val);
        traversal(node->right);
    }
    int getMinimumDifference(TreeNode* root) {
        int minval=INT_MAX;
        traversal(root);
        for(int i=1;i

双指针：

class Solution {
public:
    int res=INT_MAX;
    TreeNode* pre=NULL;//这个应该在外面初始化
    void traversal(TreeNode* cur){
        if(cur==NULL) return;
        //TreeNode* pre=NULL;
        traversal(cur->left);
        if(pre!=NULL){
            res=min(res,cur->val-pre->val);
        }
        pre=cur;
        traversal(cur->right);
    }
    int getMinimumDifference(TreeNode* root) {
        traversal(root);
        return res;
    }
};

错因：pre指针的初始化应该在递归函数外。

501.二叉搜索树中的众数 

看成一颗普通的二叉树做，直接任选一种遍历方式遍历二叉树，用unordered_map统计元素出现的频率，因为没法对map的value进行排序，所以转换成vector然后自定义排序函数进行排序，取频率最高的key值即可。

class Solution {
public:
    void traversal(TreeNode* cur,unordered_map& map){
        if(cur==nullptr) return;
        //用前序遍历
        map[cur->val]++;
        traversal(cur->left,map);
        traversal(cur->right,map);
        return;
    }
    bool static cmp(pair& a,pair& b){
        return a.second>b.second;
    }
    vector findMode(TreeNode* root) {
        unordered_map map;
        traversal(root,map);
        //先转换为vector再排序
        vector> vec(map.begin(),map.end());
        sort(vec.begin(),vec.end(),cmp);
        vector res;
        res.push_back(vec[0].first);
        for(int i=1;i

双指针：

class Solution {
public:
    TreeNode* pre=NULL;
    int count=0;
    int maxcount=0;
    vector res;
    void traversal(TreeNode* cur){
        if(cur==NULL) return;
        traversal(cur->left);
        if(pre==NULL) count=1;
        else if(cur->val==pre->val) count++;
        else count=1;
        pre=cur;
        //单个元素的频率统计出来了，就要和最大频率比较
        if(count==maxcount) res.push_back(cur->val);
        else if(count>maxcount){
            maxcount=count;
            res.clear();
            res.push_back(cur->val);
        }
        traversal(cur->right);
        return;
    }
    vector findMode(TreeNode* root) {
        traversal(root);
        return res;
    }
};

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

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