predicate for a map from string to int

Question

I have this small program that reads a line of input & prints the words in it, with their respective number of occurrences. I want to sort the elements in the map that stores these values according to their occurrences. I mean, the words that only appear once, will be ordered to be at the beginning, then the words that appeared twice 7 so on. I know that the predicate should return a bool value, but I don't know what the parameters should be. Should it be two iterators to the map? If some one could explain this, it would be greatly appreciated. Thank you in advance.

#include<iostream>
#include<map>

using std::cout;
using std::cin;
using std::endl;
using std::string;
using std::map;

int main()
{
    string s;
    map<string,int> counters;   //store each word & an associated counter

    //read the input, keeping track of each word & how often we see it
    while(cin>>s)
    {
        ++counters[s];
    }

    //write the words & associated counts
    for(map<string,int>::const_iterator iter = counters.begin();iter != counters.end();iter++)
    {
        cout<<iter->first<<"\t"<<iter->second<<endl;
    }

    return 0;
}

Answer 1

std::map is always sorted according to its key. You cannot sort the elements by their value.

You need to copy the contents to another data structure (for example std::vector<std::pair<string, int> >) which can be sorted.

Here is a predicate that can be used to sort such a vector. Note that sorting algorithms in C++ standard library need a "less than" predicate which basically says "is a smaller than b".

bool cmp(std::pair<string, int> const &a, std::pair<string, int> const &b) {
  return a.second < b.second;
}

Answer 2

You can't resort a map, it's order is predefined (by default, from std::less on the key type). The easiest solution for your problem would be to create a std::multimap<int, string> and insert your values there, then just loop over the multimap, which will be ordered on the key type (int, the number of occurences), which will give you the order that you want, without having to define a predicate.

Answer 3

You are not going to be able to do this with one pass with an std::map. It can only be sorted on one thing at a time, and you cannot change the key in-place. What I would recommend is to use the code you have now to maintain the counters map, then use std::max_element with a comparison function that compares the second field of each std::pair<string, int> in the map.

Answer 4

A map has its keys sorted, not its values. That's what makes the map efficent. You cannot sort it by occurrences without using another data structure (maybe a reversed index!)

Answer 5

As stated, it simply won't work -- a map always remains sorted by its key value, which would be the strings.

As others have noted, you can copy the data to some other structure, and sort by the value. Another possibility would be to use a Boost bimap instead. I've posted a demo of the basic idea previously.

Answer 6

You probably want to transform map<string,int> to vector<pair<const string, int> > then sort the vector on the int member.

You could do

struct PairLessSecond
{
  template< typename P >
  bool operator()( const P& pairLeft, const P& pairRight ) const
  {
    return pairLeft.second < pairRight.second;
  }
};

You can probably also construct all this somehow using a lambda with a bind.

Now

   std::vector< std::map<std::string,int>::value_type > byCount;
   std::sort( byCount.begin(), byCount.end(), PairLessSecond() );