Efficient Computation of Frequent and Top-k Elements in Data Streams - c++

Question

Here is the pseduo code for this algorithm.
Following is how I have implemented this.
#include <iostream>
#include <fstream>
#include <string>
#include <map>
typedef std::map<std::string, int> collection_t;
typedef collection_t::iterator collection_itr_t;
collection_t T;
collection_itr_t get_smallest_key() {
collection_itr_t min_key = T.begin();
collection_itr_t key = ++min_key;
while ( key != T.end() ) {
if ( key->second < min_key->second )
min_key = key;
++key;
}
return min_key;
}
void space_saving_frequent( std::string &i, int k ) {
if ( T.find(i) != T.end())
T[i]++;
else if ( T.size() < k ) {
T.insert(std::make_pair(i, 1 ));
} else {
collection_itr_t j = get_smallest_key();
int cnt = j->second + 1;
T.erase(j);
T.insert(std::make_pair(i, cnt));
}
}
int main ( int argc, char **argv) {
std::ifstream ifs(argv[1]);
if ( ifs.peek() == EOF )
return 1;
std::string line;
while( std::getline(ifs,line) ) {
std::string::size_type left = line.rfind('=') + 1;
std::string::size_type length = line.length();
std::string i = line.substr(left, length - left - 1);
space_saving_frequent(i, 5);
}
ifs.close();
return 0;
}
Original paper link : http://dimacs.rutgers.edu/~graham/pubs/papers/freqcacm.pdf
But code does not work, and I am no able to figure out where I am wrong.

Answer 1

If the items with least count are two or more, you can simply break ties arbitrarily by choosing, for instance, the item with lowest index stored in your data structure, or a random one among those of lowest count etc.
If you want to compare your implementation with a reference one, take a look at the implementation of Cormode and Hadjieleftheriou that you will find here. The code is more complex than yours, because you are not actually implementing the stream summary data structure. Their code also includes implementations for several other frequent items algorithms, and the authors compared the performances of those algorithms. Space saving proved to be in the majority of the cases, the best algorithm, with regard to several metrics such as precision, recall, update speed, space used etc. You will also find a paper discussing this experimental comparison. An improved version of this paper appeared later in Communications of the ACM. Here you can access a pdf version.