Ich habe eine Map mit ziemlich vielen Einträgen.

map<Object , int>

Ich suche jetzt die x Elemente der Map mit den größten "int"-Werten.
Wie stelle ich das an ?

In meinem Fall sind die Eigenschaften von "Object" total egal, es geht nur um den Integer-Wert der in der Map abgelegt ist.

Für Hinweise bin ich dankbar !

Viele Grüße,
Benjamin

#include <map>
#include <iostream>
using namespace std;

int main()
{
  map<int, int> v;

  v.insert(pair<int, int>(1, 5));
  v.insert(pair<int, int>(2, 6));
  v.insert(pair<int, int>(3, 7));
  v.insert(pair<int, int>(4, 8));

  multimap<int, int> tmp;

  map<int, int>::const_iterator iter;
  for (iter=v.begin(); iter!=v.end(); ++iter)
    tmp.insert(pair<int, int>(iter->second, iter->first));

  for (iter=tmp.begin(); iter!=tmp.end(); ++iter)
    cout << iter->first << iter->second;
}

#include <utility>

struct SmallerThan
{
	bool operator()(std::pair<const Object, int> &lhs, std::pair<const Object, int> &rhs)
    {
        return lhs.second < rhs.second;
    }
};

std::max_element(myMap.begin(), myMap.end(), SmallerThan());
}

Das mit dem Kopieren werde ich mal probieren. Wenns bissel dauert macht nix

Danke soweit !

Den größten int-Wert bekommst du so raus:
...

Ich suche ja aber nicht nur den größten Wert, sondern die x (2, 45, 156) größten Werte ...

Michael E. schrieb:

#include <utility>

struct SmallerThan
{
	bool operator()(std::pair<const Object, int> &lhs, std::pair<const Object, int> &rhs)
    {
        return lhs.second < rhs.second;
    }
};

std::nth_element(myMap.begin(), myMap.end(), SmallerThan());
}

Obiges müsste dann ja mein Problem lösen, oder ?

Bin nicht so fit in den std-Algorithmen ...

nth_element geht leider nicht, weil das nen Random Access Iterator erwartet, den map aber nicht bietet. Man könnte die Map natürlich aufsplitten, sodass die schon gefundenen Elemente rausfallen. Ist aber im Endeffekt alles viel zu aufwendig.

Nimm tim_gs Vorschlag oder sowas:

erstelle einen Vektor mit int-Wert + Zeiger
kopiere int-Wert von map in vector und speicher Position im Zeiger
sortiere vector

wei der variante mit dem kopieren wird der container lediglich einmal durchlaufen und nach neuem Index geordnet sortiert. ich werde austesten, wie groß sich die Unterschiede im Bezug auf die Performance sind.

kennt niemand eine andere möglichkeit oder hat jemand eine andere Idee das problem zu lösen?

ich kopiere alle ints in einen vector
diesen vector lasse ich sortieren.
ich picke mir das x-te element heraus und speichere dessen wert.

dann gehe ich die ursprünhliche map einmal komplett durch und vergleiche jedes element mit dem aus dem vector gespeicherten element. wenn es größer ist, dann habe ich eines der x geforderten elemente gefunden.
das funktioniert auch

lucky_tux schrieb:

bei der variante mit dem kopieren wird der container lediglich einmal durchlaufen und nach neuem Index geordnet sortiert.

Wenn ich das folgendermaßen tue:

map<Obj, int> map;
multimap<int, Obj> mulmap;

map<Obj, int>::iterator it;

for (it = map.begin(); it != map.end(); it++)
{
    mulmap.insert(make_pair(it->second, it->first));
}

multimap<int, Obj>::iterator iter;

for (iter = mulmap.begin(); iter != mulmap.end(); iter++)
{
  cout << iter->first << endl;
}

Dann sind die Schlüssel NICHT auf- oder absteigend sortiert, sondern relativ willkürlich.
Beispielsweise

2 1 1 2 2 3 3 3 3 2 3 1 2 3 3 3 2  usw

Das ist nicht befriedigend, weil ich sicherstellen muss, dass die ganz großen Zahlen (gibt auch welche im 100er Bereich) ganz vorne stehen.

Hat da jemand spontan eine Idee ?

Würde eine solche Konstruktion mein Problem lösen?
Falls ja, was bräuchte man da zusätzlich ? Vergleichsoperation oderso ?

vector<pair<int, Obj> > vec;

map<Obj, int> map;
map<Obj, int>::iterator it;

for (it = map.begin(); it != map.end(); it++)
{
    vec.push_back(make_pair(it->second, it->first));
}

sort(vec.begin(), vec.end());

natürlich ist die ausgabe des iterators über die multimap sortiert. ich habe in meinem code einen kleinen fehler drin, den ich hier im beispiel natürlich nicht habe. deswegen funktionierte das nicht. also alls im lot.
[/selbstgespräch]