Heapsort
Datenstrukturen und Algorithmen
Vorlesung 8: Heapsort (K6)
Joost-Pieter Katoen
Lehrstuhl für Informatik 2 Software Modeling and Verification Group
https://moves.rwth-aachen.de/teaching/ss-18/dsal/
14. Mai 2018
Heapsort
Übersicht
1 Heaps
2 Heapaufbau
3 Heapsort
4 Anwendung: Prioritätswarteschlangen
Heapsort Heaps
Übersicht
1 Heaps
2 Heapaufbau
3 Heapsort
4 Anwendung: Prioritätswarteschlangen
Heapsort Heaps
Heaps
Heap (Haufen)
Ein Heapist ein Binärbaum, der Elemente mit Schlüsseln enthält und in ein Array eingebettet ist. Die Heap-Bedingung für Max-Heaps fordert:
I Der Schlüssel eines Knotens ist stets größer als (bzw. mindestens so groß wie) die Schlüssel seiner Kinder.
Weiter gilt:
I Alle Ebenen, abgesehen von evtl. der untersten, sind komplett gefüllt.
I Die Blätter befinden sich damit alle auf einer (höchstens zwei) Ebene(n).
I Die Blätter der untersten Ebene sind linksbündig angeordnet.
Heapsort Heaps
Heaps
Heap (Haufen)
Ein Heapist ein Binärbaum, der Elemente mit Schlüsseln enthält und in ein Array eingebettet ist. Die Heap-Bedingung für Max-Heaps fordert:
I Der Schlüssel eines Knotens ist stets größer als (bzw. mindestens so groß wie) die Schlüssel seiner Kinder.
Weiter gilt:
I Alle Ebenen, abgesehen von evtl. der untersten, sind komplett gefüllt.
I Die Blätter befinden sich damit alle auf einer (höchstens zwei) Ebene(n).
I Die Blätter der untersten Ebene sind linksbündig angeordnet.
Heapsort Heaps
Heaps
Heap (Haufen)
Ein Heapist ein Binärbaum, der Elemente mit Schlüsseln enthält und in ein Array eingebettet ist. Die Heap-Bedingung für Max-Heaps fordert:
I Der Schlüssel eines Knotens ist stets größer als (bzw. mindestens so groß wie) die Schlüssel seiner Kinder.
Weiter gilt:
I Alle Ebenen, abgesehen von evtl. der untersten, sind komplett gefüllt.
I Die Blätter befinden sich damit alle auf einer (höchstens zwei) Ebene(n).
I Die Blätter der untersten Ebene sind linksbündig angeordnet.
Heapsort Heaps
Heaps
Heap (Haufen)
Ein Heapist ein Binärbaum, der Elemente mit Schlüsseln enthält und in ein Array eingebettet ist. Die Heap-Bedingung für Max-Heaps fordert:
I Der Schlüssel eines Knotens ist stets größer als (bzw. mindestens so groß wie) die Schlüssel seiner Kinder.
Weiter gilt:
I Alle Ebenen, abgesehen von evtl. der untersten, sind komplett gefüllt.
I Die Blätter befinden sich damit alle auf einer (höchstens zwei) Ebene(n).
I Die Blätter der untersten Ebene sind linksbündig angeordnet.
Heapsort Heaps
Heaps
Heap (Haufen)
Ein Heapist ein Binärbaum, der Elemente mit Schlüsseln enthält und in ein Array eingebettet ist. Die Heap-Bedingung für Max-Heaps fordert:
I Der Schlüssel eines Knotens ist stets größer als (bzw. mindestens so groß wie) die Schlüssel seiner Kinder.
Weiter gilt:
I Alle Ebenen, abgesehen von evtl. der untersten, sind komplett gefüllt.
I Die Blätter befinden sich damit alle auf einer (höchstens zwei) Ebene(n).
I Die Blätter der untersten Ebene sind linksbündig angeordnet.
Heapsort Heaps
Arrayeinbettung eines Heaps
Arrayeinbettung
Das Array awird wie folgt als Binärbaum aufgefasst:
I Die Wurzel liegt in E[0].
I Das linke Kind vona[i] liegt in E[2 * i + 1].
I Das rechte Kind von a[i] liegt in E[2 * i + 2].
Beispiel
16 14 8 2 4
7 1
10
9 3
16 14 10 8 7 9 3 2 4 1
0
0 1
1
2
2 3
3 4
4 5
5
6
6 7
7 8
8 9
9
I Durch die möglichst vollständige Füllung der Ebenen werden „Löcher“ im Array vermieden.
I Vergrößert man den Baum um ein Element, so wird das Array gerade um ein Element länger.
Heapsort Heaps
Arrayeinbettung eines Heaps
Arrayeinbettung
Das Array awird wie folgt als Binärbaum aufgefasst:
I Die Wurzel liegt in E[0].
I Das linke Kind vona[i] liegt in E[2 * i + 1].
I Das rechte Kind von a[i] liegt in E[2 * i + 2].
Beispiel
16 14 8 2 4
7 1
10
9 3
16 14 10 8 7 9 3 2 4 1
0
0 1
1
2
2 3
3 4
4 5
5
6
6 7
7 8
8 9
9
I Durch die möglichst vollständige Füllung der Ebenen werden „Löcher“ im Array vermieden.
I Vergrößert man den Baum um ein Element, so wird das Array gerade um ein Element länger.
Heapsort Heaps
Arrayeinbettung eines Heaps
Arrayeinbettung
Das Array awird wie folgt als Binärbaum aufgefasst:
I Die Wurzel liegt in E[0].
I Das linke Kind vona[i] liegt in E[2 * i + 1].
I Das rechte Kind von a[i] liegt in E[2 * i + 2].
Beispiel
16 14 8 2 4
7 1
10
9 3
16 14 10 8 7 9 3 2 4 1
0
0 1
1
2
2 3
3 4
4 5
5
6
6 7
7 8
8 9
9
I Durch die möglichst vollständige Füllung der Ebenen werden „Löcher“ im Array vermieden.
I Vergrößert man den Baum um ein Element, so wird das Array gerade um ein Element länger.
Heapsort Heaps
Arrayeinbettung eines Heaps
Arrayeinbettung
Das Array awird wie folgt als Binärbaum aufgefasst:
I Die Wurzel liegt in E[0].
I Das linke Kind vona[i] liegt in E[2 * i + 1].
I Das rechte Kind von a[i] liegt in E[2 * i + 2].
Beispiel
16 14 8 2 4
7 1
10
9 3
16 14 10 8 7 9 3 2 4 1
0
0 1
1
2
2 3
3 4
4 5
5
6
6 7
7 8
8 9
9 I Durch die möglichst vollständige Füllung der Ebenen werden „Löcher“
im Array vermieden.
I Vergrößert man den Baum um ein Element, so wird das Array gerade um ein Element länger.
Heapsort Heaps
Arrayeinbettung eines Heaps
Arrayeinbettung
Das Array awird wie folgt als Binärbaum aufgefasst:
I Die Wurzel liegt in E[0].
I Das linke Kind vona[i] liegt in E[2 * i + 1].
I Das rechte Kind von a[i] liegt in E[2 * i + 2].
Beispiel
16 14 8 2 4
7 1
10
9 3
16 14 10 8 7 9 3 2 4 1
0
0 1
1
2
2 3
3 4
4 5
5
6
6 7
7 8
8 9
9 I Durch die möglichst vollständige Füllung der Ebenen werden „Löcher“
im Array vermieden.
I Vergrößert man den Baum um ein Element, so wird das Array gerade um ein Element länger.
Heapsort Heaps
Heaps – Eigenschaften
Lemma
Vergrößert man den Schlüssel der Wurzel, dann bleibt der Baum ein Heap.
Lemma
Jedes Array „ist ein Heap“ ab Position bn2c.
I Ein Heap hat bn2cinnere Knoten.
Heapsort Heaps
Heaps – Eigenschaften
Lemma
Vergrößert man den Schlüssel der Wurzel, dann bleibt der Baum ein Heap.
Lemma
Jedes Array „ist ein Heap“ ab Position bn2c.
I Ein Heap hat bn2cinnere Knoten.
Heapsort Heaps
Heaps – Eigenschaften
Lemma
Vergrößert man den Schlüssel der Wurzel, dann bleibt der Baum ein Heap.
Lemma
Jedes Array „ist ein Heap“ ab Position bn2c.
I Ein Heap hat bn2c innere Knoten.
Heapsort Heapaufbau
Übersicht
1 Heaps
2 Heapaufbau
3 Heapsort
4 Anwendung: Prioritätswarteschlangen
Heapsort Heapaufbau
Naiver Heapaufbau
2 7
3
9 4
14 15
10
8 16
2 7 10 3 14 8 16 9 4 15
Heapaufbau, naiv
Der Heap wird von oben nach unten (top-down) aufgebaut, indem
I ein neues Element möglichst weit links angefügt wird und
Heapsort Heapaufbau
Naiver Heapaufbau
2 7
3
9 4
14 15
10
8 16
2 7 10 3 14 8 16 9 4 15
Heapaufbau, naiv
Der Heap wird von oben nach unten (top-down) aufgebaut, indem
I ein neues Element möglichst weit links angefügt wird und
I rekursiv nach oben getauscht wird, solange es größer als sein Elternknoten ist.
Heapsort Heapaufbau
Naiver Heapaufbau
7 2
3
9 4
14 15
10
8 16
7 2 10 3 14 8 16 9 4 15
Heapaufbau, naiv
Der Heap wird von oben nach unten (top-down) aufgebaut, indem
I ein neues Element möglichst weit links angefügt wird und
Heapsort Heapaufbau
Naiver Heapaufbau
7 2
3
9 4
14 15
10
8 16
7 2 10 3 14 8 16 9 4 15
Heapaufbau, naiv
Der Heap wird von oben nach unten (top-down) aufgebaut, indem
I ein neues Element möglichst weit links angefügt wird und
I rekursiv nach oben getauscht wird, solange es größer als sein Elternknoten ist.
Heapsort Heapaufbau
Naiver Heapaufbau
10 2
3
9 4
14 15
7
8 16
10 2 7 3 14 8 16 9 4 15
Heapaufbau, naiv
Der Heap wird von oben nach unten (top-down) aufgebaut, indem
I ein neues Element möglichst weit links angefügt wird und
Heapsort Heapaufbau
Naiver Heapaufbau
10 2
3
9 4
14 15
7
8 16
10 2 7 3 14 8 16 9 4 15
Heapaufbau, naiv
Der Heap wird von oben nach unten (top-down) aufgebaut, indem
I ein neues Element möglichst weit links angefügt wird und
I rekursiv nach oben getauscht wird, solange es größer als sein Elternknoten ist.
Heapsort Heapaufbau
Naiver Heapaufbau
10 3
2
9 4
14 15
7
8 16
10 3 7 2 14 8 16 9 4 15
Heapaufbau, naiv
Der Heap wird von oben nach unten (top-down) aufgebaut, indem
I ein neues Element möglichst weit links angefügt wird und
Heapsort Heapaufbau
Naiver Heapaufbau
10 3
2
9 4
14 15
7
8 16
10 3 7 2 14 8 16 9 4 15
Heapaufbau, naiv
Der Heap wird von oben nach unten (top-down) aufgebaut, indem
I ein neues Element möglichst weit links angefügt wird und
I rekursiv nach oben getauscht wird, solange es größer als sein Elternknoten ist.
Heapsort Heapaufbau
Naiver Heapaufbau
10 14
2
9 4
3 15
7
8 16
10 14 7 2 3 8 16 9 4 15
Heapaufbau, naiv
Der Heap wird von oben nach unten (top-down) aufgebaut, indem
I ein neues Element möglichst weit links angefügt wird und
Heapsort Heapaufbau
Naiver Heapaufbau
14 10
2
9 4
3 15
7
8 16
14 10 7 2 3 8 16 9 4 15
Heapaufbau, naiv
Der Heap wird von oben nach unten (top-down) aufgebaut, indem
I ein neues Element möglichst weit links angefügt wird und
I rekursiv nach oben getauscht wird, solange es größer als sein Elternknoten ist.
Heapsort Heapaufbau
Naiver Heapaufbau
14 10
2
9 4
3 15
7
8 16
14 10 7 2 3 8 16 9 4 15
Heapaufbau, naiv
Der Heap wird von oben nach unten (top-down) aufgebaut, indem
I ein neues Element möglichst weit links angefügt wird und
Heapsort Heapaufbau
Naiver Heapaufbau
14 10
2
9 4
3 15
8
7 16
14 10 8 2 3 7 16 9 4 15
Heapaufbau, naiv
Der Heap wird von oben nach unten (top-down) aufgebaut, indem
I ein neues Element möglichst weit links angefügt wird und
I rekursiv nach oben getauscht wird, solange es größer als sein Elternknoten ist.
Heapsort Heapaufbau
Naiver Heapaufbau
14 10
2
9 4
3 15
8
7 16
14 10 8 2 3 7 16 9 4 15
Heapaufbau, naiv
Der Heap wird von oben nach unten (top-down) aufgebaut, indem
I ein neues Element möglichst weit links angefügt wird und
Heapsort Heapaufbau
Naiver Heapaufbau
14 10
2
9 4
3 15
16
7 8
14 10 16 2 3 7 8 9 4 15
Heapaufbau, naiv
Der Heap wird von oben nach unten (top-down) aufgebaut, indem
I ein neues Element möglichst weit links angefügt wird und
I rekursiv nach oben getauscht wird, solange es größer als sein Elternknoten ist.
Heapsort Heapaufbau
Naiver Heapaufbau
16 10
2
9 4
3 15
14
7 8
16 10 14 2 3 7 8 9 4 15
Heapaufbau, naiv
Der Heap wird von oben nach unten (top-down) aufgebaut, indem
I ein neues Element möglichst weit links angefügt wird und
Heapsort Heapaufbau
Naiver Heapaufbau
16 10
2
9 4
3 15
14
7 8
16 10 14 2 3 7 8 9 4 15
Heapaufbau, naiv
Der Heap wird von oben nach unten (top-down) aufgebaut, indem
I ein neues Element möglichst weit links angefügt wird und
I rekursiv nach oben getauscht wird, solange es größer als sein Elternknoten ist.
Heapsort Heapaufbau
Naiver Heapaufbau
16 10
9
2 4
3 15
14
7 8
16 10 14 9 3 7 8 2 4 15
Heapaufbau, naiv
Der Heap wird von oben nach unten (top-down) aufgebaut, indem
I ein neues Element möglichst weit links angefügt wird und
Heapsort Heapaufbau
Naiver Heapaufbau
16 10
9
2 4
3 15
14
7 8
16 10 14 9 3 7 8 2 4 15
Heapaufbau, naiv
Der Heap wird von oben nach unten (top-down) aufgebaut, indem
I ein neues Element möglichst weit links angefügt wird und
I rekursiv nach oben getauscht wird, solange es größer als sein Elternknoten ist.
Heapsort Heapaufbau
Naiver Heapaufbau
16 10
9
2 4
3 15
14
7 8
16 10 14 9 3 7 8 2 4 15
Heapaufbau, naiv
Der Heap wird von oben nach unten (top-down) aufgebaut, indem
I ein neues Element möglichst weit links angefügt wird und
Heapsort Heapaufbau
Naiver Heapaufbau
16 10
9
2 4
15 3
14
7 8
16 10 14 9 15 7 8 2 4 3
Heapaufbau, naiv
Der Heap wird von oben nach unten (top-down) aufgebaut, indem
I ein neues Element möglichst weit links angefügt wird und
I rekursiv nach oben getauscht wird, solange es größer als sein Elternknoten ist.
Heapsort Heapaufbau
Naiver Heapaufbau
16 15
9
2 4
10 3
14
7 8
16 15 14 9 10 7 8 2 4 3
Heapaufbau, naiv
Der Heap wird von oben nach unten (top-down) aufgebaut, indem
I ein neues Element möglichst weit links angefügt wird und
Heapsort Heapaufbau
Naiver Heapaufbau – Algorithmus und Analyse
1void bubble(int E[], int pos) {
2 while (pos > 0) {
3 int parent = (pos - 1) / 2;
4 if (E[parent] > E[pos]) {
5 break;
6 }
7 swap(E[parent], E[pos]);
8 pos = parent;
9 }
10}
Die Höhe k eines Heaps mit n Elementen ist beschränkt durch: n62k+1−1 ⇒ k =blog2nc
I Damit kostet jedes Einfügen k≈log2n Vergleiche.
⇒ Zum Aufbau eines Heaps mitn Elementen benötigt man Θ(n·log(n)) Vergleiche.
Es geht effizienter: heapify (auch: sink, fixheap) [Floyd 1964]
Heapsort Heapaufbau
Naiver Heapaufbau – Algorithmus und Analyse
1void bubble(int E[], int pos) {
2 while (pos > 0) {
3 int parent = (pos - 1) / 2;
4 if (E[parent] > E[pos]) {
5 break;
6 }
7 swap(E[parent], E[pos]);
8 pos = parent;
9 }
10}
Die Höhe k eines Heaps mit n Elementen ist beschränkt durch:
n62k+1−1 ⇒ k =blog2nc
I Damit kostet jedes Einfügen k≈log2n Vergleiche.
⇒ Zum Aufbau eines Heaps mitn Elementen benötigt man Θ(n·log(n)) Vergleiche.
Es geht effizienter: heapify (auch: sink, fixheap) [Floyd 1964]
Heapsort Heapaufbau
Naiver Heapaufbau – Algorithmus und Analyse
1void bubble(int E[], int pos) {
2 while (pos > 0) {
3 int parent = (pos - 1) / 2;
4 if (E[parent] > E[pos]) {
5 break;
6 }
7 swap(E[parent], E[pos]);
8 pos = parent;
9 }
10}
Die Höhe k eines Heaps mit n Elementen ist beschränkt durch:
n62k+1−1 ⇒ k =blog2nc
I Damit kostet jedes Einfügen k≈log2n Vergleiche.
⇒ Zum Aufbau eines Heaps mitn Elementen benötigt man Θ(n·log(n)) Vergleiche.
Es geht effizienter: heapify (auch: sink, fixheap) [Floyd 1964]
Heapsort Heapaufbau
Naiver Heapaufbau – Algorithmus und Analyse
1void bubble(int E[], int pos) {
2 while (pos > 0) {
3 int parent = (pos - 1) / 2;
4 if (E[parent] > E[pos]) {
5 break;
6 }
7 swap(E[parent], E[pos]);
8 pos = parent;
9 }
10}
Die Höhe k eines Heaps mit n Elementen ist beschränkt durch:
n62k+1−1 ⇒ k =blog2nc
I Damit kostet jedes Einfügen k≈log2n Vergleiche.
⇒ Zum Aufbau eines Heaps mitn Elementen benötigt man Θ(n·log(n))
Es geht effizienter: heapify (auch: sink, fixheap) [Floyd 1964]
Heapsort Heapaufbau
Naiver Heapaufbau – Algorithmus und Analyse
1void bubble(int E[], int pos) {
2 while (pos > 0) {
3 int parent = (pos - 1) / 2;
4 if (E[parent] > E[pos]) {
5 break;
6 }
7 swap(E[parent], E[pos]);
8 pos = parent;
9 }
10}
Die Höhe k eines Heaps mit n Elementen ist beschränkt durch:
n62k+1−1 ⇒ k =blog2nc
I Damit kostet jedes Einfügen k≈log2n Vergleiche.
⇒ Zum Aufbau eines Heaps mitn Elementen benötigt man Θ(n·log(n)) Vergleiche.
Es geht effizienter: heapify (auch: sink, fixheap) [Floyd 1964]
Heapsort Heapaufbau
Heapify – Strategie
Betrachte E[i] unter der Annahme, dass der rechte und linke Teilbaum bereits ein Heap ist.
I E[i] kann kleiner als seine Kinder sein.
I Wir wollen die beiden Teilbäume – Heaps – zusammen mit E[i] zu einem (Gesamt-)Heap verschmelzen.
I Dazu lassen wirE[i] in den Heap hineinsinken, sodass der Teilbaum mit WurzelE[i] ein Heap ist.
Heapify
I Finde das Maximumder Werte E[i] und seiner Kinder.
I IstE[i] bereits das größte Element, dann ist dieser gesamte Teilbaum auch ein Heap. Fertig.
I Andernfalls tauscheE[i]mit dem größten Element und führe Heapify in diesem Unterbaum weiter aus.
Heapsort Heapaufbau
Heapify – Strategie
Betrachte E[i] unter der Annahme, dass der rechte und linke Teilbaum bereits ein Heap ist.
I E[i] kann kleiner als seine Kinder sein.
I Wir wollen die beiden Teilbäume – Heaps – zusammen mit E[i] zu einem (Gesamt-)Heap verschmelzen.
I Dazu lassen wirE[i] in den Heap hineinsinken, sodass der Teilbaum mit WurzelE[i] ein Heap ist.
Heapify
I Finde das Maximumder Werte E[i] und seiner Kinder.
I IstE[i] bereits das größte Element, dann ist dieser gesamte Teilbaum auch ein Heap. Fertig.
I Andernfalls tauscheE[i]mit dem größten Element und führe Heapify in diesem Unterbaum weiter aus.
Heapsort Heapaufbau
Heapify – Strategie
Betrachte E[i] unter der Annahme, dass der rechte und linke Teilbaum bereits ein Heap ist.
I E[i] kann kleiner als seine Kinder sein.
I Wir wollen die beiden Teilbäume – Heaps – zusammen mit E[i] zu einem (Gesamt-)Heap verschmelzen.
I Dazu lassen wirE[i] in den Heap hineinsinken, sodass der Teilbaum mit WurzelE[i] ein Heap ist.
Heapify
I Finde das Maximumder Werte E[i] und seiner Kinder.
I IstE[i] bereits das größte Element, dann ist dieser gesamte Teilbaum auch ein Heap. Fertig.
I Andernfalls tauscheE[i]mit dem größten Element und führe Heapify in diesem Unterbaum weiter aus.
Heapsort Heapaufbau
Heapify – Strategie
Betrachte E[i] unter der Annahme, dass der rechte und linke Teilbaum bereits ein Heap ist.
I E[i] kann kleiner als seine Kinder sein.
I Wir wollen die beiden Teilbäume – Heaps – zusammen mit E[i] zu einem (Gesamt-)Heap verschmelzen.
I Dazu lassen wirE[i] in den Heap hineinsinken, sodass der Teilbaum mit WurzelE[i] ein Heap ist.
Heapify
I Finde das Maximumder Werte E[i] und seiner Kinder.
I IstE[i] bereits das größte Element, dann ist dieser gesamte Teilbaum auch ein Heap. Fertig.
I Andernfalls tauscheE[i]mit dem größten Element und führe Heapify in diesem Unterbaum weiter aus.
Heapsort Heapaufbau
Heapify – Strategie
Betrachte E[i] unter der Annahme, dass der rechte und linke Teilbaum bereits ein Heap ist.
I E[i] kann kleiner als seine Kinder sein.
I Wir wollen die beiden Teilbäume – Heaps – zusammen mit E[i] zu einem (Gesamt-)Heap verschmelzen.
I Dazu lassen wirE[i] in den Heap hineinsinken, sodass der Teilbaum mit WurzelE[i] ein Heap ist.
Heapify
I Finde das Maximumder Werte E[i] und seiner Kinder.
I IstE[i] bereits das größte Element, dann ist dieser gesamte Teilbaum auch ein Heap. Fertig.
I Andernfalls tauscheE[i]mit dem größten Element und führe Heapify in diesem Unterbaum weiter aus.
Heapsort Heapaufbau
Heapify – Strategie
Betrachte E[i] unter der Annahme, dass der rechte und linke Teilbaum bereits ein Heap ist.
I E[i] kann kleiner als seine Kinder sein.
I Wir wollen die beiden Teilbäume – Heaps – zusammen mit E[i] zu einem (Gesamt-)Heap verschmelzen.
I Dazu lassen wirE[i] in den Heap hineinsinken, sodass der Teilbaum mit WurzelE[i] ein Heap ist.
Heapify
I Finde das Maximumder Werte E[i] und seiner Kinder.
I IstE[i] bereits das größte Element, dann ist dieser gesamte Teilbaum auch ein Heap. Fertig.
I Andernfalls tauscheE[i] mit dem größten Element und führe Heapify in diesem Unterbaum weiter aus.
Heapsort Heapaufbau
Heapify – Algorithmus und Beispiel
1void heapify(int E[], int n, int pos) {
2 int next = 2 * pos + 1;
3 while (next < n) {
4 if (next + 1 < n &&
5 E[next + 1] > E[next]) {
6 next = next + 1;
7 }
8 if (E[pos] >= E[next]) {
9 break;
10 }
11 swap(E[pos], E[next]);
12 pos = next;
13 next = 2 * pos + 1;
14 }
15}
12 16
14
2 8
7 1
10
9 3
12 16 10 14 7 9 3 2 8 1
0
1 2
3 4 5 6
7 8 9
Heapsort Heapaufbau
Heapify – Algorithmus und Beispiel
1void heapify(int E[], int n, int pos) {
2 int next = 2 * pos + 1;
3 while (next < n) {
4 if (next + 1 < n &&
5 E[next + 1] > E[next]) {
6 next = next + 1;
7 }
8 if (E[pos] >= E[next]) {
9 break;
10 }
11 swap(E[pos], E[next]);
12 pos = next;
13 next = 2 * pos + 1;
14 }
15}
16 12
14
2 8
7 1
10
9 3
16 12 10 14 7 9 3 2 8 1
0
1 2
3 4 5 6
7 8 9
Heapsort Heapaufbau
Heapify – Algorithmus und Beispiel
1void heapify(int E[], int n, int pos) {
2 int next = 2 * pos + 1;
3 while (next < n) {
4 if (next + 1 < n &&
5 E[next + 1] > E[next]) {
6 next = next + 1;
7 }
8 if (E[pos] >= E[next]) {
9 break;
10 }
11 swap(E[pos], E[next]);
12 pos = next;
13 next = 2 * pos + 1;
14 }
15}
16 14
12
2 8
7 1
10
9 3
16 14 10 12 7 9 3 2 8 1
0
1 2
3 4 5 6
7 8 9
Heapsort Heapaufbau
Heapaufbau – Algorithmus und Beispiel
Strategie: Wandle das Array von unten nach oben (bottom-up) in einen Heap um.
2 7
3
9 4
14 15
10
8 16
1void buildHeap(int E[]) {
2 for (int i = E.length / 2 - 1; i >= 0; i--) {
3 heapify(E, E.length, i);
4 }
5}
Schleifeninvariant: Nach jedem Aufruf vonheapify(E, E.length, i) sind die Knoteni, . . . , E.length - 1 schon Wurzeln von Heaps.
Heapsort Heapaufbau
Heapaufbau – Algorithmus und Beispiel
Strategie: Wandle das Array von unten nach oben (bottom-up) in einen Heap um.
2 7
3
9 4
14 15
10
8 16
1void buildHeap(int E[]) {
2 for (int i = E.length / 2 - 1; i >= 0; i--) {
3 heapify(E, E.length, i);
4 }
5}
Heapsort Heapaufbau
Heapaufbau – Algorithmus und Beispiel
Strategie: Wandle das Array von unten nach oben (bottom-up) in einen Heap um.
2 7
3
9 4
15 14
10
8 16
1void buildHeap(int E[]) {
2 for (int i = E.length / 2 - 1; i >= 0; i--) {
3 heapify(E, E.length, i);
4 }
5}
Schleifeninvariant: Nach jedem Aufruf vonheapify(E, E.length, i) sind die Knoteni, . . . , E.length - 1 schon Wurzeln von Heaps.
Heapsort Heapaufbau
Heapaufbau – Algorithmus und Beispiel
Strategie: Wandle das Array von unten nach oben (bottom-up) in einen Heap um.
2 7
3
9 4
15 14
10
8 16
1void buildHeap(int E[]) {
2 for (int i = E.length / 2 - 1; i >= 0; i--) {
3 heapify(E, E.length, i);
4 }
5}
Heapsort Heapaufbau
Heapaufbau – Algorithmus und Beispiel
Strategie: Wandle das Array von unten nach oben (bottom-up) in einen Heap um.
2 7
9
3 4
15 14
10
8 16
1void buildHeap(int E[]) {
2 for (int i = E.length / 2 - 1; i >= 0; i--) {
3 heapify(E, E.length, i);
4 }
5}
Schleifeninvariant: Nach jedem Aufruf vonheapify(E, E.length, i) sind die Knoteni, . . . , E.length - 1 schon Wurzeln von Heaps.
Heapsort Heapaufbau
Heapaufbau – Algorithmus und Beispiel
Strategie: Wandle das Array von unten nach oben (bottom-up) in einen Heap um.
2 7
9
3 4
15 14
10
8 16
1void buildHeap(int E[]) {
2 for (int i = E.length / 2 - 1; i >= 0; i--) {
3 heapify(E, E.length, i);
4 }
5}
Heapsort Heapaufbau
Heapaufbau – Algorithmus und Beispiel
Strategie: Wandle das Array von unten nach oben (bottom-up) in einen Heap um.
2 7
9
3 4
15 14
16
8 10
1void buildHeap(int E[]) {
2 for (int i = E.length / 2 - 1; i >= 0; i--) {
3 heapify(E, E.length, i);
4 }
5}
Schleifeninvariant: Nach jedem Aufruf vonheapify(E, E.length, i) sind die Knoteni, . . . , E.length - 1 schon Wurzeln von Heaps.
Heapsort Heapaufbau
Heapaufbau – Algorithmus und Beispiel
Strategie: Wandle das Array von unten nach oben (bottom-up) in einen Heap um.
2 7
9
3 4
15 14
16
8 10
1void buildHeap(int E[]) {
2 for (int i = E.length / 2 - 1; i >= 0; i--) {
3 heapify(E, E.length, i);
4 }
5}
Heapsort Heapaufbau
Heapaufbau – Algorithmus und Beispiel
Strategie: Wandle das Array von unten nach oben (bottom-up) in einen Heap um.
2 15 9
3 4
7 14
16
8 10
1void buildHeap(int E[]) {
2 for (int i = E.length / 2 - 1; i >= 0; i--) {
3 heapify(E, E.length, i);
4 }
5}
Schleifeninvariant: Nach jedem Aufruf vonheapify(E, E.length, i) sind die Knoteni, . . . , E.length - 1 schon Wurzeln von Heaps.
Heapsort Heapaufbau
Heapaufbau – Algorithmus und Beispiel
Strategie: Wandle das Array von unten nach oben (bottom-up) in einen Heap um.
2 15 9
3 4
14 7
16
8 10
1void buildHeap(int E[]) {
2 for (int i = E.length / 2 - 1; i >= 0; i--) {
3 heapify(E, E.length, i);
4 }
5}
Heapsort Heapaufbau
Heapaufbau – Algorithmus und Beispiel
Strategie: Wandle das Array von unten nach oben (bottom-up) in einen Heap um.
2 15 9
3 4
14 7
16
8 10
1void buildHeap(int E[]) {
2 for (int i = E.length / 2 - 1; i >= 0; i--) {
3 heapify(E, E.length, i);
4 }
5}
Schleifeninvariant: Nach jedem Aufruf vonheapify(E, E.length, i) sind die Knoteni, . . . , E.length - 1 schon Wurzeln von Heaps.
Heapsort Heapaufbau
Heapaufbau – Algorithmus und Beispiel
Strategie: Wandle das Array von unten nach oben (bottom-up) in einen Heap um.
16 15
9
3 4
14 7
2
8 10
1void buildHeap(int E[]) {
2 for (int i = E.length / 2 - 1; i >= 0; i--) {
3 heapify(E, E.length, i);
4 }
5}
Heapsort Heapaufbau
Heapaufbau – Algorithmus und Beispiel
Strategie: Wandle das Array von unten nach oben (bottom-up) in einen Heap um.
16 15
9
3 4
14 7
10
8 2
1void buildHeap(int E[]) {
2 for (int i = E.length / 2 - 1; i >= 0; i--) {
3 heapify(E, E.length, i);
4 }
5}
Schleifeninvariant: Nach jedem Aufruf vonheapify(E, E.length, i) sind die Knoteni, . . . , E.length - 1 schon Wurzeln von Heaps.
Heapsort Heapaufbau
Konstruktion eines Heaps
Lemma
Der Algorithmus buildHeapist korrekt und terminiert.
I Initialisierung: Jeder Knoteni =bn/2c, bn/2c+ 1,. . . ist ein Blatt und damit Wurzel eines trivialen Heaps.
I Schleifeninvariante: Zu Beginn derfor-Schleife ist jeder Knoten i+1,. . .,E.length die Wurzel eines Heaps.
I In jeder Iteration sind alle Kinder des Knotensi bereits Wurzeln eines Heaps (Schleifeninvariante).
⇒ Bedingung für den Aufruf von heapifyist erfüllt.
I Dekrementierung von i stellt Schleifeninvariante wieder her.
I Terminierung: Beii = 0 ist gemäß Schleifeninvariante jeder Knoten 1, 2,. . .,n die Wurzel eines Heaps.
Heapsort Heapaufbau
Konstruktion eines Heaps
Lemma
Der Algorithmus buildHeapist korrekt und terminiert.
I Initialisierung: Jeder Knoteni =bn/2c, bn/2c+ 1,. . . ist ein Blatt und damit Wurzel eines trivialen Heaps.
I Schleifeninvariante: Zu Beginn derfor-Schleife ist jeder Knoten i+1,. . .,E.length die Wurzel eines Heaps.
I In jeder Iteration sind alle Kinder des Knotensi bereits Wurzeln eines Heaps (Schleifeninvariante).
⇒ Bedingung für den Aufruf von heapifyist erfüllt.
I Dekrementierung von i stellt Schleifeninvariante wieder her.
I Terminierung: Beii = 0 ist gemäß Schleifeninvariante jeder Knoten 1, 2,. . .,n die Wurzel eines Heaps.
Heapsort Heapaufbau
Konstruktion eines Heaps
Lemma
Der Algorithmus buildHeapist korrekt und terminiert.
I Initialisierung: Jeder Knoteni =bn/2c, bn/2c+ 1,. . . ist ein Blatt und damit Wurzel eines trivialen Heaps.
I Schleifeninvariante: Zu Beginn derfor-Schleife ist jeder Knoten i+1,. . .,E.length die Wurzel eines Heaps.
I In jeder Iteration sind alle Kinder des Knotensi bereits Wurzeln eines Heaps (Schleifeninvariante).
⇒ Bedingung für den Aufruf von heapifyist erfüllt.
I Dekrementierung von i stellt Schleifeninvariante wieder her.
I Terminierung: Beii = 0 ist gemäß Schleifeninvariante jeder Knoten 1, 2,. . .,n die Wurzel eines Heaps.
Heapsort Heapaufbau
Konstruktion eines Heaps
Lemma
Der Algorithmus buildHeapist korrekt und terminiert.
I Initialisierung: Jeder Knoteni =bn/2c, bn/2c+ 1,. . . ist ein Blatt und damit Wurzel eines trivialen Heaps.
I Schleifeninvariante: Zu Beginn derfor-Schleife ist jeder Knoten i+1,. . .,E.length die Wurzel eines Heaps.
I In jeder Iteration sind alle Kinder des Knotensi bereits Wurzeln eines Heaps (Schleifeninvariante).
⇒ Bedingung für den Aufruf von heapifyist erfüllt.
I Dekrementierung von i stellt Schleifeninvariante wieder her.
I Terminierung: Beii = 0 ist gemäß Schleifeninvariante jeder Knoten 1, 2,. . .,n die Wurzel eines Heaps.
Heapsort Heapaufbau
Konstruktion eines Heaps
Lemma
Der Algorithmus buildHeapist korrekt und terminiert.
I Initialisierung: Jeder Knoteni =bn/2c, bn/2c+ 1,. . . ist ein Blatt und damit Wurzel eines trivialen Heaps.
I Schleifeninvariante: Zu Beginn derfor-Schleife ist jeder Knoten i+1,. . .,E.length die Wurzel eines Heaps.
I In jeder Iteration sind alle Kinder des Knotensi bereits Wurzeln eines Heaps (Schleifeninvariante).
⇒ Bedingung für den Aufruf von heapifyist erfüllt.
I Dekrementierung von i stellt Schleifeninvariante wieder her.
I Terminierung: Beii = 0 ist gemäß Schleifeninvariante jeder Knoten 1, 2,. . .,n die Wurzel eines Heaps.
Heapsort Heapaufbau
Konstruktion eines Heaps
Lemma
Der Algorithmus buildHeapist korrekt und terminiert.
I Initialisierung: Jeder Knoteni =bn/2c, bn/2c+ 1,. . . ist ein Blatt und damit Wurzel eines trivialen Heaps.
I Schleifeninvariante: Zu Beginn derfor-Schleife ist jeder Knoten i+1,. . .,E.length die Wurzel eines Heaps.
I In jeder Iteration sind alle Kinder des Knotensi bereits Wurzeln eines Heaps (Schleifeninvariante).
⇒ Bedingung für den Aufruf von heapifyist erfüllt.
I Dekrementierung von i stellt Schleifeninvariante wieder her.
I Terminierung: Beii = 0 ist gemäß Schleifeninvariante jeder Knoten 1, 2,. . .,n die Wurzel eines Heaps.
Heapsort Heapsort
Übersicht
1 Heaps
2 Heapaufbau
3 Heapsort
4 Anwendung: Prioritätswarteschlangen
Heapsort Heapsort
Heapsort – Algorithmus und Beispiel
41 26
25 3 0
6
19 69 12
17 17
4 2
8 13 34
41 26 17 25 19 17 8 3 6 69 12 4 2 13 34 0
1void heapSort(int E[]) {
2 buildHeap(E);
3 for (int i = E.length - 1; i > 0; i--) {
4 swap(E[0], E[i]);
5 heapify(E, i, 0);
6 }
7}
Heapsort Heapsort
Heapsort – Algorithmus und Beispiel
41 26
25 3 0
6
19 69 12
17 17
4 2
8 13 34
41 26 17 25 19 17 8 3 6 69 12 4 2 13 34 0
1void heapSort(int E[]) {
2 buildHeap(E);
3 for (int i = E.length - 1; i > 0; i--) {
4 swap(E[0], E[i]);
Heapsort Heapsort
Heapsort – Algorithmus und Beispiel
41 26
25 3 0
6
19 69 12
17 17
4 2
8 13 34
41 26 17 25 19 17 8 3 6 69 12 4 2 13 34 0
1void heapSort(int E[]) {
2 buildHeap(E);
3 for (int i = E.length - 1; i > 0; i--) {
4 swap(E[0], E[i]);
5 heapify(E, i, 0);
6 }
7}
Heapsort Heapsort
Heapsort – Algorithmus und Beispiel
41 26
25 3 0
6
19 69 12
17 17
4 2
34 13 8
41 26 17 25 19 17 34 3 6 69 12 4 2 13 8 0
1void heapSort(int E[]) {
2 buildHeap(E);
3 for (int i = E.length - 1; i > 0; i--) {
4 swap(E[0], E[i]);
Heapsort Heapsort
Heapsort – Algorithmus und Beispiel
41 26
25 3 0
6
19 69 12
17 17
4 2
34 13 8
41 26 17 25 19 17 34 3 6 69 12 4 2 13 8 0
1void heapSort(int E[]) {
2 buildHeap(E);
3 for (int i = E.length - 1; i > 0; i--) {
4 swap(E[0], E[i]);
5 heapify(E, i, 0);
6 }
7}
Heapsort Heapsort
Heapsort – Algorithmus und Beispiel
41 26
25 3 0
6
19 69 12
17 17
4 2
34 13 8
41 26 17 25 19 17 34 3 6 69 12 4 2 13 8 0
1void heapSort(int E[]) {
2 buildHeap(E);
3 for (int i = E.length - 1; i > 0; i--) {
4 swap(E[0], E[i]);
Heapsort Heapsort
Heapsort – Algorithmus und Beispiel
41 26
25 3 0
6
69 19 12
17 17
4 2
34 13 8
41 26 17 25 69 17 34 3 6 19 12 4 2 13 8 0
1void heapSort(int E[]) {
2 buildHeap(E);
3 for (int i = E.length - 1; i > 0; i--) {
4 swap(E[0], E[i]);
5 heapify(E, i, 0);
6 }
7}
Heapsort Heapsort
Heapsort – Algorithmus und Beispiel
41 26
25 3 0
6
69 19 12
17 17
4 2
34 13 8
41 26 17 25 69 17 34 3 6 19 12 4 2 13 8 0
1void heapSort(int E[]) {
2 buildHeap(E);
3 for (int i = E.length - 1; i > 0; i--) {
4 swap(E[0], E[i]);
Heapsort Heapsort
Heapsort – Algorithmus und Beispiel
41 26
25 3 0
6
69 19 12
17 17
4 2
34 13 8
41 26 17 25 69 17 34 3 6 19 12 4 2 13 8 0
1void heapSort(int E[]) {
2 buildHeap(E);
3 for (int i = E.length - 1; i > 0; i--) {
4 swap(E[0], E[i]);
5 heapify(E, i, 0);
6 }
7}
Heapsort Heapsort
Heapsort – Algorithmus und Beispiel
41 26
25 3 0
6
69 19 12
34 17
4 2
17 13 8
41 26 34 25 69 17 17 3 6 19 12 4 2 13 8 0
1void heapSort(int E[]) {
2 buildHeap(E);
3 for (int i = E.length - 1; i > 0; i--) {
4 swap(E[0], E[i]);
Heapsort Heapsort
Heapsort – Algorithmus und Beispiel
41 26
25 3 0
6
69 19 12
34 17
4 2
17 13 8
41 26 34 25 69 17 17 3 6 19 12 4 2 13 8 0
1void heapSort(int E[]) {
2 buildHeap(E);
3 for (int i = E.length - 1; i > 0; i--) {
4 swap(E[0], E[i]);
5 heapify(E, i, 0);
6 }
7}
