Wie kann ich Sortieren std::map zunächst von Wert, dann mit dem Schlüssel?

std::map Sortieren Ihre Elemente durch keys. Es kümmert sich nicht um die values bei der Sortierung.

Sie können std::vector<std::pair<K,V>> dann Sortieren Sie mit std::sort gefolgt von std::stable_sort:

std::vector<std::pair<K,V>> items;

//fill items

//sort by value using std::sort
std::sort(items.begin(), items.end(), value_comparer);

//sort by key using std::stable_sort
std::stable_sort(items.begin(), items.end(), key_comparer);

Beachten Sie, dass während std::sort gewählt wird, die performance für Grund std::stable_sort ist notwendig für die korrekte Bestellung, wie Sie wollen, dass die order-by-Wert, bewahrt zu werden.

@gsf erwähnt in dem Kommentar, den Sie verwenden könnten nur std::sort wenn Sie einen comparer vergleicht values ersten, und WENN Sie gleich sind, Sortieren Sie die keys.

auto cmp = [](std::pair<K,V> const & a, std::pair<K,V> const & b) 
{ 
     return a.second != b.second?  a.second < b.second : a.first < b.first;
};
std::sort(items.begin(), items.end(), cmp);

Sollte effizient sein.

Aber warten Sie, es gibt eine bessere Methode: store std::pair<V,K> statt std::pair<K,V> und dann brauchst du nicht comparer an alle — den standard-comparer for std::pair genug sein würde, wie es vergleicht first (das ist V) zuerst, dann second die K:

std::vector<std::pair<V,K>> items;
//...
std::sort(items.begin(), items.end());

Sollte große Arbeit.

Erläutert in Nawaz ist Antwort, Sie können nicht Sortieren Sie Ihre Karte, indem Sie sich, wie Sie es brauchen, weil std::map sortiert Elemente, basierend auf dem Schlüssel nur. So müssen Sie einen anderen container, aber wenn Sie zu bleiben, um Ihre anzeigen, dann können Sie immer noch kopieren Sie die Inhalte (vorübergehend) in eine andere Datenstruktur.

Ich denke, die beste Lösung ist die Verwendung eines std::set Speicherung gekippt Schlüssel-Wert-Paaren, wie Sie in ks1322 ist Antwort.
Die std::set ist sortiert und die Reihenfolge der Paare ist genau so, wie Sie es brauchen:

3) Wenn lhs.first<rhs.first, gibt true. Ansonsten, wenn rhs.first<lhs.first, gibt false. Ansonsten, wenn lhs.second<rhs.second, gibt true. Ansonsten gibt false.

Diese Weise brauchen Sie nicht eine zusätzliche Sortierung Schritt und der resultierende code ist sehr kurz:

std::map<std::string, int> m;  //Your original map.
m["realistically"] = 1;
m["really"]        = 8;
m["reason"]        = 4;
m["reasonable"]    = 3;
m["reasonably"]    = 1;
m["reassemble"]    = 1;
m["reassembled"]   = 1;
m["recognize"]     = 2;
m["record"]        = 92;
m["records"]       = 48;
m["recs"]          = 7;

std::set<std::pair<int, std::string>> s;  //The new (temporary) container.

for (auto const &kv : m)
    s.emplace(kv.second, kv.first);  //Flip the pairs.

for (auto const &vk : s)
    std::cout << std::setw(3) << vk.first << std::setw(15) << vk.second << std::endl;

Ausgabe:

  1  realistically
  1     reasonably
  1     reassemble
  1    reassembled
  2      recognize
  3     reasonable
  4         reason
  7           recs
  8         really
 48        records
 92         record

Code auf Ideone

Hinweis: Da C++17 können Sie range-basierte for-Schleifen zusammen mit strukturierte Bindungen für die Iteration über eine Karte.
Als Ergebnis der code für das kopieren der Karte wird sogar noch kürzer und lesbarer:

for (auto const &[k, v] : m)
    s.emplace(v, k);  //Flip the pairs.

EDIT: Die anderen beiden Antworten machen Sie einen guten Punkt. Ich gehe davon aus, dass Sie möchten, um Sie in eine andere Struktur, oder, um zu drucken Sie Sie aus.

"Am besten" kann bedeuten, eine Reihe von verschiedenen Dingen. Meinst du mit "am einfachsten," "Schnellste", "die meisten effizient", "least-code", "die meisten gelesen?"

Der offensichtlichste Ansatz besteht darin, eine Schleife durch zweimal. Auf dem ersten pass, um die Werte:

if(current_value > examined_value)
{
    current_value = examined_value
    (and then swap them, however you like)
}

Dann auf den zweiten Durchlauf, alphabetisch die Worte, aber nur, wenn Ihre Werte übereinstimmen.

if(current_value == examined_value)
{
    (alphabetize the two)
}

Streng genommen ist das eine "bubble-sort", das ist langsam, weil jedes mal, wenn Sie einen swap, müssen Sie von vorne beginnen. Ein "Durchlauf" ist abgeschlossen, wenn Sie durch die gesamte Liste, die Sie ohne swaps.

Gibt es andere algorithmen zur Sortierung, aber das Prinzip wäre das gleiche: order by Wert, dann alphabetisch.