ich möchte in C++ einen Algorithmus erstellen, der aus einer Liste, die n größten Elemente sucht. Eigentlich keine große Sache, doch frage ich mich, ob es vielleicht einen effizienteren Weg gibt.

Momentan würde ich einen Sortieralgorithmus (zum Beispiel MergeSort) implementieren und diesen einfach n mal anwenden. Das scheint mir aber irgendwie recht aufwendig.

Gibt es eine schönere Variante?

Vielen Dank
LG, freakC++

Gibt es eine schönere Variante?

nth_element ?
Läuft durchschnittlich in O(n) ab, ist also schneller als Sortieren.

Klar, ich kann n mal die Liste durchrattern und nach dem größten Element suchen. Das ist aber doof :). Da ich mit der STL nicht sehr vertraut bin, hoffe ich auf einen Tipp. max_element bringts nicht, da ich den Index nicht rauskriege.

Naja, sonst implementiere ich es schnell einfach selbst...

LG, freakC++

max_element bringts nicht, da ich den Index nicht rauskriege.

Doch.

Da ich mit der STL nicht sehr vertraut bin

Dann wird es aber Zeit. Um die kommst du in C++ nicht herum.

Selbst wenn du die Indices willst ist nth_element am schnellsten (musst halt eine Kopie anlegen). Sind geschätzt etwa 5 Zeilen Code.

was bringt mir eine partielle Sortierung, also ein Schritt des Quicksorts?

Du willst die n größten Elemente und partial_sort und nth_element geben dir die n größten Elemente. Was ist daran unklar?

freakC++ schrieb:

was bringt mir eine partielle Sortierung, also ein Schritt des Quicksorts?

Du willst die n größten Elemente und partial_sort und nth_element geben dir die n größten Elemente. Was ist daran unklar?

Ok, sorry! Da hab ich mich falsch ausgedrückt. Zwar kann ich die Elemente so sortieren, doch habe ich danach keinen Zugriff mehr auf die alten Indices. Die brauche ich aber.

Gibt es eine gute Möglichkeit? Spontan dachte ich, das zu sortierende Array in einer Struktur zu speicher, die zusätzlich noch die ursprünglichen Indices verwaltet und dann diese Struktur zu sortieren. Oder gibt es vielleicht einen besseren Weg?

Herzlichen Dank für eure Hilfe
LG, freakC++

Gibt es eine gute Möglichkeit? Spontan dachte ich, das zu sortierende Array in einer Struktur zu speicher, die zusätzlich noch die ursprünglichen Indices verwaltet und dann diese Struktur zu sortieren. Oder gibt es vielleicht einen besseren Weg?

Jo, das ist naheliegend.
Kannst aber auch ein Indexfeld anlegen und sortieren lassen. Einfacher als Zeigerfeld, dann kannste partial_sort nebst [](int* a,int* b){return *a<*b;} nehmen.

Ok, sorry! Da hab ich mich falsch ausgedrückt. Zwar kann ich die Elemente so sortieren, doch habe ich danach keinen Zugriff mehr auf die alten Indices. Die brauche ich aber.

Liest du eigentlich auch, was andere schreiben?

effi briest schrieb:

Selbst wenn du die Indices willst ist nth_element am schnellsten (musst halt eine Kopie anlegen). Sind geschätzt etwa 5 Zeilen Code.

std::vector<int> all = ... // Inhalt deines Arrays
std::size_t n_max = ... // Wie viele Elemente du willst - 1

auto copy = all;
std::nth_element(copy.begin(), copy.begin()+n_max, copy.end(), std::greater<int>());
for (size_t i = 0; i < all.size(); ++i)
  if (all[i] >= copy[n_max])
    std::cout << all[i] << '\n';

Dürfte im diesem speziellen Fall am besten sein (solange alle Werte des Arrays unterschiedlich sind), sonst halt den Trick von Volkard anwenden.

danke :). Da nicht alle Arrayelemente gleich sind, möchte ich gerne volkards Variante ausprobieren. Verstehe ich dich richtig, dass ich die Indices sortieren soll? Ne, das konn doch nicht sein. Was meinst Du genau mit dem Indexfeld?

Dankee

Hallo,

danke :). Da nicht alle Arrayelemente gleich sind, möchte ich gerne volkards Variante ausprobieren. Verstehe ich dich richtig, dass ich die Indices sortieren soll? Ne, das konn doch nicht sein. Was meinst Du genau mit dem Indexfeld?

Dankee

#include <vector>
#include <iostream>
#include <iterator>
#include <algorithm>

int main(){
    using namespace std;

    vector<int> daten;

    cout<<"Zahlen würfeln\n";
    for(size_t i=0;i<10;++i)
        daten.push_back(rand()%100);
    for(auto i:daten)
        cout<<i<<' ';
    cout<<'\n';

    cout<<"Indexfeld bauen\n";
    vector<int*> index;
    for(auto& i:daten)
        index.push_back(&i);

    cout<<"Indexfeld sortieren\n";
    sort(index.begin(),index.end(),[](int* a,int* b){return *a>*b;});
    for(size_t i=0;i<10;++i)
        cout<<"Rang "<<i<<"  an Platz "<<(index[i]-&*daten.begin())<<"  mit Wert "<<*index[i]<<'\n';

    return 0;
}

Zahlen würfeln
83 86 77 15 93 35 86 92 49 21 
Indexfeld bauen
Indexfeld sortieren
Rang 0  an Platz 4  mit Wert 93
Rang 1  an Platz 7  mit Wert 92
Rang 2  an Platz 1  mit Wert 86
Rang 3  an Platz 6  mit Wert 86
Rang 4  an Platz 0  mit Wert 83
Rang 5  an Platz 2  mit Wert 77
Rang 6  an Platz 8  mit Wert 49
Rang 7  an Platz 5  mit Wert 35
Rang 8  an Platz 9  mit Wert 21
Rang 9  an Platz 3  mit Wert 15

#include <vector>
#include <iostream>
#include <iterator>
#include <algorithm>

int main(){
    using namespace std;

    vector<int> daten;

    cout<<"Zahlen würfeln\n";
    for(size_t i=0;i<10;++i)
        daten.push_back(rand()%100);
    for(auto i:daten)
        cout<<i<<' ';
    cout<<'\n';

    cout<<"Indexfeld bauen\n";
    vector<int> index;
    for(size_t i=0;i<10;++i)
        index.push_back(i);

    cout<<"Indexfeld sortieren\n";
    sort(index.begin(),index.end(),[=](int a,int b){return daten[a]>daten[b];});
    for(size_t i=0;i<10;++i)
        cout<<"Rang "<<i<<"  an Platz "<<index[i]<<"  mit Wert "<<daten[index[i]]<<'\n';

    return 0;
}