[leetcode]501. Find Mode in Binary Search Tree

题目链接：https://leetcode.com/problems/find-mode-in-binary-search-tree/#/description

Given a binary search tree (BST) with duplicates, find all the mode(s) (the most frequently occurred element) in the given BST.

Assume a BST is defined as follows:

• The left subtree of a node contains only nodes with keys less than or equal to the node's key.
• The right subtree of a node contains only nodes with keys greater than or equal to the node's key.
• Both the left and right subtrees must also be binary search trees.

For example:
Given BST [1,null,2,2],

   1
    \
     2
    /
   2

return [2].

Note: If a tree has more than one mode, you can return them in any order.

Follow up: Could you do that without using any extra space? (Assume that the implicit stack space incurred due to recursion does not count).

class Solution {
public:
    vector<int> findMode(TreeNode* root) {
        put_map(root);
        int maxtime=0;
        vector<int> res;
        //sort(m.begin(),m.end(),[&](pair<int,int> a,pair<int,int>b){return a.second<b.second;});
        for(map<int,int>::iterator it=m.begin();it!=m.end();it++)
        {
            if(it->second>maxtime)
            {
                res.clear();
                maxtime=it->second;
                res.push_back(it->first);
            }
            else if(it->second==maxtime)
            {
                res.push_back(it->first);
            }
        }
        return res;
    }
    void put_map(TreeNode* root)
    {
        if(!root)
            return;
        if(root->left) put_map(root->left);
        m[root->val]+=1;
        if(root->right) put_map(root->right);
    };
private:
    map<int,int> m;
};

class Solution {
public:
    vector<int> findMode(TreeNode* root) {
        put_map(root);
        
        return v;
    }
    void put_map(TreeNode* root)
    {
        if(!root)
            return;
        if(root->left) put_map(root->left);
        currCount++;
        if(root->val!=currValue)
        {
            currValue=root->val;
            currCount=1;
        }
        if(currCount>maxCount)
        {
            maxCount=currCount;
            v.clear();
            v.push_back(root->val);
        }
        else if(currCount==maxCount)
        {
            v.push_back(root->val);
        }
        if(root->right) put_map(root->right);
    };
private:
    vector<int> v;
    int maxCount=0;
    int currCount=0;
    int currValue=0;
};