530. 二叉搜索树的最小绝对差、501. 二叉搜索树中的众数

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

题目描述：

给你一个二叉搜索树的根节点 root ，返回 树中任意两不同节点值之间的最小差值 。

差值是一个正数，其数值等于两值之差的绝对值。

解答：

二叉搜索树进行中序访问是一个有序序列，差值的最小一定会出现在序列相邻的两个位置中。

先对二叉搜索树进行中序遍历，得到遍历序列 。

然后访问遍历序列，记录最小的差值。

代码实现：

class Solution {
public:
    void inOrder(TreeNode* root, vector<int>&result){
        if (root == NULL)
            return;
        inOrder(root->left, result);
        result.push_back(root->val);
        inOrder(root->right, result);
    }
    int getMinimumDifference(TreeNode* root) {
        vector<int>result;
        inOrder(root, result);
        int min = INT_MAX;
        for (int i = 0; i<result.size()-1; i++){
            if (min > abs(result[i] - result[i+1]))
                min = abs(result[i] - result[i+1]);
        }
        return min;
    }
};

同时也可以在中序遍历递归的时候记录前一个节点，来完成比较；无需再遍历序列。

代码如下：

class Solution {
private:
int result = INT_MAX;
TreeNode* pre;
void traversal(TreeNode* cur) {
    if (cur == NULL) return;
    traversal(cur->left);   // 左
    if (pre != NULL){       // 中
        result = min(result, cur->val - pre->val);
    }
    pre = cur; // 记录前一个
    traversal(cur->right);  // 右
}
public:
    int getMinimumDifference(TreeNode* root) {
        traversal(root);
        return result;
    }
};

501. 二叉搜索树中的众数

题目描述：

给你一个含重复值的二叉搜索树（BST）的根节点 root ，找出并返回 BST 中的所有 众数（即，出现频率最高的元素）。

如果树中有不止一个众数，可以按 任意顺序 返回。

假定 BST 满足如下定义：

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

解答：

法一：不考虑二叉搜索树的性质

直接将本题当成求二叉树的众数来进行处理。

此处涉及到次数想到使用哈希表来存储。

首先对于树进行中序遍历，得到遍历序列。将遍历序列中出现的数和出现的次数存入哈希表中。然后对哈希表进行排序，拿出频率最大值即可。

对于哈希表的详情见：哈希表刷题总结_清榎的博客-CSDN博客

代码实现：

class Solution {
public:
    void inOrder(TreeNode* root, vector<int>&result){
        if (root == NULL)
            return;
        inOrder(root->left, result);
        result.push_back(root->val);
        inOrder(root->right, result);
    }
    bool static cmp (const pair<int, int>& a, const pair<int, int>& b) {
        return a.second > b.second;
    }
    vector<int> findMode(TreeNode* root) {
        vector<int>result, mode;
        map<int, int>hashMap;
        inOrder(root, result);
        //使用哈希表存储节点以及出现的次数
        for(auto n : result)
            hashMap[n]++;
        //给哈希表按照出现的次数进行排序
        vector<pair<int, int>> vec(hashMap.begin(), hashMap.end());
        sort(vec.begin(), vec.end(), cmp);
        //寻找频率最高的情况
        mode.push_back(vec[0].first);
        for (int i = 1; i < vec.size(); i++) {
            // 取最高的放到result数组中
            if (vec[i].second == vec[0].second) mode.push_back(vec[i].first);
            else break;
        }
        return mode;
    }
};

法二：使用二叉搜索树的性质

由于二叉搜索树进行中序遍历序列是有序的，寻找众数比较相邻的节点即可。

因此采用上一题中法二的思想，使用一个指针指向当前节点的前一个节点，进行比较。

if (pre == NULL)
    count = 1;
else if(pre->val == root->val)
    count++;
else 
    count = 1;
pre = root;

若前一个节点为NULL表示是树的第一个节点，count直接置为1。当前节点和前一个节点值相同count++，不同则置1。

另外还有一个问题，如何确定众数？

因为众数可以有多个，所以如果频率count 等于maxCount（最大频率），把这个元素加入到结果集中。

此处有个问题，万一，这个maxCount此时还不是真正最大频率呢？

因此在count大于maxCount时先要将结果集置为空，然后再放入结果集中。

代码实现：

class Solution {
public:
    TreeNode* pre;
    vector<int>result;
    int count, maxCount = INT_MIN;
    void inOrder(TreeNode* root){
        if (root == NULL)
            return;
        inOrder(root->left);
        if (pre == NULL)
            count = 1;
        else if(pre->val == root->val)
            count++;
        else 
            count = 1;
        pre = root;

        if (count == maxCount) { // 如果和最大值相同，放进result中
            result.push_back(root->val);
        }
        if (count > maxCount) { // 如果计数大于最大值频率
            maxCount = count;   // 更新最大频率
            result.clear();     // 很关键的一步，不要忘记清空result，之前result里的元素都失效了
            result.push_back(root->val);
        }

        inOrder(root->right);
    }
    vector<int> findMode(TreeNode* root) {
        if (root == NULL)
            return {};
        inOrder(root);
        return result;
    }
};