Geschwindigkeit

GeschwindigkeitHoara(angl. quicksort), oft genanntqsort(im Namen der Standardbibliothek der C Language) ist ein Sortieralgorithmus, der vom englischen Informanten Charles Hoar während seiner Arbeit an der MOU 1960 entwickelt wurde.

Einer der am schnellsten bekannten Universalalgorithmen der Sortierung von Massen: im Durchschnitt- Ja. in Ordnungn Elemente; aufgrund einer Reihe von Mängeln in der Praxis werden in der Regel einige Verbesserungen verwendet.

Schnelle Sortiermethode Nach dem Prinzip der Trennung und Macht. (seufzt)Orientierung des betreffenden Ziels durch zwei oder mehrere Unterziele gleicher Art, jedoch kleiner, und Kombination ihrer Entscheidungen zur Reaktion auf die Basislinie)

Schnell! ist eine wesentlich verbesserte Version des Algorithmus der Einstufung durch direkten Austausch (z.B. unser "Bublic Class"-Ansatz), bekannt als unsere geringe Leistung. Der grundsätzliche Unterschied besteht darin, dass im ersten Fall Kreuzungen möglichst weit sind und nach jedem Durchgang die Elemente in zwei unabhängige Gruppen aufgeteilt werden. (Auf diese Weise hat sich die Verbesserung der ineffizientsten Direktsortierung aus einer der effektivsten Verbesserungen ergeben.)

Leistungen Schnell! Im Vergleich zu den anderen Algorithmen der schnellen Abschreibung, es ist nicht mit zusätzlichen Massen, es ist an Ort und Stelle sortiert.

Der Algorithmus besteht aus drei Schritten:

  1. Wahl Stützelement aus der MasseX)
  2. Phase AbteilungUmverteilung von Elementen in der Masse so, dass die Elemente weniger repositiv zu ihr und mehr oder gleich zu ihnen nach.
    A[i] PER X
    A[i] Bestandteil= X
    Die Elemente befinden sich nun so, dass kein Element der ersten Gruppe in die zweite Gruppe klassifiziert wird und umgekehrt.
    Daher ist es ausreichend, jeden Teil der Masse zu trennen, der ein Ansatz ist. "separate und master."
  3. Anwendung der ersten beiden SchritteInsgesamt zwei Subbasins auf der linken und rechten Seite des Stützelements. Die Wiederholung gilt nicht für eine Masse, in der nur ein oder keine Elemente vorhanden sind.
Das Umrüstverfahren muss
- ein Volumen, das wir sortieren;
- Index des ersten Teils des klassifizierten Abschnitts;
- Index des letzten Teils der Klasse.
Algorithm auf Pseudokodid:
ALG QUICKSORT(A[], START, END)
 / Ist die Bedingung erfüllt, im Arbeitsteil der Masse
// weniger als zwei Elemente,
/ Ich meine, keine Notwendigkeit, etwas zu sortierenVERFAHREN

 // kann als Stützelement genommen werden
// Durch einen Unfall beim Abschalten,
/ mittel X = MASSIVE LIGHT ELEMENT [START; END]

L = START, R = END
PICK L PER= R
 // Suche nach KonversionselementenPICK A[L] MAN X
L +=1
Artikel X
R 1
 / Bei BedarfELEI L PER=R, dann
METHODEN A[L] UND A[R]
L +=1
R 1

 / verbleibender Teil Eins und Zwei QUICKSORT(A, START, R)
QUICKSORT(A, L, END)
Dieses Verfahren kann einen Teil der Masse verzerren, so dass es ausreicht, die Parameter anzugeben START und END.

Vergleich der Arbeitszeit (in Sekunden) verschiedener Sortieralgorithmen für verschiedene Größen (in Sekunden)N:
NVeröffentlichungenBoxenGeschwindigkeit
5.0000,0390,0160.00031
150000,3590,1410.00078
500003.981.4690,00297

Bitte beachten Sie, dass der schnelle Abschreibungsalgorithmus langsam funktioniert, wenn das Supportelement der kleinste oder größte Teil der Liste ist. Unter diesen Bedingungen wird eine rasche Abstufung am schlimmsten durchgeführtO(n²).

Mischung
Algorithm wurde erfunden.John von Neuman1945.
Klassische Idee
(1) Wir nehmen die Masse. Wenn es aus einem Element besteht, ist es bereits vervierfacht.
(2) Sind die Elemente größer als eins, brechen wir das Volumen in zwei gleiche Teile (genau zu einem) und trennen jedes Teil durch den gleichen Algorithmus.
(3) Als nächstes, "Boden" alle gestreuten Teile in eine Masse.
Wie stellen Sie alle Teile in einem Satz?
  1. Wir behalten die Indizes des Beginns der beiden fragmentierten Teile.
  2. Erstellen Sie eine neue Liste wie folgt:
    1. der beiden Elemente, die durch die Indizes angegeben werden, werden wir eine kleinere auswählen und in die neue Liste eintragen;
    2. Wir werden den Index verschieben, den wir zum nächsten Element der Liste genommen haben;
    3. Wenn die Elemente in einem der schwimmenden Teile fertig sind, werden wir die Elemente des zweiten zum Ende der letzten Liste hinzufügen.
  3. Die identifizierte Liste sollte in den Schiebeteilen platziert werden.
Pseudocod von Fusionsalgorithmus
Die Funktion entlädt zwei Teile der Massea[left;mid)und[mid;right)
FUNCTION merge(a, links, Mitte, rechts) // a - mass, size n; links, Mitte, rechts - ganze Zahlen, Indizes von Elementen des Körpers
= 0
= 0
Ergebnis: int[rechts - links] /

POCA links + it1 buoy mid und mid + it2 buoyancy rechts
EPPLE a[left + it1] RO a[mid + it2]
Ergebnis[it1 + it2] = a[links + it1]
It1 +=1
INAT
Ergebnis[it1 + it2] = a[mid + it2]
It2 +=1

POCA links + it1 Etat Mitte
Ergebnis[it1 + it2] = a[links + it1]
It1 +=1

PIC Mitte + it2 PER rechts
Ergebnis[it1 + it2] = a[mid + it2]
It2 +=1

Für i OT 0 DA it1 + it2
a[left + i] = Ergebnis[i]

VERIFIZIERUNG eine

Fusionsalgorithmus
Die Funktion beschneidet den Teilabschnitt der Masse mit Halbwertsindizes[left; right)
FUNCTION mergeSortRecursive(a, links, rechts) // a - masse, links, rechts - Indizes halb gefragt für Sortierung
wenn links + 1 Grad = rechts
VERIFIZIERUNG eine
Mitte = (links + rechts) / 2
mergeSortRecursive(a, links, Mitte)
mergeSortRecursive(a, Mitte, rechts)
fusion(a, links, Mitte, rechts)
VERIFIZIERUNG eine

Fusionsalgorithmus
Iteralgorithmus verwendet O(logn) weniger Erinnerung, die an die Herausforderung gewöhnt war.
FUNCTION mergeSortIterative(a, n) // a - Masse; n = Masselänge
Für i OT 1 bis n, SIG i *= 2
Für j OT 0 bis n - i, SAS j += 2 * i
Zusammenführung(a, j, j + i, min(j + 2 * i, n)
VERIFIZIERUNG eine
Arbeitszeit
Um die Zeit der Arbeit zu schätzen, machen wir ein Rivalen-Verhältnis.
Lass mich los! T(n) - Längenverkleidung n, dann zu Fusionszwecken ist es fair:
T(n) = 2T(n/2)+O(n)
O(n)- die Zeit benötigt, um zwei Längen zu vergießen n
Wir unterzeichnen dieses Verhältnis:
T(n) = 2T(n/2) + О(n) = 4T(n/4) + 2O(n) = ... = T(1) + log(n)O(n) = O(nlog(n))
Komplexität des AlgorithmusO(nlog(n))
Zusätzliche Materialien
(1) MischungITMO Viki Conspects.