Tri de STD :: Carte par valeur avant la sortie et détruire

Les cartes sont stockées comme un arbre trié dans l'ordre clé. Vous voulez les 10 plus petites (ou les plus grandes) valeurs entières et leurs clés, non?

Dans ce cas, itérer la carte et mettre toutes les paires de la valeur de clé dans un vecteur de paires ( std :: vecteur >) code>. Je pense que vous pouvez simplement utiliser le constructeur deux-itérator-arg constructeur de std :: vecteur pour cela. Ensuite, utilisez std :: partiel_sort code> sur le vecteur. Spécifiez un comparateur à partial_sort, qui compare des paires en comparant simplement la valeur INT, ignorant la chaîne de clé. Ensuite, vous avez les 10 paires que vous voulez au début du vecteur et le reste du vecteur contient les paires restantes dans un ordre non spécifié. P>

code (non testé): p>

typedef std::pair<std::string, int> mypair;

struct IntCmp {
    bool operator()(const mypair &lhs, const mypair &rhs) {
        return lhs.second < rhs.second;
    }
};


void print10(const std::map<std::string,int> &mymap) {
    std::vector<mypair> myvec(mymap.begin(), mymap.end());
    assert(myvec.size() >= 10);
    std::partial_sort(myvec.begin(), myvec.begin() + 10, myvec.end(), IntCmp());

    for (int i = 0; i < 10; ++i) {
        std::cout << i << ": " << myvec[i].first 
            << "-> " << myvec[i].second << "\n";
    }
}

Peut ne pas être le moyen le plus élégant, mais vous pouvez les trier via une valeur dans un ensemble comme: xxx

Une autre possibilité est de construire une carte inversée. Pour vous, ce serait std :: map code>. Les entrées dans la carte inverse sont triées par leur valeur.

Voici ce que j'ai dans ma boîte à outils pour de telles occasions: P>

template< typename TK, typename TV, class TP, class TA, typename T1, typename T2 >
inline void asserted_insert(std::map<TK,TV,TP,TA>& m, const T1& k, const T2& v)
{
  typedef std::map<TK,TV,TP,TA>                   map_type;
  typedef typename map_type::value_type           value_type;
  assert( m.insert(value_type(k,v)).second );
}

template< class TMap > struct reverse_map;
template< typename T1, typename T2 > struct reverse_map< std::map<T1,T2> > {
  typedef std::map<T2,T1>                         result_t;
};

template< typename T1, typename T2, class TP1, class TA1, class TP2, class TA2 >
inline void build_reverse_map(const std::map<T1,T2,TP1,TA1>& map, std::map<T2,T1,TP2,TA2>& reverse_map)
{
  typedef std::map<T1,T2,TP1,TA1>                 map_type;

  for( typename map_type::const_iterator it=map.begin(),
                                        end=map.end(); it!=end; ++it ) {
    asserted_insert( reverse_map, it->second, it->first );
  }
}