Heapsort -Zeitkomplexität

Heap -Sortierung, geschrieben als haufenweise, ist eine Art Sortieralgorithmus. Es dauert eine Liste, die teilweise bestellt wird und eine sortierte Liste daraus erstellt. Sortierung kann aufsteigend oder absteigend sein. In diesem Artikel steigt die Sortierung auf. Beachten Sie, dass Heapsort eine unvollständige ungewöhnliche Liste nicht sortiert. Es sortiert eine teilweise bestellte (sortierte) Liste. Diese teilweise bestellte Liste ist ein Haufen. In diesem Artikel handelt es sich bei dem Haufen, der in Betracht gezogen wird.

Ein Haufen wird als "teilweise geordnet" bezeichnet und nicht "teilweise sortiert". Das Wort "sortieren" bedeutet eine vollständige Bestellung (vollständige Sortierung). Ein Haufen ist nicht teilweise willkürlich bestellt. Ein Haufen wird nach einem Kriterium (Muster) teilweise geordnet, wie unten gezeigt.

Haufen besteht also aus zwei Phasen: Erstellen des Haufens und Extrahieren des geordneten Elements von der Oberseite des Haufens. In der zweiten Stufe wird nach jeder Extraktion der Haufen wieder aufgebaut. Jeder Wiederaufbau ist schneller als der ursprüngliche Bauprozess, da der Wiederaufbau aus einem vorherigen Build erfolgt, in dem ein Element entfernt wurde. Und damit sortiert Haufen eine völlig ungewöhnliche Liste.

Ziel dieses Artikels ist es, kurz die Haufen zu erklären und dann seine Zeitkomplexität zu erzeugen (siehe Bedeutung der Zeitkomplexität unten). Gegen Ende erfolgt die Codierung in C++.

Mindesthaufen

Ein Haufen kann ein minimaler Haufen oder ein maximaler Haufen sein. Ein Max-heap ist eines, bei dem das erste Element das höchste Element ist, und der gesamte Baum oder die entsprechende Liste ist teilweise in absteigender Reihenfolge bestellt. Ein Min-heap ist eines, bei dem das erste Element das geringste Element ist und die gesamte Liste teilweise in aufsteigender Reihenfolge bestellt wird. In diesem Artikel wird nur der Mindesthaufen berücksichtigt. Hinweis: Im Thema des Haufens wird auch ein Element als Knoten bezeichnet.

Ein Haufen ist ein kompletter binärer Baum. Der binäre Baum kann als Array (Liste) ausgedrückt werden; Lesen Sie von oben nach unten und von links nach rechts. Die Heap-Eigenschaft für einen Minimer ist, dass ein übergeordneter Knoten weniger oder gleich jedem seiner beiden Kinder ist. Ein Beispiel für eine ungeordnete Liste ist:

9	19	24	5	3	11	14	22	7	6	17	15	Null	Null	Null
0	1	2	3	4	5	6	7	8	9	10	11	12	13	14

Die erste Zeile dieser Tabelle sind die Elemente des Arrays. In der zweiten Reihe befinden sich die null basierten Indizes. Diese Liste von Elementen kann als Baum ausgedrückt werden. Die Nullelemente wurden hinzugefügt, um einen vollen binären Baum zu machen. Streng genommen sind die Nullelemente nicht Teil der Liste (Baum). Diese Liste hat keine Bestellung, daher ist sie noch kein Haufen. Es wird ein Haufen, wenn es laut Heap -Eigentum eine teilweise Bestellung hatte.

Beziehung zwischen Knoten und Indizes

Denken Sie daran, ein Haufen ist ein vollständiger binärer Baum, bevor die Heap -Konfiguration (Heap -Eigenschaft) aufgetreten ist. Die vorherige Liste ist noch kein Haufen, da die Elemente dem Haufen Eigentum nicht befolgen. Es wird ein Haufen, nachdem Elemente gemäß der Minen-Heibe-Immobilie in teilweise Reihenfolge neu angeordnet sind. Teilweise Ordnung kann als teilweise Sortierung angesehen werden (obwohl das Wort „Sort“ eine vollständige Bestellung bedeutet).

Ob ein binärer Baum ein Haufen ist oder nicht, jeder Elternteil hat zwei Kinder, außer den Blattknoten (letzte) Knoten. Es gibt eine mathematische Beziehung zwischen den Indizes zwischen jedem Elternteil und seinen Kindern. Es ist wie folgt: Wenn sich der übergeordnete Elternteil im Index I befindet, ist das linke Kind im Index:

2*i + 1

und das richtige Kind ist im Index:

2*i + 2

Dies ist für die nullbasierte Indexierung. Und so hat ein Elternteil am Index 0 sein linkes Kind am Index 2 × 0+1 = 1 und sein rechtes Kind bei 2 × 0+2 = 2. Ein Elternteil am Index 1 hat sein linkes Kind am Index 2 × 1+1 = 3 und das rechte Kind am Index 2 × 1+2 = 4; usw.

Durch das Minim-heap.

Haufen

Häufernde bedeutet, einen Haufen zu bauen. Es bedeutet, die Elemente einer Liste (oder eines entsprechenden Baums) neu zu ordnen, damit sie die Haufen Eigenschaft erfüllen. Am Ende des häufigen Prozesses ist die Liste oder der Baum ein Haufen.

Wenn die vorherige unsortierte Liste häufiger ist, wird sie:

3	5	11	7	6	15	14	22	9	19	17	24	Null	Null	Null
0	1	2	3	4	5	6	7	8	9	10	11	12	13	14

Hinweis: Es gibt 12 Elemente und nicht 15 in der Liste. In der zweiten Reihe sind die Indizes. Im Haufen Bauprozess mussten Elemente überprüft werden, und einige wurden ausgetauscht.

Beachten Sie, dass das kleinste und erste Element 3 ist. Der Rest der Elemente folgt auf aufsteigender, aber welliger Weise. Wenn die linken und rechten Kinder an den Positionen 2i+1 und 2i+2 jeweils größer als oder gleich dem Elternteil bei I sind, dann ist dies ein Min-H-Akzent. Dies ist nicht die volle Bestellung oder Sortierung. Dies ist eine teilweise Bestellung gemäß der Heap -Eigenschaft. Von hier aus beginnt die nächste Stufe für die Haufen Sortierung.

Zeitliche Komplexität höfen

Zeitkomplexität ist die relative Laufzeit eines Codes. Es kann als die Anzahl der Hauptvorgänge angesehen werden, damit dieser Code abgeschlossen ist. Es gibt verschiedene Algorithmen für das Haufen Gebäude. Die effizienteste und am schnellsten kontinuierlichsten die Liste durch zwei, überprüft die Elemente von unten und tauscht dann einige Elemente aus. Sei n die Anzahl der praktischen Elemente in der Liste. Mit diesem Algorithmus ist die maximale Anzahl der Hauptvorgänge (Swapping) n n. Die zeitliche Komplexität für das Häufen ist früher als:

An)

Wobei N ist n und die maximal mögliche Anzahl von Hauptvorgängen ist. Diese Notation wird als Big-O-Notation bezeichnet. Es beginnt mit O in Großbuchstaben, gefolgt von Klammern. Innerhalb der Klammern ist der Ausdruck für die mögliche höchste Anzahl von Operationen.

Denken Sie daran: Addition kann zu einer Multiplikation werden, wenn sich das gleiche hinzugefügt wird.

Heapsort -Illustration

Die vorherige unsortierte Liste wird verwendet, um die Haufen zu veranschaulichen. Die angegebene Liste lautet:

9 19 24 5 3 11 14 22 7 6 17 15

Der aus der Liste erzeugte Min-heap lautet:

3 5 11 7 6 15 14 22 9 19 17 24

Die erste Stufe im Haufen besteht darin, den produzierten Haufen zu produzieren. Dies ist eine teilweise bestellte Liste. Es ist keine sortierte (komplett sortierte) Liste.

Die zweite Stufe besteht darin, das geringste Element, das erste Element, aus dem Haufen zu entfernen, den verbleibenden Haufen neu zuzubereiten und die geringsten Elemente in den Ergebnissen zu entfernen. Das geringste Element ist immer das erste Element im neu geschlossenen Haufen. Die Elemente werden nicht entfernt und weggeworfen. Sie können in der Reihenfolge, in der sie entfernt werden, an ein anderes Array gesendet werden.

Am Ende hätte das Neue Array alle Elemente in aufsteigender Reihenfolge sortiert (vollständig); und nicht mehr nur teilweise bestellt.

In der zweiten Stufe ist das erste, was Sie tun müssen. Die Ergebnisse sind:

3

Und

5 11 7 6 15 14 22 9 19 17 24

Die verbleibenden Elemente müssen häufig gemacht werden, bevor das erste Element extrahiert wird. Der Haufen der verbleibenden Elemente kann werden:

5 6 7 9 15 14 22 11 19 17 24

Das Extrahieren von 5 und das Hinzufügen zur neuen Liste (Array) gibt die Ergebnisse an:

3 5

Und

6 7 9 15 14 22 11 19 17 24

Das Häpsen des verbleibenden Satzes würde geben:

6 7 9 15 14 22 11 19 17 24

Extrahieren 6 und Hinzufügen zur neuen Liste (Array) gibt die Ergebnisse an:

3 5 6

Und

7 9 15 14 22 11 19 17 24

Das Häpsen des verbleibenden Satzes würde geben:

7 9 11 14 22 15 19 17 24

Das Extrahieren von 7 und das Hinzufügen in die neue Liste gibt die Ergebnisse an:

3 5 6 7

Und

9 11 14 22 15 19 17 24

Häufern des verbleibenden Satzes gibt:

9 11 14 22 15 19 17 24

Das Extrahieren von 9 und das Hinzufügen zur neuen Liste gibt die Ergebnisse an:

3 5 6 7 9 9

Und

11 14 22 15 19 17 24

Häufern des verbleibenden Satzes gibt:

11 14 17 15 19 22 24

Das Extrahieren von 11 und das Hinzufügen in die neue Liste gibt die Ergebnisse an:

3 5 6 7 9 11

Und

14 17 15 19 22 24

Das Häpsen des verbleibenden Satzes würde geben:

14 17 15 19 22 24

Extrahieren 14 und Hinzufügen zur neuen Liste gibt die Ergebnisse an:

3 5 6 7 9 11 14 14

Und

17 15 19 22 24

Das Häpsen des verbleibenden Satzes würde geben:

15 17 19 22 24

15 extrahieren und in die neue Liste hinzuzufügen, gibt die Ergebnisse an:

3 5 6 7 9 11 14 15

Und

17 19 22 24

Das Häpsen des verbleibenden Satzes würde geben:

17 19 22 24

Das Extrahieren von 17 und das Hinzufügen in die neue Liste gibt die Ergebnisse an:

3 5 6 7 9 11 14 15 17

Und

19 22 24

Das Häpsen des verbleibenden Satzes würde geben:

19 22 24

Das Extrahieren von 19 und das Hinzufügen in die neue Liste gibt die Ergebnisse an:

3 5 6 7 9 11 14 15 17 19

Und

22 24

Häufern des verbleibenden Satzes gibt:

22 24

Extrahieren 22 und addiert es der neuen Liste ergibt die Ergebnisse:

3 5 6 7 9 11 14 15 17 19 22

Und

24

Häufern des verbleibenden Satzes gibt:

24

Extrahieren 24 und Hinzufügen in die neue Liste gibt die Ergebnisse an:

3 5 6 7 9 11 14 15 17 19 22 24

Und

- - -

Das Heap -Array ist jetzt leer. Alle Elemente, die es zu Beginn hatte.

Heapsortalgorithmus

Obwohl der Leser in Lehrbüchern gelesen hat, dass Haufen aus zwei Phasen besteht. Damit lautet der Algorithmus wie folgt wie folgt:

• Häateln Sie die unsortierte Liste.
• Extrahieren Sie das erste Element des Haufens und setzen Sie es als erstes Element der neuen Liste ein.
• Häpsen Sie die verbleibende Liste.
• Extrahieren Sie das erste Element des neuen Heaps und setzen Sie das nächste Element der neuen Liste.
• Wiederholen Sie die vorherigen Schritte in der Reihenfolge, bis die Haufenliste leer ist. Am Ende ist die neue Liste sortiert.

Haufensformenkomplexität richtig

Der einstufige Ansatz wird verwendet, um die zeitliche Komplexität von Haufen zu bestimmen. Angenommen, es gibt 8 unsortierte Elemente, die sortiert werden müssen.

Die mögliche maximale Anzahl von Operationen zum Heapifizieren der 8 Elemente beträgt 8 Elemente.
Die mögliche maximale Anzahl von Operationen zum Heapifizieren der verbleibenden 7 Elemente beträgt 7.
Die mögliche maximale Anzahl von Operationen zum Häpsen der verbleibenden 6 Elemente beträgt 6 Elemente.
Die mögliche maximale Anzahl von Operationen zum Häpsen der verbleibenden 5 Elemente beträgt 5 Elemente.
Die mögliche maximale Anzahl von Operationen zum Heapifizieren der verbleibenden 4 Elemente beträgt 4.
Die mögliche maximale Anzahl von Operationen zum Häpsen der verbleibenden 3 Elemente beträgt 3.
Die mögliche maximale Anzahl von Operationen zum Häpsen der verbleibenden 2 Elemente beträgt 2.
Die mögliche maximale Anzahl von Operationen zum Häpsen des verbleibenden 1 -Elements beträgt 1.

Die mögliche maximale Anzahl von Operationen ist:

8 + 7 + 6 + 5 + 4 + 3 + 2 + 1 = 36

Der Durchschnitt dieser Operationen ist:

36/8 = 4.5

Beachten Sie, dass sich die letzten vier Haufen in der vorherigen Abbildung nicht geändert haben, als das erste Element entfernt wurde. Einige der vorherigen Haufen änderten sich auch nicht, als das erste Element entfernt wurde. Damit beträgt eine bessere durchschnittliche Anzahl von Hauptvorgängen (Swappings) 3 und nicht 4.5. Eine bessere durchschnittliche Anzahl von Hauptvorgängen beträgt also:

24 = 8 x 3
=> 24 = 8 x log₂8

seit log₂8 = 3.

Im Allgemeinen beträgt die durchschnittliche Fallzeitkomplexität für Haufen:

An.log2n)

Wenn der Punkt die Multiplikation bedeutet und N ist n ist n, die Gesamtzahl der Elemente in der Liste (beide Liste).

Beachten Sie, dass der Betrieb des Extrahierens des ersten Elements ignoriert wurde. Zum Thema Zeitkomplexität werden Operationen, die relativ kurze Zeiten dauern, ignoriert.

Codierung in c++

In der Algorithmus -Bibliothek von C ++ gibt es eine Funktion make_heap (). Die Syntax ist:

Vorlage
contexpr void make_heap (RandomAccessiterator zuerst, RandomAccessiterator zuletzt, Compare comp);

Es nimmt den Iterator, der auf das erste Element eines Vektors zeigt, als erstes Argument und dann den Iterator, der direkt über das Ende des Vektors hinweist, als letztes Argument. Für die vorherige unsortierte Liste wird die Syntax wie folgt verwendet, um einen Mindesthaufen zu erhalten:

Vektor vtr = 9, 19, 24, 5, 3, 11, 14, 22, 7, 6, 17, 15;
Vektor:: iterator iterb = vtr.Start();
Vektor:: iterator itere = vtr.Ende();
make_heap (iterb, itere, größer());

Dieser Code ändert einen Vektorinhalt in eine minimale Heap -Konfiguration. In den folgenden C ++ - Vektoren werden zwei Vektoren anstelle von zwei Arrays verwendet.

Verwenden Sie die Vektorsyntax, um das erste Element eines Vektors zu kopieren und zurückzugeben:

contexpr referenzfront ();

Um das erste Element eines Vektors zu entfernen und wegzuwerfen, verwenden Sie die Vektorsyntax:

CONTEXPR ITERATOR ERASE (const_iteratorposition)

Verwenden Sie die Vektorsyntax, um ein Element an der Rückseite eines Vektors (nächstes Element) hinzuzufügen:

contexpr void push_back (const t & x);

Der Beginn des Programms ist:

#enthalten
#enthalten
#enthalten
Verwenden von Namespace STD;

Der Algorithmus und die Vektorbibliotheken sind enthalten. Als nächstes befindet sich im Programm die hapenort () -Funktion, die lautet:

Leerlaufhaufen (Vektor & Oldv, Vektor & newv)
if (Oldv.size ()> 0)
Vektor:: iterator iterb = oldv.Start();
Vektor:: iterator itere = oldv.Ende();
make_heap (iterb, itere, größer());
int next = oldv.Vorderseite();
Oldv.löschen (iterb);
NEWV.push_back (next);
Haufen (Oldv, Newv);

Es ist eine rekursive Funktion. Es verwendet die Funktion make_heap () der C ++ - Algorithmus -Bibliothek. Das zweite Codesegment in der Funktionsdefinition extrahiert das erste Element aus dem alten Vektor nach dem Haufen Gebäude und fügt das nächste Element für den neuen Vektor hinzu. Beachten Sie, dass in der Funktionsdefinition die Vektorparameter Referenzen sind, während die Funktion mit den Bezeichnern (Namen) aufgerufen wird.

Eine geeignete C ++ - Hauptfunktion dafür ist:

int main (int argc, char ** argv)

Vektor Oldv = 9, 19, 24, 5, 3, 11, 14, 22, 7, 6, 17, 15;
Vektor Newv;
Haufen (Oldv, Newv);
für (int i = 0; iCout << newV[i] << ";

Cout << endl;
Rückkehr 0;

Die Ausgabe ist:

3 5 6 7 9 11 14 15 17 19 22 24

sortiert (vollständig).

Abschluss

Der Artikel, der ausführlich die Art und Funktion der Haufensart erörtert, die allgemein als Heapsort bezeichnet wird, als Sortieralgorithmus. Heulenkomplexität, Haufensortillustration und Haufen als Algorithmus wurden abgedeckt und anhand von Beispielen unterstützt. Die durchschnittliche Zeitkomplexität für ein gut geschriebenes Heapsort-Programm ist O (NLOG (N))