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