Welcher Container für Sortierung?

BLR

Erfahrenes Mitglied
Hallo,

ich teste gerade für mein Programm Mergesort, HeapSort und QuickSort aus..
Dabei verwende ich den Vector, in dem ich die Zahlen halte.
Nun frage ich mich ob vllt. eine Liste, ein Set, oder ein einfaches Array vllt. eine bessere Performance für diese drei Sortierverfahren bringen würde.

Was denkt ihr?
Danke
 
Hi

Ein Vector ist prinzipiell ein einfaches Array, nur in eine Klasse verpackt. Es gibt zwar Verhaltensunterschiede zB. beim Anlegen, und bestimmte Anforderungen an den verwendeten Datentyp (falls es ein Vektor von einer eigenen Klasse sein soll), aber aus Sicht von Sortieralgorithmen ist nichts anders.
Ein Set ist nicht mit Vektor/Array/Liste vergleichbar weil es den selben Wert nicht mehrfach enthalten kann.
Damit bleibt nur Array vs Liste

Wenn einen die realen Ausführungszeiten interessieren (statt theoretische Komplexität) sind Arrays vermutlich immer besser, aus vielen Gründen (müsste man aber messen, um sicher zu sein). Typische Implementierungen von Quicksort und Heapsort sind sowieso mehr für Arrays gedacht (auch wenn es mit Anpassungen für Listen auch ziemlich gut werden kann). Für Mergesort ist es prinzipiell egal, der Zeitunterschied kommt von technischen Details (Cacheverhalten usw.usw.).

Wenn Geschwindigkeit wichtig ist, warum nicht die schon eingebauten Sortierfunktionen der Sprache verwenden? "Klassische" Sortieralgos wie auf Wikipedia zu implementieren ist ganz nett, aber die in den Standardlibs sind ziemlich aggressiv auf Geschwindigkeit optimiert; die Arbeit die da drinsteckt macht man nicht einfach mal so nach (Angepasste modernere Algos, die im Durchschnitt noch ein bisschen besser sind als die Einfachvarianten, und Ausnutzen aller möglichen Hardware-bezogenen Optimierungsmöglichkeiten (Cacheverhalten, spezielle CPU-Befehle, usw.usw.))
 
also für die oben drei genannten Sortieralgorythmen ist Array am besten geeigent als alle anderen Datencontainer?
 
Im Allgemeinen ja. Für den speziellen Fall den man hat müsste man messen.

(Falls das eine Schul/Unifrage ist schaut die Antwort etwas anders aus.)
 
Hhmm....was spielt das für eine Rolle ob man privat etwas entwickelt oder ob das von der Schule oder Uni kommt?
Ich erzeuge 1000000 Zahlen, die ich in einen Vector packe und mit diesen drei Algorithmen sortieren lasse.
Ich habe mich einfach gefragt, ob da vllt. ein anderer Container besser wäre...
 
Wenn du etwas privat entwickelst implementierst du solche Sachen nicht selber, weil du es nicht selber entwickeln musst und nur mit riesigem Aufwand die gleiche Leistung hin bekommst.
 
Das auch.
Was ich oben meinte dass Lehrer üblicherweise was von Komplexität usw.usw. hören wollen,
und nicht alle eine andere Art von Antwort akzeptieren (auch wenn sie richtig ist)
 
Zuletzt bearbeitet:
ne also ich hab einfach eine sehr große menge an zahlen.....
Und so viel Aufwand ist es nicht, gibts ja alles schon im internet.
Ich habe das einfach alles mit nem Vector als Datenbehälter implementiert.
 
Und warum verwendest du nicht std::sort?

N * log(N) Vergleiche seit C++11

oder die ganzen Sachen aus boost.Sort

Geht ja nicht darum, dass es viel Aufwand benötigt, dass eine naive erste Implementation die ganzen Tricks und Optimierungen drin hat, die eine professionelle und wohlgetestete Implementation wie in boost oder der STL (wobei letzteres öfters aus ersterem entlehnt wird) bietet.

Es gibt überhaupt keinen Grund sowas selber zu implementieren ausser irgendwo an ner Uni zwingt einem jemand dazu.
 
Genau...den std::sort habe ich schon auch getestet.
folgendes habe ich mit mit einem vector mit 1.000.000 Zahlen (rand())

*************HeapSort***********
HeapSort Dauer: 0.749sec
*************QuickSort***********
QuickSort Dauer: 0.374sec
*************STD::SORT***********
STD::SORT Dauer: 0.468sec
*************MergeSort***********
MergeSort Dauer: 3.354sec


Noch mal eine Messung durchfuehren?: 1 sonst 0
Eingabe: 1
*************HeapSort***********
HeapSort Dauer: 0.702sec
*************QuickSort***********
QuickSort Dauer: 0.39sec
*************STD::SORT***********
STD::SORT Dauer: 0.468sec
*************MergeSort***********
MergeSort Dauer: 3.322sec


Noch mal eine Messung durchfuehren?: 1 sonst 0
Eingabe: 1
*************HeapSort***********
HeapSort Dauer: 0.765sec
*************QuickSort***********
QuickSort Dauer: 0.39sec
*************STD::SORT***********
STD::SORT Dauer: 0.483sec
*************MergeSort***********
MergeSort Dauer: 3.324sec

Wie man sieht ist QuickSort immer am schnellsten, sogar schneller als stl-sort, was mich wundert.
Und noch wundert es mich dass der MergeSort mit so einem großen Abstand langsamer ist
 
Zurück