二叉树：寻找二叉搜索树的众数

501. 二叉搜索树中的众数

易错点：众数有可能不止一个！

如果不是二叉搜索树，是普通的树：

1. 这个树都遍历了，用map统计频率
2. 把统计的出来的出现频率（即map中的value）排个序
3. 取前面高频的元素

class Solution {
    
    
public:
    vector<int> findMode(TreeNode* root) {
    
    
       
        unordered_map<int, int> map; // key:元素，value:出现频率
        vector<int> result;
        if (root == NULL) 
        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++) 
        {
    
     
            // 取最高的放到result数组中
            if (vec[i].second == vec[0].second) 
             	result.push_back(vec[i].first);
            else 
            	break;
        }
        return result;
    }
    void searchBST(TreeNode* cur, unordered_map<int, int>& map) 
    
    {
    
     // 前序遍历
    	if (cur == NULL) 
    		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; // 按照频率从大到小排序
    }

};

二叉搜索树，不使用额外空间：

弄一个指针指向前一个节点，这样每次cur（当前节点）才能和pre（前一个节点）作比较,而且初始化的时候pre = NULL，这样当pre为NULL时候，我们就知道这是比较的第一个元素。如果 频率count 等于 maxCount（最大频率），当然要把这个元素加入到结果集中（以下代码为result数组），频率count 大于 maxCount的时候，不仅要更新maxCount，而且要清空结果集（以下代码为result数组），因为结果集之前的元素都失效了

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
    
    
public:
    int count = 0;//当前val出现次数数
    int maxCount = 0;//众数出现的次数
    vector<int> result;
    TreeNode* pre = NULL;
    vector<int> findMode(TreeNode* root) 
    {
    
    
        searchBST(root);
        return result;
    }
    void searchBST(TreeNode* cur)
    {
    
    
        if(cur == NULL)
        return;
        //中序遍历
        searchBST(cur->left);// 左
        if(pre == NULL)// 第一个节点
        {
    
    
            count = 1;
        }
        else if(pre->val == cur->val)// 相等
        {
    
    
            count++;
        }
        else //与pre节点的值不同，重新开始计算count
        {
    
    
            count = 1;
        }
        if(count == maxCount) //出现次数相同的节点入队
        {
    
    
            result.push_back(cur->val);
        }
        if(count > maxCount)
        {
    
    
            result.clear(); // 这一步很重要，之前元素全部失效了
            maxCount = count;// 更新最大频率
            result.push_back(cur->val);
        }
        pre = cur;// 更新pre节点
        searchBST(cur->right); //右
    }
};