代码随想录算法训练营第二十一天|501.二叉搜索树中的众数，501.二叉搜索树中的众数,236. 二叉树的最近公共祖先

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

因为此处是二叉搜索数，所以其中序遍历是一个从小到大的有序数组，最小的绝对差只会出现在中序遍历中两个相邻节点对应的值之差。

这里利用了双指针的思想，t1是上个指针，root是当前指针。

class Solution {
public:
    int cha=INT_MAX;
    TreeNode*t1=nullptr;
    void digui(TreeNode* root)
    {   
        if(root==nullptr)return;
        digui(root->left);
        if(t1!=nullptr)
        cha=min(cha,root->val-t1->val);
        t1=root;
        digui(root->right);
        


    }
    int getMinimumDifference(TreeNode* root) {
        //int cha=INT_MAX;
        //TreeNode*t1=nullptr;
        digui(root);
        return cha;

    }

};

这里注释的两行代码加上会报错，因为之前已经定义过这两个变量了！

如果想赋初值的话应该改为//cha=INT_MAX;
                //t1=nullptr;

501.二叉搜索树中的众数

第一种思路是中序遍历把结果存放在一个数组中，然后对数组进行统计。

这里有两个需要记录的元素，一个是出现的数字，一个是出现数字的个数，所以采用map

class Solution {
public:
    map<int,int>m1;
    void bianli(TreeNode* root)
    {
        if(root==nullptr)return;
        bianli(root->left);
        
        m1[root->val]++;
        bianli(root->right);
        return;
    }
    bool static compare(const pair<int,int>&t1,const pair<int,int>&t2)
    {
        return t1.second>t2.second;
    }//1.
    vector<int> findMode(TreeNode* root) {
    m1.clear();
    bianli(root);
    vector<pair<int,int>>v1(m1.begin(),m1.end());//2.
    sort(v1.begin(),v1.end(),compare);
    vector<int>result;
   for(int i=0;i<v1.size();i++)
   {
    if(v1[i].second==v1[0].second)//3.
    result.push_back(v1[i].first);
    else
    break;

   }
   return result;

    }
};

思路简单但还是有细节需要注意的

2.我们需要对map->second中的元素（出现数字的个数）直接排序，但是仅用map是无法做到这一点的，所以我们创建了一个和map相同数据类型的数组vector，然后对vector进行排序。

1.我们需要对pair<int,int>中的第二个元素进行排序，这需要重新写仿函数设定排序方式。

3.最大值是前面一个/一群数字，这里我们采用for循环，确保所有出现次数为最大的数字都可以输出。

第二种思路是双指针

class Solution {
public:
    vector<int>result;
    int maxcishu=0;
    int cishu=0;
    TreeNode* cur=nullptr;
    void digui(TreeNode* root)
    {
        if(root==nullptr)return;
        digui(root->left);
        if(cur==nullptr)cishu=1;

        else if(cur->val==root->val)
        cishu++;

        else
        cishu=1;

        if(cishu==maxcishu)
        result.push_back(root->val);
        else if(cishu>maxcishu)
        {
            maxcishu=cishu;
            result.clear();
            result.push_back(root->val);

        }
        cur=root;

        digui(root->right);



    }
    vector<int> findMode(TreeNode* root) {
        digui(root);
        return result;

    }
};

这题和上面一题的思路相似，都是上个指针和当前指针的关系，因为中序遍历是有序的，所以相同的节点值必然出现在上个指针和这个指针之间。

由于我们需要记录次数，设定了cishu和maxcishu两个变量，一个用来记录当前节点值的次数，一个用来记录最大的次数。

每当当前节点值与上个节点值次数相同时，cishu++；统计完当前节点值的次数后将它与最大次数比较

1.小于：无事发生

2.等于，当前节点的值属于众数，将他插入结果中

3.大于，将maxcishu进行更新，并且清空result中所有的值（result中所有的值都是maxcishu更新前的众数，当新的最大值出现说明之前的众数都不符合条件），后面插值

这样只需要一次遍历就能实现众数的寻找。

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

这题思路还是挺重要的

1.首先这题要求最近，肯定是从底层开始（从顶层开始的话头结点是所有节点的公共祖先）进行遍历，所以采用后序。

2.确定祖先，怎么确定祖先，如果找到一个节点，发现左子树出现结点p，右子树出现节点q，或者 左子树出现结点q，右子树出现节点p，那么该节点就是节点p和q的最近公共祖先。

还有一种特殊情况，就是root也是p/q（自己可以当自己的祖先）

接下来进行递归，共有4种情况

1. if(left!=NULL&&right!=NULL) 这时候root的左子树有一个值p，右子树有一个值q，所以root就是祖先（因为我们是自底而上进行遍历的，所以只要出现满足条件的节点就必然是最近祖先）

2.  else if(left==NULL&&right!=NULL)return right;这时候右子树有一个值但左子树没有值，返回右子树对应的值

这里举了个例子，即使2不是祖先，但是祖先一定在2的上面的节点，该节点的右子树（包括2）含有8，我们要把这个信息传输到上一层，所以return right。

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





    }
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        return digui(root,p,q);
        
    }
};

3.left和right都是空，证明该节点的子树不包含我们要的节点，返回NULL即可。