Datenstrukturen und Algorithmen
|
|
|
- Nele Bäcker
- vor 7 Jahren
- Abrufe
Transkript
1 Joost-Pieter Katoen Datenstrukturen und Algorithmen 1/32 Datenstrukturen und Algorithmen Vorlesung 7: Sortieren (K2) Joost-Pieter Katoen Lehrstuhl für Informatik 2 Software Modeling and Verification Group 7. Mai 2010
2 Joost-Pieter Katoen Datenstrukturen und Algorithmen 2/32 Übersicht 1 Sortieren - Einführung Bedeutung des Sortierens Dutch National Flag Problem 2 Sortieren durch Einfügen 3 Mergesort Das Divide-and-Conquer Paradigma Mergesort 4 Effizienteres Sortieren?
3 Sortieren - Einführung Joost-Pieter Katoen Datenstrukturen und Algorithmen 3/32 Übersicht 1 Sortieren - Einführung Bedeutung des Sortierens Dutch National Flag Problem 2 Sortieren durch Einfügen 3 Mergesort Das Divide-and-Conquer Paradigma Mergesort 4 Effizienteres Sortieren?
4 Sortieren - Einführung Joost-Pieter Katoen Datenstrukturen und Algorithmen 4/32 Die Bedeutung des Sortierens Sortieren ist ein wichtiges Thema Sortiert wird häufig benutzt, und hat viele Anwendungen. Sortierverfahren geben Ideen, wie man Algorithmen verbessern kann. Geniale und optimale Algorithmen wurden gefunden.
5 Sortieren - Einführung Joost-Pieter Katoen Datenstrukturen und Algorithmen 4/32 Die Bedeutung des Sortierens Sortieren ist ein wichtiges Thema Sortiert wird häufig benutzt, und hat viele Anwendungen. Sortierverfahren geben Ideen, wie man Algorithmen verbessern kann. Geniale und optimale Algorithmen wurden gefunden. Neben der Funktionsweise der Algorithmen widmen wir uns vor allem der Laufzeitanalyse.
6 Sortieren - Einführung Joost-Pieter Katoen Datenstrukturen und Algorithmen 5/32 Anwendungen des Sortierens Beispiel (Suchen) Schnellere Suche ist die wohl häufigste Anwendung des Sortierens. Binäre Suche findet ein Element in O(log n).
7 Sortieren - Einführung Joost-Pieter Katoen Datenstrukturen und Algorithmen 5/32 Anwendungen des Sortierens Beispiel (Suchen) Schnellere Suche ist die wohl häufigste Anwendung des Sortierens. Binäre Suche findet ein Element in O(log n). Beispiel (Engstes Paar (closest pair)) Gegeben seien n Zahlen. Finde das Paar mit dem geringstem Abstand.
8 Sortieren - Einführung Joost-Pieter Katoen Datenstrukturen und Algorithmen 5/32 Anwendungen des Sortierens Beispiel (Suchen) Schnellere Suche ist die wohl häufigste Anwendung des Sortierens. Binäre Suche findet ein Element in O(log n). Beispiel (Engstes Paar (closest pair)) Gegeben seien n Zahlen. Finde das Paar mit dem geringstem Abstand. Nach dem Sortieren liegen die Paare nebeneinander. Der Aufwand ist dann noch O(n).
9 Sortieren - Einführung Joost-Pieter Katoen Datenstrukturen und Algorithmen 6/32 Noch einige Anwendungen Beispiel (Eigenschaften von Datenobjekten) Sind alle n Elemente einzigartig oder gibt es Duplikate?
10 Sortieren - Einführung Joost-Pieter Katoen Datenstrukturen und Algorithmen 6/32 Noch einige Anwendungen Beispiel (Eigenschaften von Datenobjekten) Sind alle n Elemente einzigartig oder gibt es Duplikate? Das k-t größte Element einer Menge? Beispiel (Textkompression (Entropiekodierung)) Sortiere die Buchstaben nach Häufigkeit des Auftretens um sie dann effizient zu kodieren (d. h. mit möglichst kurzen Bitfolgen).
11 Sortieren - Einführung Joost-Pieter Katoen Datenstrukturen und Algorithmen 7/32 Einige Hilfsbegriffe Permutation Eine Permutation einer Menge A = {a 1,..., a n } ist eine bijektive Abbildung π : A A.
12 Sortieren - Einführung Joost-Pieter Katoen Datenstrukturen und Algorithmen 7/32 Einige Hilfsbegriffe Permutation Eine Permutation einer Menge A = {a 1,..., a n } ist eine bijektive Abbildung π : A A. Totale Ordnung Sei A = {a 1,..., a n } eine Menge. Die binäre Relation A A ist eine totale Ordnung (auf A) wenn für alle a i, a j, a k A gilt:
13 Sortieren - Einführung Joost-Pieter Katoen Datenstrukturen und Algorithmen 7/32 Einige Hilfsbegriffe Permutation Eine Permutation einer Menge A = {a 1,..., a n } ist eine bijektive Abbildung π : A A. Totale Ordnung Sei A = {a 1,..., a n } eine Menge. Die binäre Relation A A ist eine totale Ordnung (auf A) wenn für alle a i, a j, a k A gilt: 1. Antisymmetrie: a i a j und a j a i impliziert a i = a j.
14 Sortieren - Einführung Joost-Pieter Katoen Datenstrukturen und Algorithmen 7/32 Einige Hilfsbegriffe Permutation Eine Permutation einer Menge A = {a 1,..., a n } ist eine bijektive Abbildung π : A A. Totale Ordnung Sei A = {a 1,..., a n } eine Menge. Die binäre Relation A A ist eine totale Ordnung (auf A) wenn für alle a i, a j, a k A gilt: 1. Antisymmetrie: a i a j und a j a i impliziert a i = a j. 2. Transitivität: a i a j und a j a k impliziert a i a k.
15 Sortieren - Einführung Joost-Pieter Katoen Datenstrukturen und Algorithmen 7/32 Einige Hilfsbegriffe Permutation Eine Permutation einer Menge A = {a 1,..., a n } ist eine bijektive Abbildung π : A A. Totale Ordnung Sei A = {a 1,..., a n } eine Menge. Die binäre Relation A A ist eine totale Ordnung (auf A) wenn für alle a i, a j, a k A gilt: 1. Antisymmetrie: a i a j und a j a i impliziert a i = a j. 2. Transitivität: a i a j und a j a k impliziert a i a k. 3. Totalität: a i a j oder a j a i.
16 Sortieren - Einführung Joost-Pieter Katoen Datenstrukturen und Algorithmen 7/32 Einige Hilfsbegriffe Permutation Eine Permutation einer Menge A = {a 1,..., a n } ist eine bijektive Abbildung π : A A. Totale Ordnung Sei A = {a 1,..., a n } eine Menge. Die binäre Relation A A ist eine totale Ordnung (auf A) wenn für alle a i, a j, a k A gilt: 1. Antisymmetrie: a i a j und a j a i impliziert a i = a j. 2. Transitivität: a i a j und a j a k impliziert a i a k. 3. Totalität: a i a j oder a j a i. Beispiel Die lexikographische Ordnung von Zeichenketten und die numerische Ordnung von Zahlen sind totale Ordnungen.
17 Sortieren - Einführung Joost-Pieter Katoen Datenstrukturen und Algorithmen 8/32 Sortierproblem Das Sortier-Problem Eingabe: 1. Ein Array E mit n Einträgen. 2. Die Einträge gehören zu einer Menge A mit totaler Ordnung.
18 Sortieren - Einführung Joost-Pieter Katoen Datenstrukturen und Algorithmen 8/32 Sortierproblem Das Sortier-Problem Eingabe: 1. Ein Array E mit n Einträgen. 2. Die Einträge gehören zu einer Menge A mit totaler Ordnung. Ausgabe: Ein Array F mit n Einträgen, so dass 1. F[1],..., F[n] eine Permutation von E[1],..., E[n] ist
19 Sortieren - Einführung Joost-Pieter Katoen Datenstrukturen und Algorithmen 8/32 Sortierproblem Das Sortier-Problem Eingabe: 1. Ein Array E mit n Einträgen. 2. Die Einträge gehören zu einer Menge A mit totaler Ordnung. Ausgabe: Ein Array F mit n Einträgen, so dass 1. F[1],..., F[n] eine Permutation von E[1],..., E[n] ist 2. Für alle 0 < i, j < n gilt: F[i] F[i+1].
20 Sortieren - Einführung Joost-Pieter Katoen Datenstrukturen und Algorithmen 8/32 Sortierproblem Das Sortier-Problem Eingabe: 1. Ein Array E mit n Einträgen. 2. Die Einträge gehören zu einer Menge A mit totaler Ordnung. Ausgabe: Ein Array F mit n Einträgen, so dass 1. F[1],..., F[n] eine Permutation von E[1],..., E[n] ist 2. Für alle 0 < i, j < n gilt: F[i] F[i+1]. Annahmen dieser Vorlesung Die zu sortierende Sequenz ist als Array organisiert, nicht als Liste. Die Elementaroperation ist ein Vergleich von Schlüsseln.
21 Sortieren - Einführung Joost-Pieter Katoen Datenstrukturen und Algorithmen 9/32 Sortieralgorithmen Beispiel (Einige Sortieralgorithmen) Insertionsort, Bubblesort, Shellsort, Mergesort, Heapsort Quicksort, Countingsort, Bucketsort, Radixsort, Stoogesort, usw.
22 Sortieren - Einführung Joost-Pieter Katoen Datenstrukturen und Algorithmen 9/32 Sortieralgorithmen Beispiel (Einige Sortieralgorithmen) Insertionsort, Bubblesort, Shellsort, Mergesort, Heapsort Quicksort, Countingsort, Bucketsort, Radixsort, Stoogesort, usw. Stabilität Ein Sortieralgorithmus ist stabil wenn er die Reihenfolge der Elemente, deren Sortierschlüssel gleich sind, bewahrt.
23 Sortieren - Einführung Joost-Pieter Katoen Datenstrukturen und Algorithmen 9/32 Sortieralgorithmen Beispiel (Einige Sortieralgorithmen) Insertionsort, Bubblesort, Shellsort, Mergesort, Heapsort Quicksort, Countingsort, Bucketsort, Radixsort, Stoogesort, usw. Stabilität Ein Sortieralgorithmus ist stabil wenn er die Reihenfolge der Elemente, deren Sortierschlüssel gleich sind, bewahrt. Wenn z. B. eine Liste alphabetisch sortierter Personendateien nach dem Geburtsdatum neu sortiert wird, dann bleiben unter einem stabilen Sortierverfahren alle Personen mit gleichem Geburtsdatum alphabetisch sortiert.
24 Sortieren - Einführung Joost-Pieter Katoen Datenstrukturen und Algorithmen 9/32 Sortieralgorithmen Beispiel (Einige Sortieralgorithmen) Insertionsort, Bubblesort, Shellsort, Mergesort, Heapsort Quicksort, Countingsort, Bucketsort, Radixsort, Stoogesort, usw. Stabilität Ein Sortieralgorithmus ist stabil wenn er die Reihenfolge der Elemente, deren Sortierschlüssel gleich sind, bewahrt. Wenn z. B. eine Liste alphabetisch sortierter Personendateien nach dem Geburtsdatum neu sortiert wird, dann bleiben unter einem stabilen Sortierverfahren alle Personen mit gleichem Geburtsdatum alphabetisch sortiert. Wir werden erst einen einfachen Sortieralgorithmus betrachten.
25 Sortieren - Einführung Joost-Pieter Katoen Datenstrukturen und Algorithmen 10/32 Dutch National Flag Problem (I)
26 Sortieren - Einführung Joost-Pieter Katoen Datenstrukturen und Algorithmen 11/32 Dutch National Flag Problem (II) Beispiel (Das niederländische Flaggen-Problem [Dijkstra, 1972]) Eingabe: 1. Ein Array E mit n Einträgen, wobei für alle 0 < i n E[i] == rot, E[i] == blau oder E[i] == weiss 2. Ordnung: rot < weiss < blau
27 Sortieren - Einführung Joost-Pieter Katoen Datenstrukturen und Algorithmen 11/32 Dutch National Flag Problem (II) Beispiel (Das niederländische Flaggen-Problem [Dijkstra, 1972]) Eingabe: 1. Ein Array E mit n Einträgen, wobei für alle 0 < i n E[i] == rot, E[i] == blau oder E[i] == weiss 2. Ordnung: rot < weiss < blau Ausgabe: Ein sortiertes Array mit den Einträgen aus E.
28 Sortieren - Einführung Joost-Pieter Katoen Datenstrukturen und Algorithmen 11/32 Dutch National Flag Problem (II) Beispiel (Das niederländische Flaggen-Problem [Dijkstra, 1972]) Eingabe: 1. Ein Array E mit n Einträgen, wobei für alle 0 < i n E[i] == rot, E[i] == blau oder E[i] == weiss 2. Ordnung: rot < weiss < blau Ausgabe: Ein sortiertes Array mit den Einträgen aus E. Erwünschte Worst-Case Zeitkomplexität: Θ(n).
29 Sortieren - Einführung Joost-Pieter Katoen Datenstrukturen und Algorithmen 11/32 Dutch National Flag Problem (II) Beispiel (Das niederländische Flaggen-Problem [Dijkstra, 1972]) Eingabe: 1. Ein Array E mit n Einträgen, wobei für alle 0 < i n E[i] == rot, E[i] == blau oder E[i] == weiss 2. Ordnung: rot < weiss < blau Ausgabe: Ein sortiertes Array mit den Einträgen aus E. Erwünschte Worst-Case Zeitkomplexität: Θ(n). Erwünschte Worst-Case Speicherkomplexität: Θ(1).
30 Sortieren - Einführung Joost-Pieter Katoen Datenstrukturen und Algorithmen 12/32 Dutch National Flag Problem (III) Hauptidee Zerlege das Array E in 4 Regionen: (1) 0 < i r, (2) r < i < u, (3) u i < b, und (4) b i n für die Hilfsvariablen r, u und b,
31 Sortieren - Einführung Joost-Pieter Katoen Datenstrukturen und Algorithmen 12/32 Dutch National Flag Problem (III) Hauptidee Zerlege das Array E in 4 Regionen: (1) 0 < i r, (2) r < i < u, (3) u i < b, und (4) b i n für die Hilfsvariablen r, u und b, so dass folgende Invariante gilt: 1. E[1],..., E[r] ist die rote Region, d. h. für alle 0 < i r E[i] == rot.
32 Sortieren - Einführung Joost-Pieter Katoen Datenstrukturen und Algorithmen 12/32 Dutch National Flag Problem (III) Hauptidee Zerlege das Array E in 4 Regionen: (1) 0 < i r, (2) r < i < u, (3) u i < b, und (4) b i n für die Hilfsvariablen r, u und b, so dass folgende Invariante gilt: 1. E[1],..., E[r] ist die rote Region, d. h. für alle 0 < i r E[i] == rot. 2. E[r+1],..., E[u-1] ist die weiße Region, d. h. für alle r < i < u E[i] == weiss.
33 Sortieren - Einführung Joost-Pieter Katoen Datenstrukturen und Algorithmen 12/32 Dutch National Flag Problem (III) Hauptidee Zerlege das Array E in 4 Regionen: (1) 0 < i r, (2) r < i < u, (3) u i < b, und (4) b i n für die Hilfsvariablen r, u und b, so dass folgende Invariante gilt: 1. E[1],..., E[r] ist die rote Region, d. h. für alle 0 < i r E[i] == rot. 2. E[r+1],..., E[u-1] ist die weiße Region, d. h. für alle r < i < u E[i] == weiss. 3. E[u],..., E[b-1] ist die unbekannte Region, d. h. für alle u i < b E[i] == rot oder E[i] == weiss oder E[i] == blau.
34 Sortieren - Einführung Joost-Pieter Katoen Datenstrukturen und Algorithmen 12/32 Dutch National Flag Problem (III) Hauptidee Zerlege das Array E in 4 Regionen: (1) 0 < i r, (2) r < i < u, (3) u i < b, und (4) b i n für die Hilfsvariablen r, u und b, so dass folgende Invariante gilt: 1. E[1],..., E[r] ist die rote Region, d. h. für alle 0 < i r E[i] == rot. 2. E[r+1],..., E[u-1] ist die weiße Region, d. h. für alle r < i < u E[i] == weiss. 3. E[u],..., E[b-1] ist die unbekannte Region, d. h. für alle u i < b E[i] == rot oder E[i] == weiss oder E[i] == blau. 4. E[b],..., E[n] ist die blaue Region, d. h. für alle b i n E[i] == blau.
35 Sortieren - Einführung Joost-Pieter Katoen Datenstrukturen und Algorithmen 12/32 Dutch National Flag Problem (III) Hauptidee Zerlege das Array E in 4 Regionen: (1) 0 < i r, (2) r < i < u, (3) u i < b, und (4) b i n für die Hilfsvariablen r, u und b, so dass folgende Invariante gilt: 1. E[1],..., E[r] ist die rote Region, d. h. für alle 0 < i r E[i] == rot. 2. E[r+1],..., E[u-1] ist die weiße Region, d. h. für alle r < i < u E[i] == weiss. 3. E[u],..., E[b-1] ist die unbekannte Region, d. h. für alle u i < b E[i] == rot oder E[i] == weiss oder E[i] == blau. 4. E[b],..., E[n] ist die blaue Region, d. h. für alle b i n E[i] == blau. Arrayelemente können mit der swap-operation vertauscht werden.
36 Sortieren - Einführung Joost-Pieter Katoen Datenstrukturen und Algorithmen 13/32 Dutch National Flag Problem (IV) 1 void DutchNationalFlag(Color E[], int n) { 2 int r = 0, b = n + 1; // die rote und blaue Region sind leer 3 int u = 1; // die unbekannte Region == E 4 while (u < b) { 5 if (E[u] == rot) { 6 swap(e[r + 1], E[u]); 7 r = r + 1; // vergrößere die rote Region 8 die unbekannte Region u = u + 1; // verkleinere 9 } 10 if (E[u] == weiss) { 11 u = u + 1; r u b 12 } 13 if (E[u] == blau) { 14 swap(e[b - 1], E[u]); 15 b = b - 1; // vergrößere die blaue Region 16 } 17 } 18 }
37 Sortieren - Einführung Joost-Pieter Katoen Datenstrukturen und Algorithmen 13/32 Dutch National Flag Problem (IV) 1 void DutchNationalFlag(Color E[], int n) { 2 int r = 0, b = n + 1; // die rote und blaue Region sind leer 3 int u = 1; // die unbekannte Region == E 4 while (u < b) { 5 if (E[u] == rot) { 6 swap(e[r + 1], E[u]); 7 r = r + 1; // vergrößere die rote Region 8 die unbekannte Region u = u + 1; // verkleinere 9 } 10 if (E[u] == weiss) { 11 u = u + 1; r u b 12 } 13 if (E[u] == blau) { 14 swap(e[b - 1], E[u]); 15 b = b - 1; // vergrößere die blaue Region 16 } 17 } 18 }
38 Sortieren - Einführung Joost-Pieter Katoen Datenstrukturen und Algorithmen 13/32 Dutch National Flag Problem (IV) 1 void DutchNationalFlag(Color E[], int n) { 2 int r = 0, b = n + 1; // die rote und blaue Region sind leer 3 int u = 1; // die unbekannte Region == E 4 while (u < b) { 5 if (E[u] == rot) { 6 swap(e[r + 1], E[u]); 7 r = r + 1; // vergrößere die rote Region 8 die unbekannte Region u = u + 1; // verkleinere 9 } 10 if (E[u] == weiss) { 11 u = u + 1; r u b 12 } 13 if (E[u] == blau) { 14 swap(e[b - 1], E[u]); 15 b = b - 1; // vergrößere die blaue Region 16 } 17 } 18 }
39 Sortieren - Einführung Joost-Pieter Katoen Datenstrukturen und Algorithmen 13/32 Dutch National Flag Problem (IV) 1 void DutchNationalFlag(Color E[], int n) { 2 int r = 0, b = n + 1; // die rote und blaue Region sind leer 3 int u = 1; // die unbekannte Region == E 4 while (u < b) { 5 if (E[u] == rot) { 6 swap(e[r + 1], E[u]); 7 r = r + 1; // vergrößere die rote Region 8 die unbekannte Region u = u + 1; // verkleinere 9 } 10 if (E[u] == weiss) { 11 u = u + 1; r u b 12 } 13 if (E[u] == blau) { 14 swap(e[b - 1], E[u]); 15 b = b - 1; // vergrößere die blaue Region 16 } 17 } 18 }
40 Sortieren - Einführung Joost-Pieter Katoen Datenstrukturen und Algorithmen 13/32 Dutch National Flag Problem (IV) 1 void DutchNationalFlag(Color E[], int n) { 2 int r = 0, b = n + 1; // die rote und blaue Region sind leer 3 int u = 1; // die unbekannte Region == E 4 while (u < b) { 5 if (E[u] == rot) { 6 swap(e[r + 1], E[u]); 7 r = r + 1; // vergrößere die rote Region 8 die unbekannte Region u = u + 1; // verkleinere 9 } 10 if (E[u] == weiss) { 11 u = u + 1; r u b 12 } 13 if (E[u] == blau) { 14 swap(e[b - 1], E[u]); 15 b = b - 1; // vergrößere die blaue Region 16 } 17 } 18 }
41 Sortieren - Einführung Joost-Pieter Katoen Datenstrukturen und Algorithmen 13/32 Dutch National Flag Problem (IV) 1 void DutchNationalFlag(Color E[], int n) { 2 int r = 0, b = n + 1; // die rote und blaue Region sind leer 3 int u = 1; // die unbekannte Region == E 4 while (u < b) { 5 if (E[u] == rot) { 6 swap(e[r + 1], E[u]); 7 r = r + 1; // vergrößere die rote Region 8 die unbekannte Region u = u + 1; // verkleinere 9 } 10 if (E[u] == weiss) { 11 u = u + 1; r u b 12 } 13 if (E[u] == blau) { 14 swap(e[b - 1], E[u]); 15 b = b - 1; // vergrößere die blaue Region 16 } 17 } 18 }
42 Sortieren - Einführung Joost-Pieter Katoen Datenstrukturen und Algorithmen 13/32 Dutch National Flag Problem (IV) 1 void DutchNationalFlag(Color E[], int n) { 2 int r = 0, b = n + 1; // die rote und blaue Region sind leer 3 int u = 1; // die unbekannte Region == E 4 while (u < b) { 5 if (E[u] == rot) { 6 swap(e[r + 1], E[u]); 7 r = r + 1; // vergrößere die rote Region 8 die unbekannte Region u = u + 1; // verkleinere 9 } 10 if (E[u] == weiss) { 11 u = u + 1; r u b 12 } 13 if (E[u] == blau) { 14 swap(e[b - 1], E[u]); 15 b = b - 1; // vergrößere die blaue Region 16 } 17 } 18 }
43 Sortieren - Einführung Joost-Pieter Katoen Datenstrukturen und Algorithmen 13/32 Dutch National Flag Problem (IV) 1 void DutchNationalFlag(Color E[], int n) { 2 int r = 0, b = n + 1; // die rote und blaue Region sind leer 3 int u = 1; // die unbekannte Region == E 4 while (u < b) { 5 if (E[u] == rot) { 6 swap(e[r + 1], E[u]); 7 r = r + 1; // vergrößere die rote Region 8 die unbekannte Region u = u + 1; // verkleinere 9 } 10 if (E[u] == weiss) { 11 u = u + 1; r u b 12 } 13 if (E[u] == blau) { 14 swap(e[b - 1], E[u]); 15 b = b - 1; // vergrößere die blaue Region 16 } 17 } 18 }
44 Sortieren - Einführung Joost-Pieter Katoen Datenstrukturen und Algorithmen 13/32 Dutch National Flag Problem (IV) 1 void DutchNationalFlag(Color E[], int n) { 2 int r = 0, b = n + 1; // die rote und blaue Region sind leer 3 int u = 1; // die unbekannte Region == E 4 while (u < b) { 5 if (E[u] == rot) { 6 swap(e[r + 1], E[u]); 7 r = r + 1; // vergrößere die rote Region 8 die unbekannte Region u = u + 1; // verkleinere 9 } 10 if (E[u] == weiss) { 11 u = u + 1; r u b 12 } 13 if (E[u] == blau) { 14 swap(e[b - 1], E[u]); 15 b = b - 1; // vergrößere die blaue Region 16 } 17 } 18 }
45 Sortieren - Einführung Joost-Pieter Katoen Datenstrukturen und Algorithmen 13/32 Dutch National Flag Problem (IV) 1 void DutchNationalFlag(Color E[], int n) { 2 int r = 0, b = n + 1; // die rote und blaue Region sind leer 3 int u = 1; // die unbekannte Region == E 4 while (u < b) { 5 if (E[u] == rot) { 6 swap(e[r + 1], E[u]); 7 r = r + 1; // vergrößere die rote Region 8 die unbekannte Region u = u + 1; // verkleinere 9 } 10 if (E[u] == weiss) { 11 u = u + 1; r u b 12 } 13 if (E[u] == blau) { 14 swap(e[b - 1], E[u]); 15 b = b - 1; // vergrößere die blaue Region 16 } 17 } 18 }
46 Sortieren - Einführung Joost-Pieter Katoen Datenstrukturen und Algorithmen 13/32 Dutch National Flag Problem (IV) 1 void DutchNationalFlag(Color E[], int n) { 2 int r = 0, b = n + 1; // die rote und blaue Region sind leer 3 int u = 1; // die unbekannte Region == E 4 while (u < b) { 5 if (E[u] == rot) { 6 swap(e[r + 1], E[u]); 7 r = r + 1; // vergrößere die rote Region 8 die unbekannte Region u = u + 1; // verkleinere 9 } 10 if (E[u] == weiss) { 11 u = u + 1; r u b 12 } 13 if (E[u] == blau) { 14 swap(e[b - 1], E[u]); 15 b = b - 1; // vergrößere die blaue Region 16 } 17 } 18 }
47 Sortieren - Einführung Joost-Pieter Katoen Datenstrukturen und Algorithmen 13/32 Dutch National Flag Problem (IV) 1 void DutchNationalFlag(Color E[], int n) { 2 int r = 0, b = n + 1; // die rote und blaue Region sind leer 3 int u = 1; // die unbekannte Region == E 4 while (u < b) { 5 if (E[u] == rot) { 6 swap(e[r + 1], E[u]); 7 r = r + 1; // vergrößere die rote Region 8 u = u + 1; // verkleinere die unbekannte Region 9 } 10 if (E[u] == weiss) { 11 u = u + 1; r 12 } 13 if (E[u] == blau) { 14 swap(e[b - 1], E[u]); 15 b = b - 1; // vergrößere die blaue Region 16 } 17 } 18 } u b
48 Sortieren - Einführung Dutch National Flag Problem (IV) 1 void DutchNationalFlag(Color E[], int n) { 2 int r = 0, b = n + 1; // die rote und blaue Region sind leer 3 int u = 1; // die unbekannte Region == E 4 while (u < b) { 5 if (E[u] == rot) { 6 swap(e[r + 1], E[u]); 7 r = r + 1; // vergrößere die rote Region 8 u = u + 1; // verkleinere die unbekannte Region 9 } 10 if (E[u] == weiss) { 11 u = u + 1; 12 } 13 if (E[u] == blau) { 14 swap(e[b - 1], E[u]); 15 b = b - 1; // vergrößere die blaue Region 16 } 17 } 18 } Joost-Pieter Katoen Datenstrukturen und Algorithmen 13/32
49 Sortieren - Einführung Dutch National Flag Problem (IV) 1 void DutchNationalFlag(Color E[], int n) { 2 int r = 0, b = n + 1; // die rote und blaue Region sind leer 3 int u = 1; // die unbekannte Region == E 4 while (u < b) { 5 if (E[u] == rot) { 6 swap(e[r + 1], E[u]); 7 r = r + 1; // vergrößere die rote Region 8 u = u + 1; // verkleinere die unbekannte Region 9 } 10 if (E[u] == weiss) { 11 u = u + 1; 12 } 13 if (E[u] == blau) { 14 swap(e[b - 1], E[u]); 15 b = b - 1; // vergrößere die blaue Region 16 } 17 } 18 } Frage: Ist der DNF-Algorithmus ein stabiles Sortierverfahren? Joost-Pieter Katoen Datenstrukturen und Algorithmen 13/32
50 Sortieren - Einführung Dutch National Flag Problem (IV) 1 void DutchNationalFlag(Color E[], int n) { 2 int r = 0, b = n + 1; // die rote und blaue Region sind leer 3 int u = 1; // die unbekannte Region == E 4 while (u < b) { 5 if (E[u] == rot) { 6 swap(e[r + 1], E[u]); 7 r = r + 1; // vergrößere die rote Region 8 u = u + 1; // verkleinere die unbekannte Region 9 } 10 if (E[u] == weiss) { 11 u = u + 1; 12 } 13 if (E[u] == blau) { 14 swap(e[b - 1], E[u]); 15 b = b - 1; // vergrößere die blaue Region 16 } 17 } 18 } Frage: Ist der DNF-Algorithmus ein stabiles Sortierverfahren? Antwort: Nein. Joost-Pieter Katoen Datenstrukturen und Algorithmen 13/32
51 Sortieren - Einführung Joost-Pieter Katoen Datenstrukturen und Algorithmen 14/32 Dutch National Flag Problem (V) Speicherkomplexität Die Worst-Case Speicherkomplexität vom DNF-Algorithmus ist Θ(1), da die einzigen extra Variablen r, u und b sind.
52 Sortieren - Einführung Joost-Pieter Katoen Datenstrukturen und Algorithmen 14/32 Dutch National Flag Problem (V) Speicherkomplexität Die Worst-Case Speicherkomplexität vom DNF-Algorithmus ist Θ(1), da die einzigen extra Variablen r, u und b sind. DNF ist in-place, d. h. der Algorithmus arbeitet ohne zusätzlichen Speicherplatz.
53 Sortieren - Einführung Joost-Pieter Katoen Datenstrukturen und Algorithmen 14/32 Dutch National Flag Problem (V) Speicherkomplexität Die Worst-Case Speicherkomplexität vom DNF-Algorithmus ist Θ(1), da die einzigen extra Variablen r, u und b sind. DNF ist in-place, d. h. der Algorithmus arbeitet ohne zusätzlichen Speicherplatz. Zeitkomplexität Betrachte als elementare Operation die Vergleiche der Form E[i] ==.... Die Worst-Case Zeitkomplexität ist Θ(n), da:
54 Sortieren - Einführung Joost-Pieter Katoen Datenstrukturen und Algorithmen 14/32 Dutch National Flag Problem (V) Speicherkomplexität Die Worst-Case Speicherkomplexität vom DNF-Algorithmus ist Θ(1), da die einzigen extra Variablen r, u und b sind. DNF ist in-place, d. h. der Algorithmus arbeitet ohne zusätzlichen Speicherplatz. Zeitkomplexität Betrachte als elementare Operation die Vergleiche der Form E[i] ==.... Die Worst-Case Zeitkomplexität ist Θ(n), da: 1. in jedem Durchlauf werden eine konstante Anzahl Vergleiche durchgeführt
55 Sortieren - Einführung Joost-Pieter Katoen Datenstrukturen und Algorithmen 14/32 Dutch National Flag Problem (V) Speicherkomplexität Die Worst-Case Speicherkomplexität vom DNF-Algorithmus ist Θ(1), da die einzigen extra Variablen r, u und b sind. DNF ist in-place, d. h. der Algorithmus arbeitet ohne zusätzlichen Speicherplatz. Zeitkomplexität Betrachte als elementare Operation die Vergleiche der Form E[i] ==.... Die Worst-Case Zeitkomplexität ist Θ(n), da: 1. in jedem Durchlauf werden eine konstante Anzahl Vergleiche durchgeführt 2. die Anzahl der Durchläufe ist Θ(n), da in jedem Durchlauf die Größe vom unbekannten Gebiet b - u um eins verkleinert wird.
56 Sortieren durch Einfügen Joost-Pieter Katoen Datenstrukturen und Algorithmen 15/32 Übersicht 1 Sortieren - Einführung Bedeutung des Sortierens Dutch National Flag Problem 2 Sortieren durch Einfügen 3 Mergesort Das Divide-and-Conquer Paradigma Mergesort 4 Effizienteres Sortieren?
57 Sortieren durch Einfügen Joost-Pieter Katoen Datenstrukturen und Algorithmen 16/32 Sortieren durch Einfügen Insertionsort
58 Sortieren durch Einfügen Joost-Pieter Katoen Datenstrukturen und Algorithmen 17/32 Sortieren durch Einfügen Insertionsort bereits sortiert noch unsortiert als Nächstes einzusortieren Durchlaufen des (unsortierten) Arrays von links nach rechts.
59 Sortieren durch Einfügen Joost-Pieter Katoen Datenstrukturen und Algorithmen 17/32 Sortieren durch Einfügen Insertionsort bereits sortiert noch unsortiert als Nächstes einzusortieren Durchlaufen des (unsortierten) Arrays von links nach rechts. Gehe zum ersten bisher noch nicht berücksichtigte Element.
60 Sortieren durch Einfügen Joost-Pieter Katoen Datenstrukturen und Algorithmen 17/32 Sortieren durch Einfügen Insertionsort bereits sortiert noch unsortiert als Nächstes einzusortieren Durchlaufen des (unsortierten) Arrays von links nach rechts. Gehe zum ersten bisher noch nicht berücksichtigte Element. Füge es im sortierten Teil (links) nach elementweisem Vergleichen ein.
61 Sortieren durch Einfügen Joost-Pieter Katoen Datenstrukturen und Algorithmen 17/32 Sortieren durch Einfügen Insertionsort bereits sortiert noch unsortiert als Nächstes einzusortieren Durchlaufen des (unsortierten) Arrays von links nach rechts. Gehe zum ersten bisher noch nicht berücksichtigte Element. Füge es im sortierten Teil (links) nach elementweisem Vergleichen ein. Dieser Algorithmus funktioniert auch mit anderen lineare Anordnungen, etwa Listen.
62 Sortieren durch Einfügen Joost-Pieter Katoen Datenstrukturen und Algorithmen 18/32 Insertionsort Animation und Algorithmus void insertionsort(int E[]) { 2 int i,j; 3 for (i = 1; i < E.length; i++) { 4 int v = E[i]; // speichere E[i] 5 for (j = i; j > 0 && E[j-1] > v; j--) { 6 E[j] = E[j-1]; // schiebe Element j-1 nach rechts 7 } 8 E[j] = v; // füge E[i] an der richtigen Stelle ein 9 } 10 }
63 Sortieren durch Einfügen Joost-Pieter Katoen Datenstrukturen und Algorithmen 18/32 Insertionsort Animation und Algorithmus void insertionsort(int E[]) { 2 int i,j; 3 for (i = 1; i < E.length; i++) { 4 int v = E[i]; // speichere E[i] 5 for (j = i; j > 0 && E[j-1] > v; j--) { 6 E[j] = E[j-1]; // schiebe Element j-1 nach rechts 7 } 8 E[j] = v; // füge E[i] an der richtigen Stelle ein 9 } 10 } Insertionsort ist in-place, d. h. der Algorithmus arbeitet ohne zusätzlichen Speicherplatz.
64 Sortieren durch Einfügen Joost-Pieter Katoen Datenstrukturen und Algorithmen 18/32 Insertionsort Animation und Algorithmus void insertionsort(int E[]) { 2 int i,j; 3 for (i = 1; i < E.length; i++) { 4 int v = E[i]; // speichere E[i] 5 for (j = i; j > 0 && E[j-1] > v; j--) { 6 E[j] = E[j-1]; // schiebe Element j-1 nach rechts 7 } 8 E[j] = v; // füge E[i] an der richtigen Stelle ein 9 } 10 } Insertionsort ist in-place, d. h. der Algorithmus arbeitet ohne zusätzlichen Speicherplatz. Insertionsort ist stabil, da die Reihenfolge der gleichwertigen Arrayelemente unverändert bleibt.
65 Sortieren durch Einfügen Joost-Pieter Katoen Datenstrukturen und Algorithmen 18/32 Insertionsort Animation und Algorithmus void insertionsort(int E[]) { 2 int i,j; 3 for (i = 1; i < E.length; i++) { 4 int v = E[i]; // speichere E[i] 5 for (j = i; j > 0 && E[j-1] > v; j--) { 6 E[j] = E[j-1]; // schiebe Element j-1 nach rechts 7 } 8 E[j] = v; // füge E[i] an der richtigen Stelle ein 9 } 10 } Insertionsort ist in-place, d. h. der Algorithmus arbeitet ohne zusätzlichen Speicherplatz. Insertionsort ist stabil, da die Reihenfolge der gleichwertigen Arrayelemente unverändert bleibt.
66 Sortieren durch Einfügen Joost-Pieter Katoen Datenstrukturen und Algorithmen 18/32 Insertionsort Animation und Algorithmus void insertionsort(int E[]) { 2 int i,j; 3 for (i = 1; i < E.length; i++) { 4 int v = E[i]; // speichere E[i] 5 for (j = i; j > 0 && E[j-1] > v; j--) { 6 E[j] = E[j-1]; // schiebe Element j-1 nach rechts 7 } 8 E[j] = v; // füge E[i] an der richtigen Stelle ein 9 } 10 } Insertionsort ist in-place, d. h. der Algorithmus arbeitet ohne zusätzlichen Speicherplatz. Insertionsort ist stabil, da die Reihenfolge der gleichwertigen Arrayelemente unverändert bleibt.
67 Sortieren durch Einfügen Joost-Pieter Katoen Datenstrukturen und Algorithmen 18/32 Insertionsort Animation und Algorithmus void insertionsort(int E[]) { 2 int i,j; 3 for (i = 1; i < E.length; i++) { 4 int v = E[i]; // speichere E[i] 5 for (j = i; j > 0 && E[j-1] > v; j--) { 6 E[j] = E[j-1]; // schiebe Element j-1 nach rechts 7 } 8 E[j] = v; // füge E[i] an der richtigen Stelle ein 9 } 10 } Insertionsort ist in-place, d. h. der Algorithmus arbeitet ohne zusätzlichen Speicherplatz. Insertionsort ist stabil, da die Reihenfolge der gleichwertigen Arrayelemente unverändert bleibt.
68 Sortieren durch Einfügen Joost-Pieter Katoen Datenstrukturen und Algorithmen 18/32 Insertionsort Animation und Algorithmus void insertionsort(int E[]) { 2 int i,j; 3 for (i = 1; i < E.length; i++) { 4 int v = E[i]; // speichere E[i] 5 for (j = i; j > 0 && E[j-1] > v; j--) { 6 E[j] = E[j-1]; // schiebe Element j-1 nach rechts 7 } 8 E[j] = v; // füge E[i] an der richtigen Stelle ein 9 } 10 } Insertionsort ist in-place, d. h. der Algorithmus arbeitet ohne zusätzlichen Speicherplatz. Insertionsort ist stabil, da die Reihenfolge der gleichwertigen Arrayelemente unverändert bleibt.
69 Sortieren durch Einfügen Joost-Pieter Katoen Datenstrukturen und Algorithmen 18/32 Insertionsort Animation und Algorithmus void insertionsort(int E[]) { 2 int i,j; 3 for (i = 1; i < E.length; i++) { 4 int v = E[i]; // speichere E[i] 5 for (j = i; j > 0 && E[j-1] > v; j--) { 6 E[j] = E[j-1]; // schiebe Element j-1 nach rechts 7 } 8 E[j] = v; // füge E[i] an der richtigen Stelle ein 9 } 10 } Insertionsort ist in-place, d. h. der Algorithmus arbeitet ohne zusätzlichen Speicherplatz. Insertionsort ist stabil, da die Reihenfolge der gleichwertigen Arrayelemente unverändert bleibt.
70 Sortieren durch Einfügen Joost-Pieter Katoen Datenstrukturen und Algorithmen 18/32 Insertionsort Animation und Algorithmus void insertionsort(int E[]) { 2 int i,j; 3 for (i = 1; i < E.length; i++) { 4 int v = E[i]; // speichere E[i] 5 for (j = i; j > 0 && E[j-1] > v; j--) { 6 E[j] = E[j-1]; // schiebe Element j-1 nach rechts 7 } 8 E[j] = v; // füge E[i] an der richtigen Stelle ein 9 } 10 } Insertionsort ist in-place, d. h. der Algorithmus arbeitet ohne zusätzlichen Speicherplatz. Insertionsort ist stabil, da die Reihenfolge der gleichwertigen Arrayelemente unverändert bleibt.
71 Sortieren durch Einfügen Joost-Pieter Katoen Datenstrukturen und Algorithmen 18/32 Insertionsort Animation und Algorithmus void insertionsort(int E[]) { 2 int i,j; 3 for (i = 1; i < E.length; i++) { 4 int v = E[i]; // speichere E[i] 5 for (j = i; j > 0 && E[j-1] > v; j--) { 6 E[j] = E[j-1]; // schiebe Element j-1 nach rechts 7 } 8 E[j] = v; // füge E[i] an der richtigen Stelle ein 9 } 10 } Insertionsort ist in-place, d. h. der Algorithmus arbeitet ohne zusätzlichen Speicherplatz. Insertionsort ist stabil, da die Reihenfolge der gleichwertigen Arrayelemente unverändert bleibt.
72 Sortieren durch Einfügen Joost-Pieter Katoen Datenstrukturen und Algorithmen 18/32 Insertionsort Animation und Algorithmus void insertionsort(int E[]) { 2 int i,j; 3 for (i = 1; i < E.length; i++) { 4 int v = E[i]; // speichere E[i] 5 for (j = i; j > 0 && E[j-1] > v; j--) { 6 E[j] = E[j-1]; // schiebe Element j-1 nach rechts 7 } 8 E[j] = v; // füge E[i] an der richtigen Stelle ein 9 } 10 } Insertionsort ist in-place, d. h. der Algorithmus arbeitet ohne zusätzlichen Speicherplatz. Insertionsort ist stabil, da die Reihenfolge der gleichwertigen Arrayelemente unverändert bleibt.
73 Sortieren durch Einfügen Joost-Pieter Katoen Datenstrukturen und Algorithmen 18/32 Insertionsort Animation und Algorithmus void insertionsort(int E[]) { 2 int i,j; 3 for (i = 1; i < E.length; i++) { 4 int v = E[i]; // speichere E[i] 5 for (j = i; j > 0 && E[j-1] > v; j--) { 6 E[j] = E[j-1]; // schiebe Element j-1 nach rechts 7 } 8 E[j] = v; // füge E[i] an der richtigen Stelle ein 9 } 10 } Insertionsort ist in-place, d. h. der Algorithmus arbeitet ohne zusätzlichen Speicherplatz. Insertionsort ist stabil, da die Reihenfolge der gleichwertigen Arrayelemente unverändert bleibt.
74 Sortieren durch Einfügen Joost-Pieter Katoen Datenstrukturen und Algorithmen 18/32 Insertionsort Animation und Algorithmus void insertionsort(int E[]) { 2 int i,j; 3 for (i = 1; i < E.length; i++) { 4 int v = E[i]; // speichere E[i] 5 for (j = i; j > 0 && E[j-1] > v; j--) { 6 E[j] = E[j-1]; // schiebe Element j-1 nach rechts 7 } 8 E[j] = v; // füge E[i] an der richtigen Stelle ein 9 } 10 } Insertionsort ist in-place, d. h. der Algorithmus arbeitet ohne zusätzlichen Speicherplatz. Insertionsort ist stabil, da die Reihenfolge der gleichwertigen Arrayelemente unverändert bleibt.
75 Sortieren durch Einfügen Joost-Pieter Katoen Datenstrukturen und Algorithmen 18/32 Insertionsort Animation und Algorithmus void insertionsort(int E[]) { 2 int i,j; 3 for (i = 1; i < E.length; i++) { 4 int v = E[i]; // speichere E[i] 5 for (j = i; j > 0 && E[j-1] > v; j--) { 6 E[j] = E[j-1]; // schiebe Element j-1 nach rechts 7 } 8 E[j] = v; // füge E[i] an der richtigen Stelle ein 9 } 10 } Insertionsort ist in-place, d. h. der Algorithmus arbeitet ohne zusätzlichen Speicherplatz. Insertionsort ist stabil, da die Reihenfolge der gleichwertigen Arrayelemente unverändert bleibt.
76 Sortieren durch Einfügen Joost-Pieter Katoen Datenstrukturen und Algorithmen 18/32 Insertionsort Animation und Algorithmus void insertionsort(int E[]) { 2 int i,j; 3 for (i = 1; i < E.length; i++) { 4 int v = E[i]; // speichere E[i] 5 for (j = i; j > 0 && E[j-1] > v; j--) { 6 E[j] = E[j-1]; // schiebe Element j-1 nach rechts 7 } 8 E[j] = v; // füge E[i] an der richtigen Stelle ein 9 } 10 } Insertionsort ist in-place, d. h. der Algorithmus arbeitet ohne zusätzlichen Speicherplatz. Insertionsort ist stabil, da die Reihenfolge der gleichwertigen Arrayelemente unverändert bleibt.
77 Sortieren durch Einfügen Joost-Pieter Katoen Datenstrukturen und Algorithmen 18/32 Insertionsort Animation und Algorithmus void insertionsort(int E[]) { 2 int i,j; 3 for (i = 1; i < E.length; i++) { 4 int v = E[i]; // speichere E[i] 5 for (j = i; j > 0 && E[j-1] > v; j--) { 6 E[j] = E[j-1]; // schiebe Element j-1 nach rechts 7 } 8 E[j] = v; // füge E[i] an der richtigen Stelle ein 9 } 10 } Insertionsort ist in-place, d. h. der Algorithmus arbeitet ohne zusätzlichen Speicherplatz. Insertionsort ist stabil, da die Reihenfolge der gleichwertigen Arrayelemente unverändert bleibt.
78 Sortieren durch Einfügen Joost-Pieter Katoen Datenstrukturen und Algorithmen 19/32 Insertionsort Best- und Worst-Case-Analyse Best-Case Im Best-Case ist das Array bereits sortiert.
79 Sortieren durch Einfügen Joost-Pieter Katoen Datenstrukturen und Algorithmen 19/32 Insertionsort Best- und Worst-Case-Analyse Best-Case Im Best-Case ist das Array bereits sortiert. Pro Element ist daher nur ein Vergleich nötig.
80 Sortieren durch Einfügen Joost-Pieter Katoen Datenstrukturen und Algorithmen 19/32 Insertionsort Best- und Worst-Case-Analyse Best-Case Im Best-Case ist das Array bereits sortiert. Pro Element ist daher nur ein Vergleich nötig. Es gilt: B(n) = n 1 Θ(n)
81 Sortieren durch Einfügen Joost-Pieter Katoen Datenstrukturen und Algorithmen 19/32 Insertionsort Best- und Worst-Case-Analyse Best-Case Im Best-Case ist das Array bereits sortiert. Pro Element ist daher nur ein Vergleich nötig. Es gilt: B(n) = n 1 Θ(n) Worst-Case Im Worst-Case wird das einzusortierende Element immer ganz vorne eingefügt.
82 Sortieren durch Einfügen Joost-Pieter Katoen Datenstrukturen und Algorithmen 19/32 Insertionsort Best- und Worst-Case-Analyse Best-Case Im Best-Case ist das Array bereits sortiert. Pro Element ist daher nur ein Vergleich nötig. Es gilt: B(n) = n 1 Θ(n) Worst-Case Im Worst-Case wird das einzusortierende Element immer ganz vorne eingefügt. Es musste mit allen vorhergehenden Elementen verglichen werden.
83 Sortieren durch Einfügen Joost-Pieter Katoen Datenstrukturen und Algorithmen 19/32 Insertionsort Best- und Worst-Case-Analyse Best-Case Im Best-Case ist das Array bereits sortiert. Pro Element ist daher nur ein Vergleich nötig. Es gilt: B(n) = n 1 Θ(n) Worst-Case Im Worst-Case wird das einzusortierende Element immer ganz vorne eingefügt. Es musste mit allen vorhergehenden Elementen verglichen werden. Das tritt etwa auf, wenn das Array umgekehrt vorsortiert war.
84 Sortieren durch Einfügen Joost-Pieter Katoen Datenstrukturen und Algorithmen 19/32 Insertionsort Best- und Worst-Case-Analyse Best-Case Im Best-Case ist das Array bereits sortiert. Pro Element ist daher nur ein Vergleich nötig. Es gilt: B(n) = n 1 Θ(n) Worst-Case Im Worst-Case wird das einzusortierende Element immer ganz vorne eingefügt. Es musste mit allen vorhergehenden Elementen verglichen werden. Das tritt etwa auf, wenn das Array umgekehrt vorsortiert war. Zum Einsortieren des i-ten Elements sind im schlimmsten Fall i Vergleiche nötig:
85 Sortieren durch Einfügen Joost-Pieter Katoen Datenstrukturen und Algorithmen 19/32 Insertionsort Best- und Worst-Case-Analyse Best-Case Im Best-Case ist das Array bereits sortiert. Pro Element ist daher nur ein Vergleich nötig. Es gilt: B(n) = n 1 Θ(n) Worst-Case Im Worst-Case wird das einzusortierende Element immer ganz vorne eingefügt. Es musste mit allen vorhergehenden Elementen verglichen werden. Das tritt etwa auf, wenn das Array umgekehrt vorsortiert war. Zum Einsortieren des i-ten Elements sind im schlimmsten Fall n 1 i Vergleiche nötig: W (n) = i = i=1
86 Sortieren durch Einfügen Joost-Pieter Katoen Datenstrukturen und Algorithmen 19/32 Insertionsort Best- und Worst-Case-Analyse Best-Case Im Best-Case ist das Array bereits sortiert. Pro Element ist daher nur ein Vergleich nötig. Es gilt: B(n) = n 1 Θ(n) Worst-Case Im Worst-Case wird das einzusortierende Element immer ganz vorne eingefügt. Es musste mit allen vorhergehenden Elementen verglichen werden. Das tritt etwa auf, wenn das Array umgekehrt vorsortiert war. Zum Einsortieren des i-ten Elements sind im schlimmsten Fall n 1 i Vergleiche nötig: W (n) = i = n (n 1) 2 Θ(n 2 ) i=1
87 Sortieren durch Einfügen Joost-Pieter Katoen Datenstrukturen und Algorithmen 20/32 Insertionsort Average-Case-Analyse (I) Annahmen für die Average-Case-Analyse Alle Permutationen von Elementen treten in gleicher Häufigkeit auf. Die zu sortierenden Elemente sind alle verschieden.
88 Sortieren durch Einfügen Joost-Pieter Katoen Datenstrukturen und Algorithmen 20/32 Insertionsort Average-Case-Analyse (I) Annahmen für die Average-Case-Analyse Alle Permutationen von Elementen treten in gleicher Häufigkeit auf. Die zu sortierenden Elemente sind alle verschieden. Es gilt: n 1 A(n) = erwartete Anzahl an Vergleichen, um E[i] einzusortieren i=1
89 Sortieren durch Einfügen Joost-Pieter Katoen Datenstrukturen und Algorithmen 20/32 Insertionsort Average-Case-Analyse (I) Annahmen für die Average-Case-Analyse Alle Permutationen von Elementen treten in gleicher Häufigkeit auf. Die zu sortierenden Elemente sind alle verschieden. Es gilt: n 1 A(n) = erwartete Anzahl an Vergleichen, um E[i] einzusortieren i=1 Die erwartete Anzahl an Vergleichen, um den richtigen Platz für E[i] zu finden wird dann wie folgt hergeleitet:
90 Sortieren durch Einfügen Joost-Pieter Katoen Datenstrukturen und Algorithmen 21/32 Insertionsort Average-Case-Analyse (II) i { i-tes Element wird Pr an Position j eingefügt j=0 } Anzahl Vergleiche, um E[i] an Position j einzufügen
91 Sortieren durch Einfügen Joost-Pieter Katoen Datenstrukturen und Algorithmen 21/32 Insertionsort Average-Case-Analyse (II) i { i-tes Element wird Pr an Position j eingefügt j=0 = i j=0 1 Anzahl Vergleiche, um E[i] i + 1 an Position j einzufügen } Anzahl Vergleiche, um E[i] an Position j einzufügen E[i] wird an beliebiger Position j mit gleicher W lichkeit eingefügt
92 Sortieren durch Einfügen Joost-Pieter Katoen Datenstrukturen und Algorithmen 21/32 Insertionsort Average-Case-Analyse (II) i { i-tes Element wird Pr an Position j eingefügt j=0 = i j=0 1 Anzahl Vergleiche, um E[i] i + 1 an Position j einzufügen = 1 i + 1 i + 1 i + 1 } i (i j + 1) j=1 Anzahl Vergleiche, um E[i] an Position j einzufügen E[i] wird an beliebiger Position j mit gleicher W lichkeit eingefügt Anzahl Vergleiche, um an Position 0 oder 1 einzufügen ist i, sonst i j+1.
93 Sortieren durch Einfügen Joost-Pieter Katoen Datenstrukturen und Algorithmen 21/32 Insertionsort Average-Case-Analyse (II) i { i-tes Element wird Pr an Position j eingefügt j=0 = i j=0 1 Anzahl Vergleiche, um E[i] i + 1 an Position j einzufügen = 1 i + 1 i + 1 i + 1 = i i i + 1 } i (i j + 1) j=1 i j = j=0 Anzahl Vergleiche, um E[i] an Position j einzufügen i i i i+1 i + 2 E[i] wird an beliebiger Position j mit gleicher W lichkeit eingefügt Anzahl Vergleiche, um an Position 0 oder 1 einzufügen ist i, sonst i j+1. Vereinfachen = i i + 1.
94 Sortieren durch Einfügen Joost-Pieter Katoen Datenstrukturen und Algorithmen 22/32 Insertionsort Average-Case-Analyse (III) Damit gilt für A(n): n 1 ( i A(n) = ) i + 1 i=1
95 Sortieren durch Einfügen Joost-Pieter Katoen Datenstrukturen und Algorithmen 22/32 Insertionsort Average-Case-Analyse (III) Damit gilt für A(n): n 1 ( i A(n) = ) i + 1 = i=1 n (n 1) 4 + (n 1) n i=2 1 i Auseinanderziehen
96 Sortieren durch Einfügen Joost-Pieter Katoen Datenstrukturen und Algorithmen 22/32 Insertionsort Average-Case-Analyse (III) Damit gilt für A(n): n 1 ( i A(n) = ) i + 1 = = i=1 n (n 1) 4 n (n 1) 4 + (n 1) + n n i=1 1 i n i=2 1 i Auseinanderziehen Verschieben des Summenstarts
97 Sortieren durch Einfügen Joost-Pieter Katoen Datenstrukturen und Algorithmen 22/32 Insertionsort Average-Case-Analyse (III) Damit gilt für A(n): n 1 ( i A(n) = ) i + 1 = = A(n) i=1 n (n 1) 4 n (n 1) 4 n (n 1) 4 + (n 1) + n n i=1 1 i n i=2 1 i + n ln n Θ(n 2 ) Auseinanderziehen Verschieben des Summenstarts Harmonische Reihe: n (1/i) ln n i=1
98 Mergesort Joost-Pieter Katoen Datenstrukturen und Algorithmen 23/32 Übersicht 1 Sortieren - Einführung Bedeutung des Sortierens Dutch National Flag Problem 2 Sortieren durch Einfügen 3 Mergesort Das Divide-and-Conquer Paradigma Mergesort 4 Effizienteres Sortieren?
99 Mergesort Joost-Pieter Katoen Datenstrukturen und Algorithmen 24/32 Divide-and-Conquer Teile-und-Beherrsche Algorithmen (divide and conquer) teilen das Problem in mehrere Teilprobleme auf, die dem Ausgangsproblem ähneln, jedoch von kleinerer Größe sind.
100 Mergesort Joost-Pieter Katoen Datenstrukturen und Algorithmen 24/32 Divide-and-Conquer Teile-und-Beherrsche Algorithmen (divide and conquer) teilen das Problem in mehrere Teilprobleme auf, die dem Ausgangsproblem ähneln, jedoch von kleinerer Größe sind. Sie lösen die Teilprobleme rekursiv und kombinieren diese Lösungen dann, um die Lösung des eigentlichen Problems zu erstellen.
101 Mergesort Joost-Pieter Katoen Datenstrukturen und Algorithmen 24/32 Divide-and-Conquer Teile-und-Beherrsche Algorithmen (divide and conquer) teilen das Problem in mehrere Teilprobleme auf, die dem Ausgangsproblem ähneln, jedoch von kleinerer Größe sind. Sie lösen die Teilprobleme rekursiv und kombinieren diese Lösungen dann, um die Lösung des eigentlichen Problems zu erstellen. Das Paradigma von Teile-und-Beherrsche umfasst 3 Schritte auf jeder Rekursionsebene:
102 Mergesort Joost-Pieter Katoen Datenstrukturen und Algorithmen 24/32 Divide-and-Conquer Teile-und-Beherrsche Algorithmen (divide and conquer) teilen das Problem in mehrere Teilprobleme auf, die dem Ausgangsproblem ähneln, jedoch von kleinerer Größe sind. Sie lösen die Teilprobleme rekursiv und kombinieren diese Lösungen dann, um die Lösung des eigentlichen Problems zu erstellen. Das Paradigma von Teile-und-Beherrsche umfasst 3 Schritte auf jeder Rekursionsebene: Teile das Problem in eine Anzahl von Teilproblemen auf.
103 Mergesort Joost-Pieter Katoen Datenstrukturen und Algorithmen 24/32 Divide-and-Conquer Teile-und-Beherrsche Algorithmen (divide and conquer) teilen das Problem in mehrere Teilprobleme auf, die dem Ausgangsproblem ähneln, jedoch von kleinerer Größe sind. Sie lösen die Teilprobleme rekursiv und kombinieren diese Lösungen dann, um die Lösung des eigentlichen Problems zu erstellen. Das Paradigma von Teile-und-Beherrsche umfasst 3 Schritte auf jeder Rekursionsebene: Teile das Problem in eine Anzahl von Teilproblemen auf. Beherrsche die Teilprobleme durch rekursives Lösen. Hinreichend kleine Teilprobleme werden direkt gelöst.
104 Mergesort Joost-Pieter Katoen Datenstrukturen und Algorithmen 24/32 Divide-and-Conquer Teile-und-Beherrsche Algorithmen (divide and conquer) teilen das Problem in mehrere Teilprobleme auf, die dem Ausgangsproblem ähneln, jedoch von kleinerer Größe sind. Sie lösen die Teilprobleme rekursiv und kombinieren diese Lösungen dann, um die Lösung des eigentlichen Problems zu erstellen. Das Paradigma von Teile-und-Beherrsche umfasst 3 Schritte auf jeder Rekursionsebene: Teile das Problem in eine Anzahl von Teilproblemen auf. Beherrsche die Teilprobleme durch rekursives Lösen. Hinreichend kleine Teilprobleme werden direkt gelöst. Verbinde die Lösungen der Teilprobleme zur Lösung des Ausgangsproblem.
105 Mergesort Joost-Pieter Katoen Datenstrukturen und Algorithmen 25/32 Mergesort Strategie rekursiv Sortieren Mitte rekursiv Sortieren Verschmelzen Teile das Array in zwei möglichst gleichgroße Hälften. Beherrsche: Sortiere die Teile durch rekursive Mergesort-Aufrufe. Verbinde: Mische die 2 sortierte Teilsequenzen zu einem einzigen, sortierten Array.
106 Mergesort Joost-Pieter Katoen Datenstrukturen und Algorithmen 26/32 Mergesort Algorithm 1 void mergesort(int E[], int left, int right) { 2 if (left < right) { 3 int mid = (left + right) / 2; // finde Mitte 4 mergesort(e, left, mid); // sortiere linke Hälfte 5 mergesort(e, mid + 1, right); // sortiere rechte Hälfte 6 // Verschmelzen der sortierten Hälften 7 merge(e, left, mid, right); 8 } 9 } 10 // Aufruf: mergesort(e, 0, E.length-1); Verschmelzen kann man in Linearzeit. Wie?
107 Mergesort Joost-Pieter Katoen Datenstrukturen und Algorithmen 27/32 Mergesort Animation
108 Mergesort Joost-Pieter Katoen Datenstrukturen und Algorithmen 27/32 Mergesort Animation
109 Mergesort Joost-Pieter Katoen Datenstrukturen und Algorithmen 27/32 Mergesort Animation
110 Mergesort Joost-Pieter Katoen Datenstrukturen und Algorithmen 27/32 Mergesort Animation
111 Mergesort Joost-Pieter Katoen Datenstrukturen und Algorithmen 27/32 Mergesort Animation
112 Mergesort Joost-Pieter Katoen Datenstrukturen und Algorithmen 27/32 Mergesort Animation
113 Mergesort Joost-Pieter Katoen Datenstrukturen und Algorithmen 27/32 Mergesort Animation
114 Mergesort Joost-Pieter Katoen Datenstrukturen und Algorithmen 27/32 Mergesort Animation
115 Mergesort Joost-Pieter Katoen Datenstrukturen und Algorithmen 27/32 Mergesort Animation
Datenstrukturen und Algorithmen
Joost-Pieter Katoen Datenstrukturen und Algorithmen 1/33 Datenstrukturen und Algorithmen Vorlesung 7: Sortieren (K2) Joost-Pieter Katoen Lehrstuhl für Informatik 2 Software Modeling and Verification Group
Datenstrukturen und Algorithmen
Joost-Pieter Katoen Datenstrukturen und Algorithmen 1/36 Datenstrukturen und Algorithmen Vorlesung 7: Sortieren (K2) Joost-Pieter Katoen Lehrstuhl für Informatik 2 Software Modeling and Verification Group
Übersicht. Datenstrukturen und Algorithmen. Die Bedeutung des Sortierens. Übersicht. Vorlesung 6: Sortieren (K2)
Datenstrukturen und Algorithmen Vorlesung 6: (K2) Joost-Pieter Katoen 1 - Einführung Bedeutung des s 2 durch Einfügen Lehrstuhl für Informatik 2 Software Modeling and Verification Group http://moves.rwth-aachen.de/teaching/ss-15/dsal/
VL-06: Sortieren I. (Datenstrukturen und Algorithmen, SS 2017) Janosch Fuchs
VL-06: Sortieren I (Datenstrukturen und Algorithmen, SS 2017) Janosch Fuchs SS 2017, RWTH DSAL/SS 2017 VL-06: Sortieren I 1/34 Organisatorisches Vorlesung: Gerhard Woeginger (Zimmer 4024 im E1) Sprechstunde:
Sortieren I. Einführung ins Sortieren. Organisatorisches. VL-06: Sortieren I. (Datenstrukturen und Algorithmen, SS 2017) Janosch Fuchs
Organisatorisches VL-06: Sortieren I (Datenstrukturen und Algorithmen, SS 2017) nosch Fuchs Vorlesung: Gerhard Woeginger (Zimmer 4024 im E1) Sprechstunde: Mittwoch 11:15 12:00 Übungen: Tim Hartmann, David
Übersicht. Datenstrukturen und Algorithmen. Übersicht. Divide-and-Conquer. Vorlesung 9: Quicksort (K7)
Datenstrukturen und Algorithmen Vorlesung 9: (K7) Joost-Pieter Katoen Lehrstuhl für Informatik 2 Software Modeling and Verification Group http://www-i2.rwth-aachen.de/i2/dsal0/ Algorithmus 8. Mai 200 Joost-Pieter
Übersicht. Datenstrukturen und Algorithmen. Divide-and-Conquer. Übersicht. Vorlesung 9: Quicksort (K7)
Datenstrukturen und Algorithmen Vorlesung 9: (K7) Joost-Pieter Katoen Algorithmus Lehrstuhl für Informatik 2 Software Modeling and Verification Group http://moves.rwth-aachen.de/teaching/ss-5/dsal/ 2 7.
Tutoraufgabe 1 (Sortieralgorithmus):
Prof. aa Dr. Ir. Joost-Pieter Katoen Datenstrukturen und Algorithmen SS Tutoriumslösung - Übung 4 (Abgabe 2..2) Christian Dehnert, Friedrich Gretz, Benjamin Kaminski, Thomas Ströder Tutoraufgabe (Sortieralgorithmus):
Tutoraufgabe 1 (Sortieren): Lösung: Datenstrukturen und Algorithmen SS14 Lösung - Übung 4
Prof. aa Dr. E. Ábrahám Datenstrukturen und Algorithmen SS Lösung - Übung F. Corzilius, S. Schupp, T. Ströder Tutoraufgabe (Sortieren): a) Sortieren Sie das folgende Array durch Anwendung des Selectionsort-Algorithmus.
Algorithmen I. Tutorium 1-3. Sitzung. Dennis Felsing
Algorithmen I Tutorium 1-3. Sitzung Dennis Felsing dennis.felsing@student.kit.edu www.stud.uni-karlsruhe.de/~ubcqr/algo 2011-05-02 Überblick 1 Sortieren und Suchen 2 Mastertheorem 3 Datenstrukturen 4 Kreativaufgabe
Grundlagen: Algorithmen und Datenstrukturen
Grundlagen: Algorithmen und Datenstrukturen Prof. Dr. Hanjo Täubig Lehrstuhl für Effiziente Algorithmen (Prof. Dr. Ernst W. Mayr) Institut für Informatik Technische Universität München Sommersemester 2010
damit hätten wir nach Ende der Schleife: "a[0 n-1] enthält nur Elemente aus a[0 n-1], aber in sortierter Reihenfolge".
![damit hätten wir nach Ende der Schleife: a[0 n-1] enthält nur Elemente aus a[0 n-1], aber in sortierter Reihenfolge.](/thumbs/53/31257583.jpg "damit hätten wir nach Ende der Schleife: a[0 n-1] enthält nur Elemente aus a[0 n-1], aber in sortierter Reihenfolge.")
Korrektheit Invariante: a[0 k-1] enthält nur Elemente aus a[0 k-1], aber in sortierter Reihenfolge Terminierung: Die Schleife endet mit k=n def insertionsort(a): for k in range( 1, len(a) ): while i >
Abschnitt: Algorithmendesign und Laufzeitanalyse
Abschnitt: Algorithmendesign und Laufzeitanalyse Definition Divide-and-Conquer Paradigma Divide-and-Conquer Algorithmen verwenden die Strategien 1 Divide: Teile das Problem rekursiv in Subproblem gleicher
3.2. Divide-and-Conquer-Methoden
LUDWIG- MAXIMILIANS- UNIVERSITY MUNICH DEPARTMENT INSTITUTE FOR INFORMATICS DATABASE 3.2. Divide-and-Conquer-Methoden Divide-and-Conquer-Methoden Einfache Sortieralgorithmen reduzieren die Größe des noch
Algorithmen und Datenstrukturen
Algorithmen und Datenstrukturen 11. Übung Verkettete Listen, Sortieren Insertionsort, Mergesort, Radixsort, Quicksort Clemens Lang Übungen zu AuD 19. Januar 2010 Clemens Lang (Übungen zu AuD) Algorithmen
Übersicht 1 Suchalgorithmen. Übersicht
Datenstrukturen und Algorithmen Vorlesungen 6-7: für lineare Datenstrukturen (K,6,7,8) Prof. Dr. Erika Ábrahám Theorie Hybrider Systeme Informatik http://ths.rwth-aachen.de/teaching/ss-14/ datenstrukturen-und-algorithmen/
Übersicht. Datenstrukturen und Algorithmen. Übersicht. Heaps. Vorlesung 8: Heapsort (K6) Joost-Pieter Katoen. 7. Mai 2015
Datenstrukturen und Algorithmen Vorlesung 8: (K6) 1 Joost-Pieter Katoen Lehrstuhl für Informatik Software Modeling and Verification Group http://moves.rwth-aachen.de/teaching/ss-15/dsal/ 7. Mai 015 3 Joost-Pieter
2 Sortieren. Beispiel: Es seien n = 8 und a = i : a i : ϕ(i) : a ϕ(i) :
2 Sortieren Das Sortieren einer Datenfolge ist eines der am leichtesten zu verstehenden und am häufigsten auftretenden algorithmischen Probleme. In seiner einfachsten Form besteht das Problem darin, eine
Datenstrukturen & Algorithmen
Datenstrukturen & Algorithmen Matthias Zwicker Universität Bern Frühling 2010 Übersicht Untere Schranken für Sortieren Sortieren mit linearem Aufwand Mediane und Ranggrössen 2 Wie schnell können wir sortieren?
Sortieren II / HeapSort Heaps
Organisatorisches VL-07: Sortieren II: HeapSort (Datenstrukturen und Algorithmen, SS 2017) Vorlesung: Gerhard Woeginger (Zimmer 4024 im E1) Email: dsal-i1@algo.rwth-aachen.de Webseite: http://algo.rwth-aachen.de/lehre/ss17/dsa.php
Prof. Dr. Margarita Esponda
Algorithmen und Programmieren II Sortieralgorithmen imperativ Teil I Prof. Dr. Margarita Esponda Freie Universität Berlin Sortieralgorithmen Bubble-Sort Insert-Sort Selection-Sort Vergleichsalgorithmen
Algorithmen und Datenstrukturen
Algorithmen und Datenstrukturen A7. Sortieren III Marcel Lüthi and Gabriele Röger Universität Basel 14. März 2018 Untere Schranke Sortierverfahren Sortieren Vergleichsbasierte Verfahren Nicht vergleichsbasierte
Sortieralgorithmen OOPM, Ralf Lämmel
Unterhaltet Euch mal mit Euren Großeltern wie Sortieren früher funktionierte! Sortieralgorithmen OOPM, Ralf Lämmel 230 Eine unsortierte Liste 7 3 2 5 2 3 5 7 Die sortierte Liste 231 Wiederholung: Das Problem
A7.1 Untere Schranke. Algorithmen und Datenstrukturen. A7.1 Untere Schranke. Algorithmen und Datenstrukturen. A7.2 Quicksort. A7.
Algorithmen und Datenstrukturen 14. März 2018 A7. III Algorithmen und Datenstrukturen A7. III Marcel Lüthi and Gabriele Röger Universität Basel 14. März 2018 A7.1 Untere Schranke A7.2 Quicksort A7.3 Heapsort
Heapsort / 1 A[1] A[2] A[3] A[4] A[5] A[6] A[7] A[8]
![Heapsort / 1 A[1] A[2] A[3] A[4] A[5] A[6] A[7] A[8]](/thumbs/69/61689021.jpg "Heapsort / 1 A[1] A[2] A[3] A[4] A[5] A[6] A[7] A[8]")
Heapsort / 1 Heap: Ein Array heißt Heap, falls A [i] A [2i] und A[i] A [2i + 1] (für 2i n bzw. 2i + 1 n) gilt. Beispiel: A[1] A[2] A[3] A[4] A[5] A[6] A[7] A[8] Heapsort / 2 Darstellung eines Heaps als
Programmieren I. Kapitel 7. Sortieren und Suchen
Programmieren I Kapitel 7. Sortieren und Suchen Kapitel 7: Sortieren und Suchen Ziel: Varianten der häufigsten Anwendung kennenlernen Ordnung Suchen lineares Suchen Binärsuche oder Bisektionssuche Sortieren
Praktikum Algorithmische Anwendungen WS 2006/07 Sortieren in linearer Laufzeit
Praktikum Algorithmische Anwendungen WS 2006/07 Sortieren in linearer Laufzeit Team A blau Martin Herfurth 11043831 Markus Wagner 11043447 5. Februar 2007 1 1 Untere Schranke für Vergleichsbasierte Algorithmen
Mergesort. Idee. Die folgende Funktion mergesort sortiert eine Folge a vom unteren Index lo bis zum oberen Index hi.
Sortierverfahren Mergesort Das Sortierverfahren Mergesort erzeugt eine sortierte Folge durch Verschmelzen (engl.: to merge) sortierter Teilstücke. Mit einer Zeitkomplexität von (n log(n)) ist das Verfahren
Grundlagen der Informatik
Jörn Fischer j.fischer@hs-mannheim.de Willkommen zur Vorlesung Grundlagen der Informatik ADS-Teil Page 2 Überblick Inhalt 1 Eigenschaften von Algorithmen Algorithmenbegriff O-Notation Entwurfstechniken
Elementare Sortierverfahren
Algorithmen und Datenstrukturen I Elementare Sortierverfahren Fakultät für Informatik und Mathematik Hochschule München Letzte Änderung: 18.03.2018 18:16 Inhaltsverzeichnis Sortieren.......................................
4. Sortieren 4.1 Vorbemerkungen
. Seite 1/21 4. Sortieren 4.1 Vorbemerkungen allgemeines Sortierproblem spezielle Sortierprobleme Ordne a 1,..., a n so um, dass Elemente in aufsteigender Reihenfolge stehen. Die a i stammen aus vollständig
Informatik II Sortieren
lausthal Sortieralgorithmen Informatik II Sortieren Preprocessing fürs Suchen sind für kommerzielle Anwendungen häufig die Programmteile, die die meiste Rechenzeit verbrauchen viele raffinierte Methoden
Informatik II Sortieren
lausthal Informatik II Sortieren. Zachmann lausthal University, ermany zach@in.tu-clausthal.de Sortieralgorithmen Preprocessing fürs Suchen sind für kommerzielle Anwendungen häufig die Programmteile, die
Algorithms & Data Structures 2
Algorithms & Data Structures Digital Sorting WS B. Anzengruber-Tanase (Institute for Pervasive Computing, JKU Linz) (Institute for Pervasive Computing, JKU Linz) WIEDERHOLUNG :: UNTERE SCHRANKE FÜR SORTIEREN
Abschnitt 19: Sortierverfahren
Abschnitt 19: Sortierverfahren 19. Sortierverfahren 19.1 Allgemeines 19.2 Einfache Sortierverfahren 19.3 Effizientes Sortieren: Quicksort 19.4 Zusammenfassung 19 Sortierverfahren Informatik 2 (SS 07) 758
Aufgabe (Schreibtischtest, Algorithmenanalyse)
Aufgabe (Schreibtischtest, Algorithmenanalyse) Führen Sie einen Schreibtischtest für den Algorithmus Positionsort für das folgende Eingabe-Array durch. Geben Sie nach jedem Durchlauf der for-schleife mit
Übung: Algorithmen und Datenstrukturen SS 2007
Übung: Algorithmen und Datenstrukturen SS 2007 Prof. Lengauer Sven Apel, Michael Claÿen, Christoph Zengler, Christof König Blatt 5 Votierung in der Woche vom 04.06.0708.06.07 Aufgabe 12 Manuelle Sortierung
Datenstrukturen & Algorithmen
Datenstrukturen & Algorithmen Matthias Zwicker Universität Bern Frühling 2010 Übersicht Sortieralgorithmen Einleitung Heapsort Quicksort 2 Motivation Sortieren ist Voraussetzung für viele Anwendungen Nach
Algorithmen und Datenstrukturen 1
Algorithmen und Datenstrukturen 1 4. Vorlesung Peter F. Stadler Universität Leipzig Institut für Informatik studla@bioinf.uni-leipzig.de 4. Sortierverfahren Elementare Sortierverfahren - Sortieren durch
f 1 (n) = log(n) + n 2 n 5 f 2 (n) = n 3 + n 2 f 3 (n) = log(n 2 ) f 4 (n) = n n f 5 (n) = (log(n)) 2
Prof. aa Dr. E. Ábrahám Datenstrukturen und Algorithmen SS Lösung - Präsenzübung.05.0 F. Corzilius, S. Schupp, T. Ströder Aufgabe (Asymptotische Komplexität): (6 + 0 + 6 = Punkte) a) Geben Sie eine formale
Algorithmen und Datenstrukturen SS09. Foliensatz 15. Michael Brinkmeier. Technische Universität Ilmenau Institut für Theoretische Informatik
Foliensatz 15 Michael Brinkmeier Technische Universität Ilmenau Institut für Theoretische Informatik Sommersemester 2009 TU Ilmenau Seite 1 / 16 Untere Schranken für das Vergleichsbasierte Sortieren TU
lim log 2n n = > 0 Da es einen Limes gibt, gibt es auch einen Limes inferior, der gleich diesem Limes ist.
Prof. aa Dr. Ir. Joost-Pieter Katoen Christian Dehnert, Jonathan Heinen, Thomas Ströder, Sabrina von Styp Aufgabe 1 (O-Notation): Beweisen oder widerlegen Sie die folgenden Aussagen: (3 + 3 + 4 = 10 Punkte)
Programmiertechnik II
Sortieren: Einfache Algorithmen Sortieren Abstrakte Operation geg: Menge von items (Elemente) jedes Element besitzt Sortierschlüssel Schlüssel unterliegen einer Ordnung eventuell sind doppelte Schlüssel
Kap. 3: Sortieren. Überblick. Unser Sortierproblem. Motivation. Laufzeitmessung. Warum soll ich hier bleiben? Sortierverfahren sind WICHTIG!!!
Kap. 3: Sortieren Professor Dr. Lehrstuhl für Algorithm Engineering, LS11 Fakultät für Informatik, TU Dortmund Überblick Einführung in das Sortierproblem Insertion-Sort Selection-Sort Merge-Sort 4. VO
JAVA - Suchen - Sortieren
Übungen Informatik I JAVA - Suchen - Sortieren http://www.fbi-lkt.fh-karlsruhe.de/lab/info01/tutorial Übungen Informatik 1 Folie 1 Inhalt Suchen/Sortieren binary search mergesort bubblesort Übungen Informatik
Kap. 3: Sortieren. 4. VO DAP2 SS April 2009
Kap. 3: Sortieren Professor Dr. Lehrstuhl für Algorithm Engineering, LS11 Fakultät für Informatik, TU Dortmund 4. VO DAP2 SS 2009 23. April 2009 1 Überblick Einführung in das Sortierproblem Insertion-Sort
Übung Algorithmen und Datenstrukturen
Übung Algorithmen und Datenstrukturen Sommersemester 2017 Patrick Schäfer, Humboldt-Universität zu Berlin Agenda: Sortierverfahren 1. Schreibtischtest 2. Stabilität 3. Sortierung spezieller Arrays 4. Untere
Grundlagen der Programmierung 2. Sortierverfahren
Grundlagen der Programmierung 2 Sortierverfahren Prof. Dr. Manfred Schmidt-Schauÿ Künstliche Intelligenz und Softwaretechnologie 30. Mai 2006 Sortieren Ziel: Bringe Folge von Objekten in eine Reihenfolge
Präsenzübung Datenstrukturen und Algorithmen SS 2014
Prof. aa Dr. E. Ábrahám F. Corzilius, S. Schupp, T. Ströder Präsenzübung Datenstrukturen und Algorithmen SS 2014 Vorname: Nachname: Studiengang (bitte genau einen markieren): Informatik Bachelor Informatik
Algorithmen und Datenstrukturen
Algorithmen und Datenstrukturen A3. Sortieren: Selection- und Insertionsort Marcel Lüthi and Gabriele Röger Universität Basel 1. März 2018 Sortieralgorithmen Inhalt dieser Veranstaltung A&D Sortieren Komplexitätsanalyse
2.2 Allgemeine (vergleichsbasierte) Sortierverfahren
. Allgemeine (vergleichsbasierte) Sortierverfahren Vergleichsbaum: Der Aufbau des Verbleichsbaum ist für jeden Algorithmus und jede Eingabelänge n gleich. Jede Permutation der Eingabe, muss zu einem anderen
2 Sortieren durch Vergleichen Eingabefolge a 1, a 2,..., a n 2, 1, 3 Sortieralg. Für festes n ist ein vergleichsbasierter Sortieralg. charakterisiert
1 Algorithmen und Datenstrukturen Wintersemester 2014/15 9. Vorlesung Sortieren in Linearzeit Prof. Dr. Alexander Wolff Lehrstuhl für Informatik I 2 Sortieren durch Vergleichen Eingabefolge a 1, a 2,...,
Vorlesung Datenstrukturen
Vorlesung Datenstrukturen Sortieren fortgesetzt Maike Buchin 16.5.2017 5.6 Brechen der Unteren Schranke nur Vergleichen erlauben keine Algorithmen mit Laufzeit schneller als O(n log n) stattdessen: Struktur
QuickSort ist ein Sortieralgorithmus, der auf der Idee des Teile & Beherrsche beruht, und das gegebene Array an Ort und Stelle (in place) sortiert
4.3.6 QuickSort QuickSort ist ein Sortieralgorithmus, der auf der Idee des Teile & Beherrsche beruht, und das gegebene Array an Ort und Stelle (in place) sortiert QuickSort teilt das gegebene Array anhand
Übersicht. Einfache Verfahren MergeSort Untere Schranke QuickSort Selektieren Schnelleres Sortieren Externes Sortieren. 6 Sortieren.
Übersicht 6 Sortieren Einfache Verfahren MergeSort Untere Schranke QuickSort Selektieren Schnelleres Sortieren Externes Sortieren H. Täubig (TUM) GAD SS 14 221 Statisches Wörterbuch Sortieren Lösungsmöglichkeiten:
A3.1 Sortieralgorithmen
Algorithmen und Datenstrukturen 1. März 2018 A3. : Selection- und Insertionsort Algorithmen und Datenstrukturen A3. : Selection- und Insertionsort Marcel Lüthi and Gabriele Röger Universität Basel 1. März
Algorithmen und Datenstrukturen (Th. Ottmann und P. Widmayer) Folien: Einfache Sortierverfahren Autor: Stefan Edelkamp
Algorithmen und Datenstrukturen (Th. Ottmann und P. Widmayer) Folien: Einfache Sortierverfahren Autor: Stefan Edelkamp Institut für Informatik Georges-Köhler-Allee Albert-Ludwigs-Universität Freiburg 1
1. Musterlösung. Problem 1: Average-case-Laufzeit vs. Worst-case-Laufzeit ** i=1
Universität Karlsruhe Algorithmentechnik Fakultät für Informatik WS 05/06 ITI Wagner. Musterlösung Problem : Average-case-Laufzeit vs. Worst-case-Laufzeit ** (a) Im schlimmsten Fall werden für jedes Element
Kapitel 3: Sortierverfahren Gliederung
Gliederung 1. Grundlagen 2. Zahlentheoretische Algorithmen 3. Sortierverfahren 4. Ausgewählte Datenstrukturen 5. Dynamisches Programmieren 6. Graphalgorithmen 7. String-Matching 8. Kombinatorische Algorithmen
UE Algorithmen und Datenstrukturen 1 UE Praktische Informatik 1. Übung 9. Sortieren
UE Algorithmen und Datenstrukturen 1 UE Praktische Informatik 1 Übung 9 Sortieren Institut für Pervasive Computing Johannes Kepler Universität Linz Altenberger Straße 69, A-4040 Linz Sortieren :: Problemstellung
Algorithmen und Datenstrukturen
Algorithmen und Datenstrukturen Dr. Michael Brinkmeier Technische Universität Ilmenau Fakultät Informatik und Automatisierung Fachgebiet Automaten und Formale Sprachen 4.7.2007 Dr. Michael Brinkmeier (TU
Kapitel 6 Elementare Sortieralgorithmen
Kapitel 6 Elementare Sortieralgorithmen Ziel: Kennenlernen elementarer Sortierverfahren und deren Effizienz Zur Erinnerung: Das Sortier-Problem Gegeben: Folge A von n Elementen a 1, a 2,..., a n ; Eine
Mergesort. Inhaltsverzeichnis. Veranschaulichung der Funktionsweise. aus Wikipedia, der freien Enzyklopädie
Mergesort aus Wikipedia, der freien Enzyklopädie Mergesort ist ein rekursiver, stabiler Sortieralgorithmus, der ähnlich wie Quicksort nach dem Prinzip Teile und herrsche (engl. Divide and conquer) arbeitet.
2.3.1 Einleitung Einfache Sortierverfahren Höhere Sortierverfahren Komplexität von Sortierverfahren Spezielle Sortierverfahren
2.3 Sortieren 2.3.1 Einleitung 2.3.2 Einfache Sortierverfahren 2.3.3 Höhere Sortierverfahren 2.3.4 Komplexität von Sortierverfahren 2.3.5 Spezielle Sortierverfahren 1 Selection-Sort Idee: Suche kleinstes
(08 - Einfache Sortierverfahren)
Vorlesung Informatik 2 Algorithmen und Datenstrukturen (08 - Einfache Sortierverfahren) Prof. Dr. Susanne Albers Sortieren Motivation, Einführung Datenbestände müssen sehr oft sortiert werden, etwa um
Übersicht. Datenstrukturen und Algorithmen. Übersicht. Motivation. Vorlesung 10: Binäre Suchbäume
Übersicht Datenstrukturen und lgorithmen Vorlesung : Joost-Pieter Katoen Lehrstuhl für Informatik 2 Software Modeling and Verification Group http://moves.rwth-aachen.de/teaching/ss-/dsal/ 1 Suche Einfügen
Klausur Algorithmen und Datenstrukturen SS August Arbeitszeit 90 min
TU Ilmenau, Fakultät für Informatik und Automatisierung FG Komplexitätstheorie und Effiziente Algorithmen Univ.-Prof. Dr. M. Dietzfelbinger, Dipl.-Ing. C. Mattern Klausur Algorithmen und Datenstrukturen
Algorithmen und Datenstrukturen 12
12. Juli 2012 1 Besprechung Blatt 11 Fragen 2 Binary Search Binäre Suche in Arrays Binäre Suchbäume (Binary Search Tree) 3 Sortierverfahren Allgemein Heapsort Bubblesort Insertionsort Mergesort Quicksort
Sortieralgorithmen. Jan Pöschko. 18. Januar Problemstellung Definition Warum Sortieren?... 2
Jan Pöschko 18. Januar 2007 Inhaltsverzeichnis 1 Problemstellung 2 1.1 Definition................................... 2 1.2 Warum Sortieren?.............................. 2 2 Einfache Sortieralgorithmen
Heapsort. Dr. Michael Brinkmeier (TU Ilmenau) Algorithmen und Datenstrukturen / 50
Heapsort Dr. Michael Brinkmeier (TU Ilmenau) Algorithmen und Datenstrukturen 27.6.2007 / 50 Heapsort - Wiederholung Definition Array A[..n] mit Einträgen aus (U,
1 Raumwechsel: Gr. 15 (Do 10-12, F-235) ab sofort in G Studie zum Arbeitsverhalten von Studierenden unter Leitung
Organisatorisches Algorithmen und Datenstrukturen Kapitel 3: Divide & Conquer Frank Heitmann heitmann@informatik.uni-hamburg.de 1 Raumwechsel: Gr. 15 (Do 10-12, F-235) ab sofort in G-021. 2 Studie zum
Datenstrukturen Kurzanleitung
Datenstrukturen Kurzanleitung Insertionsort p = (7, 5, 4, 83, 6, 6) n = 6 Start: K ist sortierte Folge. Für i =, 3, 4,..., n: Füge ki in eine sortierte Folge ( k, k, k 3,..., k n ) in der richtigen Position
Kapitel 2. Sortieren. Adressenverwaltung (lexikographisch) Treerlisten bei Suchanfragen (Relevanz) Verdeckung (z-koordinate) ...
Kapitel 2 Sortieren Das Sortieren ist eines der grundlegenden Probleme in der Informatik. Es wird geschätzt, dass mehr als ein Viertel aller kommerzieller Rechenzeit auf Sortiervorgänge entfällt. Einige
(Digital) Sorting. October 25, Algorithms & Datastructures 2 Exercises WS 2016
(Digital) Sorting October 2, 2016 Algorithms & Datastructures 2 Exercises WS 2016 Dipl.-Ing. University Linz, Institute for Pervasive Computing Altenberger Straße 69, A-4040 Linz kurz@pervasive.jku.at
14. Sortieren II Heapsort. Heapsort. [Max-]Heap 7. Heapsort, Quicksort, Mergesort. Binärer Baum mit folgenden Eigenschaften
![14. Sortieren II Heapsort. Heapsort. [Max-]Heap 7. Heapsort, Quicksort, Mergesort. Binärer Baum mit folgenden Eigenschaften](/thumbs/86/93979187.jpg "14. Sortieren II Heapsort. Heapsort. [Max-]Heap 7. Heapsort, Quicksort, Mergesort. Binärer Baum mit folgenden Eigenschaften")
Heapsort, Quicksort, Mergesort 14. Sortieren II 14.1 Heapsort [Ottman/Widmayer, Kap. 2.3, Cormen et al, Kap. 6] 397 398 Heapsort [Max-]Heap 7 Inspiration von Selectsort: Schnelles Einfügen Binärer Baum
Klausur Datenstrukturen und Algorithmen SoSe 2012
Prof. aa Dr. Ir. Joost-Pieter Katoen Christian Dehnert, Jonathan Heinen, Thomas Ströder, Sabrina von Styp Klausur Datenstrukturen und Algorithmen SoSe 2012 Vorname: Nachname: Studiengang (bitte genau einen
Algorithmen und Datenstrukturen
1 Algorithmen und Datenstrukturen Wintersemester 017/18 8. Vorlesung Sortieren mit dem Würfel! Prof. Dr. Alexander Wolff Lehrstuhl für Informatik I - 5 Guten Morgen! Tipps für unseren ersten Test am Do,
Übungsklausur Algorithmen I
Jun.-Prof. Hofheinz, Jun.-Prof. Meyerhenke (ITI, KIT) 08.06.2015 Übungsklausur Algorithmen I Aufgabe 1. (Algorithm Engineering) Nennen Sie zwei Konzepte, die Algorithm Engineering im Gegensatz zu theoretischer
Abgabe: (vor der Vorlesung) Aufgabe 3.1 (P) Master-Theorem
TECHNISCHE UNIVERSITÄT MÜNCHEN FAKULTÄT FÜR INFORMATIK Lehrstuhl für Sprachen und Beschreibungsstrukturen SS 2009 Grundlagen: Algorithmen und Datenstrukturen Übungsblatt 3 Prof. Dr. Helmut Seidl, S. Pott,
Übersicht Datenstrukturen und Algorithmen. Literatur. Algorithmus: Wikipedia Definition. Vorlesung 1: Einführung. Prof. Dr.
Übersicht Datenstrukturen und Vorlesung 1: Prof. Dr. Erika Ábrahám Theorie Hybrider Systeme Informatik 2 http://ths.rwth-aachen.de/teaching/ss-14/ datenstrukturen-und-algorithmen/ Diese Präsentation verwendet
Heapsort. Erstellung eines Heaps
Heapsort Beispiel für einen eleganten Algorithmus, der auf einer effizienten Datenstruktur (dem Heap) beruht [Williams, 1964] Daten liegen in einem Array der Länge n vor 1. Erstelle aus dem gegebenen Array
Heapsort. 1. Erstelle aus dem gegebenen Array einen Heap (DownHeap) 2. Tausche erstes und letztes Element des Arrays
Heapsort Beispiel für einen eleganten Algorithmus, der auf einer effizienten Datenstruktur (dem Heap) beruht [Williams, 1964] Daten liegen in einem Array der Länge n vor 1. Erstelle aus dem gegebenen Array
Kapitel 2. Weitere Beispiele Effizienter Algorithmen
Kapitel 2 Weitere Beispiele Effizienter Algorithmen Sequentielle Suche Gegeben: Array a[1..n] Suche in a nach Element x Ohne weitere Zusatzinformationen: Sequentielle Suche a[1] a[2] a[3] Laufzeit: n Schritte
Einführung in die Informatik Algorithmen und Datenstrukturen. Thema 17 Sortieren
Einführung in die Informatik Algorithmen und Datenstrukturen Thema 17 Sortieren Sortierproblem Es gibt eine Menge von Datensätzen, und jeder dieser Sätze besitzt einen (möglichst eindeutigen) Schlüssel.
Aufgabe (Schreibtischtest, lexikographische Ordnung)
Aufgabe (Schreibtischtest, lexikographische Ordnung) Führen Sie einen Schreibtischtest für den Algorithmus Bubblesort aus der VL für die folgenden Eingabe-Arrays durch. Geben Sie das Array S nach jedem
Übungsklausur Algorithmen I
Universität Karlsruhe, Institut für Theoretische Informatik Prof. Dr. P. Sanders 26.5.2010 svorschlag Übungsklausur Algorithmen I Hiermit bestätige ich, dass ich die Klausur selbständig bearbeitet habe:
Algorithmen und Programmieren II
Algorithmen und Programmieren II Sortieralgorithmen (Teil III) 2 46 69 4 5 6 4 4 0 8 9 0 6 4 2 Prof. Dr. Margarita Esponda Sortieralgorithmen Vergleichs- Algorithmen quadratisch Bubblesort O(n 2 ) Insertsort
Heapsort, Quicksort, Mergesort. 8. Sortieren II
209 Heapsort, Quicksort, Mergesort 8. Sortieren II 210 8.1 Heapsort [Ottman/Widmayer, Kap. 2.3, Cormen et al, Kap. 6] Heapsort 211 Inspiration von Selectsort: Schnelles Einfügen Inspiration von Insertionsort:
Pro Informatik 2009: Objektorientierte Programmierung Tag 18. Marco Block-Berlitz, Miao Wang Freie Universität Berlin, Institut für Informatik
Tag 18 Marco Block-Berlitz, Miao Wang Freie Universität Berlin, Institut für Informatik 09.09.2009 Agenda Tag 16 Datenstrukturen Abstrakte Datentypen, ADT Folge: Stack, Queue, Liste, ADT Menge: Bäume:
Algorithmen und Datenstrukturen
Algorithmen und Datenstrukturen Wintersemester 2013/14 1. Vorlesung Kapitel 1: Sortieren Prof. Dr. Alexander Wolff Lehrstuhl für Informatik I Das Problem Eingabe Gegeben: eine Folge A = a 1, a 2,..., a
Übung zu Algorithmen und Datenstrukturen (für ET/IT)
Übung zu Algorithmen und Datenstrukturen (für ET/IT) Sommersemester 2017 Rüdiger Göbl, Mai Bui Computer Aided Medical Procedures Technische Universität München Fibonacci Zahlen Fibonacci Folge Die Fibonacci
8. Sortieren II. 8.1 Heapsort. Heapsort. [Max-]Heap 6. Heapsort, Quicksort, Mergesort. Binärer Baum mit folgenden Eigenschaften
![8. Sortieren II. 8.1 Heapsort. Heapsort. [Max-]Heap 6. Heapsort, Quicksort, Mergesort. Binärer Baum mit folgenden Eigenschaften](/thumbs/72/66389118.jpg "8. Sortieren II. 8.1 Heapsort. Heapsort. [Max-]Heap 6. Heapsort, Quicksort, Mergesort. Binärer Baum mit folgenden Eigenschaften")
Heapsort, Quicksort, Mergesort 8. Sortieren II 8.1 Heapsort [Ottman/Widmayer, Kap. 2.3, Cormen et al, Kap. 6] 9 210 Heapsort [Max-]Heap 6 Inspiration von Selectsort: Schnelles Einfügen Binärer Baum mit
Heapsort, Quicksort, Mergesort. 8. Sortieren II
209 Heapsort, Quicksort, Mergesort 8. Sortieren II 210 8.1 Heapsort [Ottman/Widmayer, Kap. 2.3, Cormen et al, Kap. 6] 211 Heapsort Inspiration von Selectsort: Schnelles Einfügen Inspiration von Insertionsort:
Algorithmen und Datenstrukturen (für ET/IT)
Algorithmen und Datenstrukturen (für ET/IT) Sommersemester 2018 Dr. Stefanie Demirci Computer Aided Medical Procedures Technische Universität München Organisatorisches: Keine Vorlesung nächste Woche wegen
in eine Folge ai, so daß bezgl. einer Ordnung gilt: a a, j < n
6. Sortieren Umordnen von Objekten a in eine Folge ai,..., ai n, so daß bezgl. einer Ordnung gilt: a a, j < n Begriffe: ij i j + ) Stabilität : Ein Sortierverfahren heißt stabil, falls die relative Reihenfolge