Praktische Informatik I - Algorithmen und Datenstrukturen Wintersemester 2006/07

Transkript

1 2 Sortieren Untersuchungen haben gezeigt, dass mehr als ein Viertel der kommerziell verbrauchten Rechenzeit auf Sortiervorgänge entfällt. Sortierproblem Gegeben ist eine Folge F von Datensätzen (engl.: items) s 1,..., s N. Jeder Satz s i hat den Schlüssel k i. Man finde eine Permutation π der Zahlen von 1 bis N derart, dass die Umordnung der Datensätze gemäß π die Schlüssel in aufsteigende Reihenfolge bringt: k π(1) k π(2)... k π(n). Prof. Dr. Dietmar Seipel 57

2 Die Ordnungsrelation auf den Schlüsseln kann sein: die natürliche Ordnung auf (reellen) Zahlen z.b. bei Artikelnummern, Personalnummern... die alphabetische und lexikographische Ordnung auf Buchstaben und Strings, z.b. bei Namen. Größen zur Messung der Laufzeit von Sortierverfahren: Anzahl der ausgeführten Schlüsselwertvergleiche (engl.: comparisons) C min (N), C max (N), C mit (N) Anzahl der ausgeführten Bewegungen von Datensätzen (engl.: movements) M min (N), M max (N), M mit (N) Prof. Dr. Dietmar Seipel 58

3 Für beide Parameter interessieren uns die im günstigsten Fall (engl.: best case, Index: min) schlechtesten Fall (engl.: worst case, Index: max) Mittel (engl.: average case, Index: mit) erforderlichen Anzahlen. Die Mittelwerte werden üblicherweise auf die Menge aller N! möglichen Ausgangsordnungen von N zu sortierenden Datensätzen bezogen. Interne Sortierverfahren zu sortierende Datensätze sind vollständig im Hauptspeicher Externe Sortierverfahren Datensätze sind auf einem externen Speichermedium (Diskette, Platte). Prof. Dr. Dietmar Seipel 59

4 2.1 Mergesort Mergesort ( Sortieren durch Mischen ) ist eines der ältesten und bestuntersuchtesten Verfahren zum Sortieren mit Hilfe von Computern. John von Neumann hat es bereits 1945 vorgeschlagen. Mergesort eignet sich auch besonders für das Sortieren von Daten auf Sekundärspeichern, das externe Sortieren. Prof. Dr. Dietmar Seipel 60

5 2.1.1 Der Mergesort Algorithmus Algorithmus Mergesort (F : Folge) { Sortiert die Folge F durch rekursives Teilen nach aufsteigenden Werten } Falls F die Länge N = 0 oder N = 1 hat, so ist F bereits sortiert und bleibt unverändert. Sonst: 1. Divide Teile F in zwei etwa gleich große Teilfolgen F 1 und F Conquer Sortiere F 1 und F 2 rekursiv mit Mergesort Mergesort(F 1 ) F 1 sortiert Mergesort(F 2 ) F 2 sortiert Prof. Dr. Dietmar Seipel 61

6 3. Merge Bilde die Resultatfolge durch Verschmelzen von F 1 und F 2. Lasse dazu je einen Positionszeiger (Index) durch die Teilfolgen F 1, F 2 so wandern: Bewege jeweils in einem Schritt denjenigen der beiden Zeiger um eine Position weiter, der auf den kleineren Schlüssel zeigt. Prof. Dr. Dietmar Seipel 62

7 Implementierung Mergesort public static void mergesort(int[] a, int l, int r) { int i, j, k, m; int[] b = new int[a.length]; if (r > l) { /* Divide */ m = (l + r) / 2; Prof. Dr. Dietmar Seipel 63

8 Mergesort /* Conquer */ mergesort(a, l, m); mergesort(a, m+1, r); /* Merge */ // zuerst alle Werte ins Feld b kopieren: // b = a[l],...,a[m],a[r],...a[m+1] for (i = m; i >= l; i--) b[i] = a[i]; for (j = m+1; j <= r; j++) b[r + m j] = a[j]; Prof. Dr. Dietmar Seipel 64

9 Mergesort } } // dann der Groesse nach die Werte // zurueckschreiben i = l; j = r; for (k = l; k <= r; k++) { if (b[i] < b[j]) { a[k] = b[i++]; } else { a[k] = b[j--]; } } Prof. Dr. Dietmar Seipel 65

10 Beispiel F = (2, 1, 3, 9, 5, 6, 7, 4, 8, 10) wird aufgespalten in F 1 = (2, 1, 3, 9, 5), F 2 = (6, 7, 4, 8, 10). Sortieren von F 1, F 2 ergibt Verschmelzen von F 1 und F 2: F 1 = (1, 2, 3, 5, 9), F 2 = (4, 6, 7, 8, 10) Prof. Dr. Dietmar Seipel 66

11 2.1.2 Aufwandsabschätzung Es gilt C min (N) = C max (N) = C mit (N) := C(N), denn die Komplexität ist in diesem Fall unabhängig von der Eingabe. Ebenso gilt M min (N) = M max (N) = M mit (N) := M(N). Rekursionsgleichung C(1) = 0, C(N) = 2 C ( N 2 ) + N Folglich gilt C min (N) = C max (N) = C mit (N) O(N log(n)). ( ) N M(1) = 0, M(N) = 2 C + 2 N 2 Folglich gilt M min (N) = M max (N) = M mit (N) O(N log(n)). Prof. Dr. Dietmar Seipel 67

12 2.2 Quicksort Quicksort wurde von C. A. R. Hoare (1962) entwickelt. Es ist erfahrungsgemäß (im Mittel) eines der schnellsten, wenn nicht das schnellste interne Sortierverfahren. In situ Sortierverfahren d.h. es wird zur (Zwischen-) Speicherung für die Datensätze kein zusätzlicher Speicher benötigt, außer einer konstanten Anzahl von Hilfsspeicherplätzen für Tauschoperationen. Prof. Dr. Dietmar Seipel 68

13 2.2.1 Der Quicksort Algorithmus Algorithmus Quicksort (F : Folge) { Sortiert die Folge F durch rekursives Teilen nach aufsteigenden Werten } Falls F die Länge N = 0 oder N = 1 hat, so ist F bereits sortiert und bleibt unverändert. Sonst: 1. Divide Wähle ein Pivotelement k von F (z.b. das letzte) und teile F ohne k in Teilfolgen F 1 und F 2 bezüglich k: F 1 enthält nur die Elemente von F ohne k, die k sind, F 2 enthält nur die Elemente von F ohne k, die k sind, Prof. Dr. Dietmar Seipel 69

14 2. Conquer Sortiere F 1 und F 2 rekursiv mit Quicksort Quicksort(F 1 ) F 1 sortiert Quicksort(F 2 ) F 2 sortiert 3. Merge Bilde die Ergebnisfolge F duch Hintereinanderhängen von F 1, k, F 2 in dieser Reihenfolge. Prof. Dr. Dietmar Seipel 70

15 Beispiel F = ( 2, 1, 3, 9, 5, 6, 7, 4, 8, 10 ) ( 2, 1, 3, 9, 5, 6, 7, 4, 8 ) 10 ( ) ( 2, 1, 3, 5, 6, 7, 4 ) 8 ( 9 ) ( 2, 1, 3 ) 4 ( 5, 6, 7 ) ( 2, 1 ) 3 ( ) ( 5, 6 ) 7 ( ) ( ) 1 ( 2 ) ( 5 ) 6 ( ) Tiefe des Aufraufbaumes : 5 Prof. Dr. Dietmar Seipel 71

16 Implementierung public static void quicksort Quicksort (int[] a, int links, int rechts) { int l, r, pivot; if (links < rechts) { /* Divide */ //Pivotelement v ist rechtestes Element pivot = a[rechts]; l = links; r = rechts-1; Prof. Dr. Dietmar Seipel 72

17 Quicksort do { while (a[l] < pivot && l < rechts) l++; while (a[r] > pivot && r > links) r--; if (l < r) vertausche(a, l, r); } while (l < r); //Pivotelement an die richtige Position vertausche(a, l, rechts); } } /* Conquer */ quicksort(a, links, l-1); quicksort(a, l+1, rechts); Prof. Dr. Dietmar Seipel 73

18 Quicksort /** Vertauschen von Feldelementen */ public static void vertausche (int[] a, int i, int j) { int v = a[i]; a[i] = a[j]; a[j] = v; } Prof. Dr. Dietmar Seipel 74

19 2.2.2 Analyse des Aufwande im besten bzw. schlechtesten Fall (i) Ist das Pivotelemet das Element mit kleinstem oder größten Schlüssel, so ist eine der beiden durch Aufteilung entstehenden Teilfolgen jeweils leer und die andere hat jeweils genau ein Element (nämlich das Pivotelement) weniger als die Ausgangsfolge. Damit ist klar, dass gilt C max (N) N 1 k=1 k, d.h. C max (N) Ω ( N 2). Ebenso kann man sich überlegen M max Ω ( N 2). Prof. Dr. Dietmar Seipel 75

20 Beispiel k 1 < k2<... < kn quicksort (a, 1, N) k 1 < k2<... < kn-1 quicksort (a, 1, N-1) k n ( ) k n-1 ( ) k < 1 k 2 quicksort (a, 1, 2) ( k 1 ) k 2 ( ) Tiefe des Aufraufbaumes : N 1 Prof. Dr. Dietmar Seipel 76

21 (ii) Im günstigsten Fall haben die durch Aufteilung entstehenden Teilfolgen stets etwa die gleiche Länge. Dann ist die Rekursionstiefe genau von der Größenordnung von log 2 (N). Da auf jeder Rekursionsstufe zur Aufteilung T(N) Schlüsselvergleiche durchgeführt werden, gilt: C min (N) Θ (n log(n)) Prof. Dr. Dietmar Seipel 77

22 Beispiel ( 7, 5, 1, 3, 2, 6, 4, 9, 13, 11, 15, 14, 10, 12, 8 ) quicksort( a, 1, 15) ( 7, 5, 1, 3, 2, 6, 4 ) quicksort( a, 1, 7) 8 ( 9, 13, 11, 15, 14, 10, 12 ) quicksort( a, 9, 15) ( 1, 3, 2 ) quicksort( a, 1, 3) 4 ( 7, 5, 6 ) ( 9, 11, 10 ) quicksort( a, 5, 7) quicksort( a, 9, 11) 12 ( 13, 15, 14 ) quicksort( a, 13, 15) ( 1 ) 2 ( 3 ) ( 5 ) 6 ( 7 ) ( 9 ) 10 ( 11 ) ( 13 ) 14 ( 15 ) Tiefe des Aufraufbaumes : 3 Prof. Dr. Dietmar Seipel 78

23 Beispiel nach Algorithmus ( 7, 6, 2, 3, 1, 5, 4, 12, 9, 15, 10, 14, 13, 11, 8 ) quicksort( a, 1, 15) ( 7, 6, 2, 3, 1, 5, 4 ) quicksort( a, 1, 7) 8 ( 9, 15, 10, 14, 13, 11, 12 ) quicksort( a, 9, 15) ( 1, 3, 2 ) quicksort( a, 1, 3) 4 ( 7, 5, 6 ) ( 9, 11, 10 ) quicksort( a, 5, 7) quicksort( a, 9, 11) 12 ( 13, 15, 14 ) quicksort( a, 13, 15) ( 1 ) 2 ( 3 ) ( 5 ) 6 ( 7 ) ( 9 ) 10 ( 11 ) ( 13 ) 14 ( 15 ) Tiefe des Aufraufbaumes : 3 Prof. Dr. Dietmar Seipel 79

24 2.2.3 Analyse der mittleren Laufzeit Annahmen 1. Alle N Schlüssel k 1,..., k N sind paarweise verschieden, o.b.d.a. seien die Schlüssel die Zahlen 1,..., N (in beliebiger Reihenfolge). 2. Wir betrachten alle N! möglichen Anordnungen der N Schlüssel als gleichwahrscheinlich. Folgerung Jede der Zahlen k 1, N tritt mit gleicher Wahrscheinlichkeit 1 N als Pivotelement an Position N auf. Es werden bei Pivotelement k durch Aufteilung zwei Folgen mit den Längen k 1 und N k erzeugt. Auch diese sind wieder zufällig. Prof. Dr. Dietmar Seipel 80

25 Rekursionsformel für den Erwartungswert T(1) = 0, T(N) 1 N N (T(k 1) + T(n k)) + k=1 b N }{{} Aufteilungsaufwand für eine geeignete Konstante b. Wir wollen nun zeigen, dass für c = 2 b gilt: T(N) c N log e (N), für alle N 1 Prof. Dr. Dietmar Seipel 81

26 Beweis T(N) 2 N = 2 N N 1 k=0 N 1 k=1 T(k) + b N T(k) + b N vollständige Induktion nach N : Induktionsanfang, N = 1: sei c = 2 b Induktionsschluss, N 1 N: T(1) = 0 = 2 b 1 log e (1) }{{} 0 T(N) 2 N N 1 k=1 T(k) +b N }{{} I.A. c k log e (k) Prof. Dr. Dietmar Seipel 82

27 Sei nun f(x) = x log e (x) f(x) N-1 N x Die Funktion f hat folgende Eigenschaften: a) f(x) ist monoton steigend in [1, ) b) f(x) 0, für x [1, ) Prof. Dr. Dietmar Seipel 83

28 Damit gilt N 1 k=1 k log e (k) part. Int. = N 2 [ x 2 }{{} x log e (x) }{{} u (x) 2 log e(x) v(x) ] N dx N x x 2 2 (partielle Integration: R b a u (x) v(x) dx=[u(x) v(x)] b a R b = N2 2 log e(n) 2 log e (2) }{{} 1,38 [ x 2 4 ] N = N2 2 log e(n) N2 4 + } 1 2 {{ log e(2) } 0 N2 2 log e(n) N2 4 2 a u(x) v (x) dx) Prof. Dr. Dietmar Seipel 84

29 Folglich gilt T(N) 2c ( ) N 2 N 2 log e(n) N2 + b N ( 4 = c N log e (N) + N b c ) 2 = c N log e (N) Analog gilt auch für die mittlere Laufzeit von Schlüsselvergleichen C mit O (N log(n)) Prof. Dr. Dietmar Seipel 85

30 2.3 Untere Schranken für das Sortierproblem Satz (worst case) Jedes Sortierverfahren, das ausschließlich die vollständige Ordnung auf dem Wertebereich W ausnutzt, benötigt im worst case größenordnungsmäßig mindestens N log 2 (N) Vergleiche ( d.h. C max (N) Ω(N log 2 (N))) zum Sortieren von N Werten k 1,..., k N W. Zum Beweis beschränken wir uns auf die Folgen F = (k 1,..., k N ) W N mit k i k j für alle i j, d.h. paarweise verschiedenen Werten k i. D.h. wir zeigen obige Behauptung bereits für diese Teilmenge aller möglichen Eingabefolgen. Prof. Dr. Dietmar Seipel 86

31 Definition (Entscheidungsbaum) Ein Entscheidungsbaum (engl.: decision tree) ist ein bewerteter binärer Wurzelbaum B = (T, b) mit T = (V, E): V : Knotenmenge von T, E V V : Kantenmenge von T, b : E {ja, nein}: Kantenbewertung. Jeder Knoten v V, der nicht Blatt ist, repräsentiert eine Entscheidung (hier einen Vergleich w < w? zweier Werte w, w W ). Jeder Pfeil e = (v, v ) E repräsentiert das Ergebnis der Entscheidung (ja,nein) an seiner Anfangsecke v. Jedes Blatt ṽ repräsentiert das Ergebnis des Entscheidungsprozesses längs des Weges von der Wurzel v 0 bis zu ṽ, d.h. eine Partialordnung. Prof. Dr. Dietmar Seipel 87

32 Beispiel a, b, c W paarweise verschieden v 0 ja a < b nein v 1 ja b < c nein ja a < c nein a < b < c a < c v 2 b < a < c b < c ja nein ja nein a < c < b c < a < b b < c < a c < b < a ~ v v 0 : Koten, Wurzel des Baumes (v 0, v 1 ) : Kante / Pfeil, b((v 0, v 1 )) = ja v 0, v 1, v 2, ṽ): Pfrad von der Wuzel v 0 zu ṽ ṽ: Knoten, Blatt des Baumes Prof. Dr. Dietmar Seipel 88

33 In einem binären Wurzelbaum hat jeder Knoten, der nicht Blatt ist, einen oder zwei Nachfolger; jedes Blatt hat keinen Nachfolger. Jeder Sortieralgorithmus, der ausschließlich die vollständige Ordnung auf der Wertemenge W ausnutzt und sequentiell Wertepaare vergleicht, induziert einen solchen Entscheidungsbaum. Die maximale Anzahl der Vergleiche C max (N) entspricht dann der Höhe h T des induzierten Entscheidungsbaumes. Für eine Eingabefolge F = (k 1,..., k N ) aus paarweise verschiedenen Werten sind N! Permutationen (k i1,..., k in ) als Ergebnisse möglich, d.h. der induzierte Entscheidungsbaum muss mindestens N! Blätter haben. Prof. Dr. Dietmar Seipel 89

34 h t = 2, 4 Blätter Deshalb muss gelten: 2 ht N!, d.h. h T log 2 (N!) Da N N! N (N 1)... 2 }{{} N 2 +1 Faktoren, N 2 +1 N 2 ( N 2 ) N 2 Prof. Dr. Dietmar Seipel 90

35 gilt weiter ( N h t log 2 (N!) log 2 2 = N ( ) N 2 log 2 2 = N 2 (log 2(N) 1). ) N 2 Also gilt C max (N) Ω(N log 2 (N)). Prof. Dr. Dietmar Seipel 91

36 Satz (average case) Jedes Sortierverfahren, das ausschließlich die vollständige Ordnung auf dem Wertebereich W ausnutzt, benötigt im Mittel bei Gleichverteilungsannahme größenordnungsmäßig mindestens N log 2 (N) Vergleiche (d.h. C mit (N) Ω(N log 2 (N))) zum Sortieren von N paarweise verschiedenen Werten k 1,..., k N W. Zum Beweis benutzen wir wieder den induzierten Entscheidungsbaum T, welcher bekanntlich mindestens N! Blätter haben muss. Der Erwartungswert C mit (N) für die Anzahl der Vergleiche lässt sich nun wie folgt ausdrücken: C mit (N) = 1 N! h(v) v Blatt von T Prof. Dr. Dietmar Seipel 92

37 Für einen binären Wurzelbaum T heißt H(T) = v Blatt von T h(v) die Blätterhöhensumme von T. (Im Beispiel oben war H(T) = 16.) Sei nun H(n) = min{h(t) T ist binärer Wurzelbaum mit n Blättern}. Dann wollen wir H(n) nach unten abschätzen und zeigen H(n) n log 2 (n), für alle n N +. Prof. Dr. Dietmar Seipel 93

38 Induktion nach n: n = 1 : H(1) = 0 1 log 2 (1) n = 2 : H(2) = 2 2 log 2 (2) Sei nun n > 2 und die Behauptung bereits bewiesen für alle i n 1. Wir betrachten einen binären Wurzelbaum T 0 mit n Blättern und mit minimaler Blätterhöhensumme H(T 0 ) = H(n). Prof. Dr. Dietmar Seipel 94

39 Sei v 0 die Wurzel von T 0, T l (v 0 ) der linke Teilbaum und T r (v 0 ) der rechte Teilbaum von v 0 : v 0 T l(v 0) T r (v 0) i Blätter n-i Blätter Wegen der Minimalität von T 0 sind auch T l (v 0 ) und T r (v 0 ) minimal zur Blätterzahl i bzw. n i. Prof. Dr. Dietmar Seipel 95

40 Folglich haben wir H(n) = min (n + H(i) + H(n i)) i 1,n 1 I.A. n + min (i log 2(i) + (n i) log 2 (n i)) i 1,n 1 Wir betrachten nun die Funktion f(x) =x log 2 (x) + (n x) log 2 (n x), für x [1, n). f 1 (x) =1 log 2 (x) + x x log e (2) 1 + ( 1) log 2 (n x) + (n x) (n x) log e (2) =log 2 (x) log 2 (n x) Prof. Dr. Dietmar Seipel 96

41 f (x) = 0 log 2 (x) = log 2 (n x) x = n x x = n 2 Für x < n 2 gilt f (x) < 0, Für x > n 2 gilt f (x) > 0. Folglich hat f(x) ein globales Minimum bei x = n 2. Prof. Dr. Dietmar Seipel 97

42 n/2 n f(1) = (n 1) log 2 (n 1) ( n ) ( n ) f = n log 2 2 = n log 2 2 (n) n lim f(x) = n log 2(n) x n Prof. Dr. Dietmar Seipel 98

43 Daraus ergibt sich für den Erwartungswert C mit (N) folgendes: C mit (N) = 1 N! h(v) v Blatt von T = 1 N! H(T) 1 N! H(N!) 1 N! N! log 2(N!) N 2 (log 2(N) 1) Also gilt C mit (N) Ω(N log 2 (N)). Prof. Dr. Dietmar Seipel 99

44 2.4 Heaps und Heapsort Benötigt man aus einer vorgegebenen Menge wiederholt das minimale Element z.b. bei einer Prioritätswartschlange so bietet sich folgende Datenstruktur zur Speicherung der dynamisch veränderlichen Menge an: Der Heap Definition (Heap, Haufen, Halde) Ein Feld a[1...n] mit Komponentenwerten a[i], 1 i N, aus einem vollständig geordneten Wertebereich W heißt Heap, falls gilt: (1) a[i] = a[2i], für 1 i N 2 (2) a[i] = a[2i + 1], fr1 i N 2 1. Prof. Dr. Dietmar Seipel 100

45 Beispiel N = 10: a: i 2i 2i+1 Prof. Dr. Dietmar Seipel 101

46 Ein Heap realisiert implizit eine partielle Ordnung, nämlich einen vollständigen binären Wurzelbaum: a i = a[i], ein Pfeil von a i nach a j bedeutet a i a j. a 1 N = 10 a 2 a 3 a 4 a 5 a 6 a 7 a 8 a 9 a 10 Prof. Dr. Dietmar Seipel 102

47 Man erkennt, dass a 1 das minimale Element des Heap ist: a[1] a[i], für 1 i N Der Heapsort Algorithmus Im folgenden werden Java Programme angegeben für das Einfügen eines Elementes in einen Heap, das Löschen eines Elementes in einem Heap, den Aufbau eines Heaps, das Sortieren mit Hilfe von Heaps. Prof. Dr. Dietmar Seipel 103

48 Implementierung public class Heapsort { /** Array mit Heap */ int[] a; /** Groesse des Heaps */ int N; Heapsort /** * Tauscht die Elemente a[i] und a[j]. */ void exchange (int i, int j) { } int temp = a[i]; a[i] = a[j]; a[j] = temp; Prof. Dr. Dietmar Seipel 104

49 /** Heapsort * Laesst a[k] im Feld aufsteigen. */ void upheap (int k) { } while ( (k > 1) && (a[k] < a[k/2]) ) { } exchange(k, k/2); k = k / 2; Prof. Dr. Dietmar Seipel 105

50 /** Heapsort * Fuegt das neue Element v in den Heap der * Groesse N ein und erhoeht N um 1 */ void insert (int v) { } N++; a[n] = v; upheap(v); Prof. Dr. Dietmar Seipel 106

51 /** Heapsort * Laesst a[k] im Feld versickern */ void downheap(int k) { int j = 2 * k; // a[k] hat linken Sohn a[j] if (j <= N) { // a[k] hat auch rechten Sohn a[j + 1] if (j + 1 <= N) if (a[j] > a[j + 1]) j++; // jetzt ist a[j] der kleinere Sohn von a[k] Prof. Dr. Dietmar Seipel 107

52 Heapsort } } if (a[k] > a[j]) { exchange(k, j); downheap(j); } Prof. Dr. Dietmar Seipel 108

53 /** Heapsort * Liefert als Resultat das Heapelement a[k], * entfernt a[k] aus dem Heap und stellt die * Heap-Eigenschaft wieder her. */ int remove(int k) { } int v = a[k]; a[k] = a[n]; N--; if ( (k > 1) && a[k] < a[k / 2] ) else upheap(k); downheap(k); return v; Prof. Dr. Dietmar Seipel 109

54 Heapsort /** * Aufbau des Heaps durch downheap */ void heapaufbau() { } for (int k = N/2; k >= 1; k--) downheap(k); Prof. Dr. Dietmar Seipel 110

55 Heapsort /** * Aufbau des Heaps durch insert */ void heapaufbau2() { } int m = N; N = 0; for (int k = 1; k <= m; k++) insert(a[k]); Prof. Dr. Dietmar Seipel 111

56 Heapsort } /** * Sortiert das gegebene Feld b mit den angegebenen * Methoden und gibt das sortierte Feld zurueck. */ int[] heapsort(int[] b) { } //Globale Variablen fuer die Heap-Methoden setzen a = b; N = b.length; int m = N; heapaufbau(); int[] c = new int[m]; for (int k = 1; k <= m; k++) c[k] = remove(1); return c; Prof. Dr. Dietmar Seipel 112

57 Beispiel 4 N = Prof. Dr. Dietmar Seipel 113

58 Einfügen von v = 5 liefert Prof. Dr. Dietmar Seipel 114

59 Löschen an der Stelle k = 3, d.h. a[k] = 6, liefert Prof. Dr. Dietmar Seipel 115

60 Aus einem Heap erhält man eine Sortierung : Löschen von 4 Löschen von Löschen von Löschen von Löschen von 20 leerer Heap Prof. Dr. Dietmar Seipel 116

61 2.4.3 Komplexität des Heapaufbaus nach der Methode heapaufbau1 mit downheap: Stufe 1 2 Stufe 3: 2 = 4 Knoten Ein Heap mit j Stufen speichert zwischen 2 j 1 und 2 j 1 Schlüssel: Deshalb gilt j = log 2 (N + 1). 2 j 1 N 2 j 1 Prof. Dr. Dietmar Seipel 117

62 Auf Stufe k gibt es höchstens 2k 1 Schlüssel. Die Anzahl der Bewege- und Vergleichsoperationen zum Versickern (downheap) eines Elements der Stufe k ist proportional zu j k. j 1 k=1 2 k 1 (j k) = 2 j 1 = 2 j 1 j 1 k=1 j 1 k=1 2 k j (j k) k 2 k }{{} 2 N 2 O(N) Der Aufbau eines Heaps aus einer unsortierten Folge ist also in linearer Zeit möglich. (mittels der Routine heapaufbau ). (Die Routine heapaufbau2 benötigt dagegen im schlechtsten Fall größenordnungsmäßig mindestens N log 2 (N) Operationen.) Prof. Dr. Dietmar Seipel 118

63 2.4.4 Komplexität von Heapsort Die Anzahl der Bewege- und Vergleichsoperationen zum Löschen ( remove ) der Wurzel in einem Heap der Größe N ist proportional zu log 2 (N). Daraus ergibt sich für das N malige Löschen bei Heapsort ein Aufwand der proportional ist zu N log 2 (k) = log 2 (N!) Θ(N log 2 (N)). k=1 Dies dominiert den Aufwand zum Aufbau des Heaps. Die Komplexitäten von Heapsort sind also im worst case : C max (N) O(N log 2 (N)), M max (N) O(N log 2 (N)). Prof. Dr. Dietmar Seipel 119

64 2.5 Elementare Sortierverfahren Sortieren durch Auswahl (Selection Sort) Man bestimme sukzessive für alle i 1, N diejenige Position j i, N, an der das Element mit minimalem Schlüssel unter den Elementen a[i],..., a[n] auftritt und vertausche a[i] mit a[j]. Komplexitäten C min (N), C max (N), C mit (N) Θ ( N 2), M min (N) = M max (N) = M mit (N) = 3 (N 1). Prof. Dr. Dietmar Seipel 120

65 Implementierung Selection Sort void selectionsort(int[] a) { int i, j, min; for (i = 0; i < a.length - 1; i++) { min = i; for (j = i + 1; j < a.length; j++) if (a[j] < a[min]) min = j; exchange(a, i, min); } } Prof. Dr. Dietmar Seipel 121

66 2.5.2 Sortieren durch Einfügen (Insertion Sort) Man füge sukzessive für alle i 1, N das i-te Feldelement a[i] an der richtigen Stelle in die bereits sortierte Folge der Elemente a[1],..., a[i 1] ein. Das verlangt das verschieben von j 0, i 1 größeren Elementen um jeweils eine Position nach rechts. Komplexitäten C min (N) = N 1, C max (N) Θ ( N 2), M min (N) = 2 (N 1), M max (N) Θ ( N 2). Prof. Dr. Dietmar Seipel 122

67 Implementierung Insertion Sort void insertionsort(int[] a) { int i, j, v; for (i = 1; i < a.length; i++) { v = a[i]; j = i; while ( (j > 0) && (a[j-1] > v) ) { a[j] = a[j-1]; j--; } a[j] = v; } } Prof. Dr. Dietmar Seipel 123

68 2.5.3 Sortieren durch (direktes) Austauschen (Bubble Sort) Man durchläuft wiederholt die Liste der Datensätze a[1],..., a[i] und betrachtet dabei je zwei benachbarte Elemente a[j 1] und a[j], mit 2 j i. Ist a[j 1] > a[j], so vertauscht man a[j 1] und a[j]. Komplexitäten C min (N), C max (N), C mit (N) Θ ( N 2), M min (N) = 0, M max (N), M mit (N) Θ ( N 2). Prof. Dr. Dietmar Seipel 124

69 Implementierung Bubble Sort void bubblesort(int[] a) { for (int i = a.length-1; i >= 0; i--) for (int j = 1; j <= i; j++) if (a[j-1] > a[j]) exchange(a, j-1, j); } Größere Elemente haben also die Tendenz, wie Luftblasen im Wasser langsam nach oben aufzusteigen. Prof. Dr. Dietmar Seipel 125

70 Beispiel (Bubble Sort) F = (15, 2, 43, 17, 4, 8, 47) (2, 15, 17, 4, 8, 43, 47) (2, 15, 4, 8, 17, 43, 47) (2, 4, 8, 15, 17, 43, 47) (2, 4, 8, 15, 17, 43, 47) hier könnte man schon stoppen!!. (2, 4, 8, 15, 17, 43, 47) Prof. Dr. Dietmar Seipel 126

71 Testet man nach jedem Durchlauf der äußeren for-schleife, ob sich noch eine Veränderung ergeben hat, so kann man, falls dies nicht der Fall ist, schon früher stoppen. Dann erhält man C min (N) = N 1. die restlichen Komplexitäten ändern sich nicht. Prof. Dr. Dietmar Seipel 127