LeetCode 501.Find Mode in Binary Search Tree

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].

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
using namespace std;


//我的垃圾解法
class Solution {
public:
    int record[10000]={0};//记录数组记录数字出现的次数
    vector<int>c;//存放点
    vector<int>b;//存放最后结果
    vector<int>d;//存放点对应记录数组的位置
    int count=0;//计数器
    vector<int> findMode(TreeNode* root) {
        if(root==NULL){
            return b;
        }
        solve(root);
        int temp=record[d[0]];
        for(int i=0;i<c.size();i++){
            if(record[d[i]]==temp){
                b.push_back(c[i]);
            }
            if(record[d[i]]>temp){b.clear();temp=record[d[i]];b.push_back(c[i]);}


        }
        return b;
    }
    void solve(TreeNode *root){




            vector<int>::iterator result = find( c.begin( ), c.end( ), root->val ); 

            if(result!=c.end()){
                record[result-c.begin()]++;

            }
            else{
                c.push_back(root->val);
                d.push_back(count);
                record[count]++;
                count++;


            }
            bool a= root->left==NULL;
            bool b=root->right==NULL;
            if(!a||!b){
            if(!a&&b){
                solve(root->left);
                return;
            }
            if(a&&!b){
                solve(root->right);
                return;
            }
            if(!a&&!b){
                solve(root->left);
                solve(root->right);
                return;
            }
        }
           return; 
        }




};

//讨论中的高端解法：
class Solution {
public:
    vector<int> findMode(TreeNode* root) {
        unordered_map<int, int> map;
        vector<int> result;
        int modeCount = getModeCount(root, map);

        for(pair<int,int> p : map) {
            if(p.second == modeCount) {
                result.push_back(p.first);
            }
        }

        return result;

    }

    /**
     * Traverse the tree using depth first search.
     * Return the mode count (i.e. The count of a repeated number that occurs the most.) of the tree.
     */
    int getModeCount(TreeNode* root, unordered_map<int, int> &map) {
        if(root == NULL)
            return 0;

        if(map.find(root->val) == map.end()) {
            map.insert(pair<int, int>(root->val, 1));
        }
        else {
            map[root->val]++;
        }

        return max(map[root->val], max(getModeCount(root->left, map), getModeCount(root->right, map)));
    }
};

其实大家都是深度优先搜索，只是因为我没用map这个数据结构改用了几个vector，搜索浪费了时间。