【算法练习Day18】二叉搜索树的最小绝对差&&二叉搜索树中的众数&& 二叉树的最近公共祖先

​📝个人主页：@Sherry的成长之路
🏠学习社区：Sherry的成长之路（个人社区）
📖专栏链接：练题
🎯长路漫漫浩浩，万事皆有期待

二叉搜索树的最小绝对差

530. 二叉搜索树的最小绝对差 - 力扣（LeetCode）

这道题要使用先处理底部节点的方法，搜索树的遍历解法通常都是使用中序遍历来解出答案。

思路就是按照搜索树的特性：中间节点一定比左子树部分节点数值大，我们让一个指针指向该节点的上一个位置，然后用我们当前的节点值减去上一个节点的值，用一个变量保存最小值，最后递归完毕返回。这是双指针的解法。变量创建一个大数，每次都和这个数比较比它小就和它交换即可，但是这种思路有一个弊端，就是当二叉树的两个节点相减如果本来就非常大，可能会引发一些bug。

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;
    }
};

为了避免这种bug，我们可以将最后返回的变量result的值开始用第一次减出来的值，接下来每次减出来的值都和它做对比，这样无论两个数减出来的值有多大也不会出现bug（但是承接该数的数据类型也有可能会溢出）。当然这道题我们同样也可以使用中序遍历存数组的方法，然后比较数组中各元素相减求最小值。

二叉搜索树中的众数

501. 二叉搜索树中的众数 - 力扣（LeetCode）

先说一说常规做法，遍历一次二叉树，用map来存储每一个数出现的频率，然后再用数组来承接，将数组按照频率的高低来排序，最终输出答案，注意可能有多个众数，比如说有两个数出现的频率都是最高的，那么将它们都返回来，这时我们如果数组是从频率大到小，那么我们就返回第一个数，然后比较它后面有没有和它频率相等的，如果有也一并加入返回。

class Solution {
public:

    void searchBST(TreeNode* cur,unordered_map<int,int>&map)
    {
        if(cur==nullptr)
        {
            return;
        }
        map[cur->val]++;
        searchBST(cur->left,map);
        searchBST(cur->right,map);
        return;
    }

    bool static cmp(const pair<int,int>&a,const pair<int,int>&b)
    {
        return a.second>b.second;
    }
    vector<int> findMode(TreeNode* root) {
        unordered_map<int,int>map;
        vector<int> result;
        if(root==nullptr)
        {
            return result;
        }
        searchBST(root,map);
        vector<pair<int,int>>vec(map.begin(),map.end());
        sort(vec.begin(),vec.end(),cmp);
        result.push_back(vec[0].first);
        for(int i=1;i<vec.size();i++)
        {
            if(vec[i].second==vec[0].second)
            {
                result.push_back(vec[i].first);
                
            }
            else
            {
                break;
            }
        }
        return result;
    }
};

这就是第一种常规做法，需要遍历两次二叉树。

但是我们可以遍历一次二叉树就完成题目需求。思路是：仍然是中序遍历，我们设立两个变量一个是当前数字的出现频率，另一个是我们在遍历过程中出现的最大频率有多少，最大频率我们一开始是无法确定的，所以它是实时更新的，而结果数组也是实时更新的，那么我们怎么知道一个数出现了多少次呢？还是用双指针，一个指向该节点上一个节点，另一个指向当前节点，如果两个节点值相等那么说明此时有两个一样的值的节点

class Solution {
public:
    vector<int> result;
    TreeNode* pre=nullptr;
    int maxcount=0,count=1;
    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);
        return;
    }
    vector<int> findMode(TreeNode* root) {
        count=0;
        maxcount=0;
        pre=nullptr;
        result.clear();

        searchBST(root);
        return result;
    }
};

代码核心在于递归中间部分，如果我们遍历时发现当前该值的出现频率和最大出现频率相等，那么直接加入进结果集合，如果比当前最大出现频率还大，清空数组并加入当前节点值。

二叉树的最近公共祖先

236. 二叉树的最近公共祖先 - 力扣（LeetCode）

一道略有难度的题，在于它的思路也在于对递归的理解。

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

代码整体看上去不长，思路是首先我们要知道什么时候返回节点，也就是结束递归逻辑如何书写，这里我们是遍历到空直接返回到上一层，这一点无需多言，其次我们找到p，q目标节点之一也要向上一级返回，这是为了告诉上一层我们找到了p或者q其中一个将它存在left或者right层次里，然后left有值后接着递归寻找right。

寻找p，q的最近祖先节点，有两种情况，其一是pq在两侧，也就是最常见的情况最容易被想到的情况，这样的话我们在寻找到left和right之后把返回到上一层的root节点直接返回上去，那如果暂时还没有找到另一个呢？我们怎么告诉上一层它的左侧或者右侧找到了其中一个呢？我们在left&&right的后面还有两个if来判断，告诉它我们找到了其一，当然找到其一我们并不在代码中具体表现找到哪一个，只是告诉找到了，且pq一定会被找到，因为题目已经说过了，一定存在pq。两个一起找到后返回一次root也就是中间节点处理的第一个if逻辑，然后我们通过返回左子树或右子树进入第二个或者第三个if完成向上返回。

那么第二种情况是什么呢？就是p或者q充当最近祖先节点的时候，其实这种情况也在代码里面体现了，由于p或者q在一条路径上所以我们遇到了最上面的p或者q直接返回来了，也就找到了最近祖先节点。

总结：

今天我们完成了二叉搜索树的最小绝对差、二叉搜索树中的众数、 二叉树的最近公共祖先三道题，相关的思想需要多复习回顾。接下来，我们继续进行算法练习。希望我的文章和讲解能对大家的学习提供一些帮助。

当然，本文仍有许多不足之处，欢迎各位小伙伴们随时私信交流、批评指正！我们下期见~