Algorithmen und Datenstrukturen

Transkript

1 1 Algorithmen und Datenstrukturen Wintersemester 2015/16 2. Vorlesung Sortieren mit anderen Mitteln Prof. Dr. Alexander Wolff Lehrstuhl für Informatik I

2 2-11 Teile und herrsche Idee: teile den Kartenstapel in zwei ungefähr gleichgroße Teile, sortiere die Teile (z.b. durch verschiedene Personen) und füge die Teilstapel zu einem sortierten Stapel zusammen. Allgemein: Teile... Herrsche... Kombiniere... eine Instanz in kleinere Instanzen desselben Problems. durch rekursives Lösen von Teilinstanzen nur falls diese sehr klein sind, löse sie direkt. Aufruf einer Funktion durch sich selbst die Teillösungen zu einer Lösung der ursprünglichen Instanz.

3 2-14 Teile und herrsche MergeSort(array of int A, int l = 1, int r = A.length) if l < r then Allgemein: Teile... m = (l + r)/2 MergeSort(A, l, m) MergeSort(A, m + 1, r) Merge(A, l, m, r) Herrsche... Kombiniere... Defaultwerte Dadurch wird die Funktion MergeSort(A) MergeSort(A, 1, A.length) definiert. eine Instanz in kleinere Instanzen desselben Problems. durch rekursives Lösen von Teilinstanzen nur falls diese sehr klein sind, löse sie direkt. die Teillösungen zu einer Lösung der ursprünglichen Instanz.

4 2-24 Teile und herrsche MergeSort(array of int A, int l = 1, int r = A.length) if l < r then m = (l + r)/2 } teile MergeSort(A, l, m) } herrsche MergeSort(A, m + 1, r) Merge(A, l, m, r) } kombiniere Allgemein: Teile... Herrsche... Kombiniere... To do! eine Instanz in kleinere Instanzen desselben Problems. durch rekursives Lösen von Teilinstanzen nur falls diese sehr klein sind, löse sie direkt. die Teillösungen zu einer Lösung der ursprünglichen Instanz.

5 3-7 Kombiniere Merge(array of int A, int l, int m, int r) n 1 = m l + 1; n 2 = r m let L[1..n 1 + 1] and R[1..n 2 + 1] be new L[1..n 1 ] = A[l..m] arrays of int Aufgabe: R[1..n 2 ] = A[m + 1..r] L[n 1 + 1] = R[n 2 + 1] = i = j = 1 for k = l to r do ifsie L[i] haben R[j] 5 then Minuten. A[k] = L[i] i = i + 1 else A[k] = R[j] A j = j + 1 Schließen Sie Ihre Bücher und Ihren Browser! Schreiben Sie mit Ihrer NachbarIn den Rest der Routine! Benutzen Sie dazu die beiden neuen Felder L und R. n 1 n 2 {}}{ {}}{ l m r

6 3-11 Kombiniere Merge(array of int A, int l, int m, int r) n 1 = m l + 1; n 2 = r m let L[1..n 1 + 1] and R[1..n 2 + 1] be new L[1..n 1 ] = A[l..m] arrays of int R[1..n 2 ] = A[m + 1..r] L[n 1 + 1] = R[n 2 + 1] = i = j = 1 for k = l to r do if L[i] R[j] then L A[k] = L[i] i = i + 1 else A[k] = R[j] A j = j + 1 for i = 1 to n 1 do L[i] = A[(l 1) + i] n 1 n 2 {}}{ {}}{ l m r

7 3-17 Kombiniere Merge(array of int A, int l, int m, int r) n 1 = m l + 1; n 2 = r m let L[1..n 1 + 1] and R[1..n 2 + 1] be new L[1..n 1 ] = A[l..m] arrays of int R[1..n 2 ] = A[m + 1..r] L[n 1 + 1] = R[n 2 + 1] = i = j = 1 for k = l to r do if L[i] R[j] then L A[k] = L[i] i = i + 1 else A[k] = R[j] A j = j + 1 Stopper (engl. sentinel) R n 1 n 2 {}}{ {}}{ l m r

8 3-27 Kombiniere Merge(array of int A, int l, int m, int r) n 1 = m l + 1; n 2 = r m let L[1..n 1 + 1] and R[1..n 2 + 1] be new L[1..n 1 ] = A[l..m] arrays of int R[1..n 2 ] = A[m + 1..r] L[n 1 + 1] = R[n 2 + 1] = i = j = 1 i for k = l to r do if L[i] R[j] then L A[k] = L[i] i = i + 1 else A[k] = R[j] A j = j + 1 Aber... stimmt das denn alles??? R n 1 n 2 {}}{ {}}{ l k m r j

9 Korrektheit von Merge... nach Schema F! 0. Schleifeninvariante A[l..k 1] enthält die k l kleinsten Elemente von L R sortiert. L[i] und R[j] sind die kleinsten Elemente in L bzw. R, die noch nicht in A kopiert wurden. Merge(array of int A, int l, int m, int r) n 1 = m l + 1; n 2 = r m lege L[1..n 1 + 1] und R[1..n 2 + 1] an L[1..n 1 ] = A[l..m] R[1..n 2 ] = A[m + 1..r] L[n 1 + 1] = R[n 2 + 1] = i = j = 1 for k = l to r do if L[i] R[j] then A[k] = L[i] i = i + 1 else A[k] = R[j] j = j Initialisierung Da beim ersten Schleifendurchlauf k = l gilt, enthält A[l..k 1] = die 0 kleinsten Elem. von L R. Da i = j = 1, sind L[i] und R[j] die kleinsten noch nicht kopierten Elem.

10 Korrektheit von Merge... nach Schema F! 0. Schleifeninvariante A[l..k 1] enthält die k l kleinsten Elemente von L R sortiert. L[i] und R[j] sind die kleinsten Elemente in L bzw. R, die noch nicht in A kopiert wurden. Merge(array of int A, int l, int m, int r) n 1 = m l + 1; n 2 = r m lege L[1..n 1 + 1] und R[1..n 2 + 1] an L[1..n 1 ] = A[l..m] R[1..n 2 ] = A[m + 1..r] L[n 1 + 1] = R[n 2 + 1] = i = j = 1 for k = l to r do if L[i] R[j] then // Fall (a) A[k] = L[i] i = i + 1 else A[k] = R[j] j = j Initialisierung 2. Aufrechterhaltung Zwei Fälle: (a) L[i] R[j], (b) R[j] < L[i]. Betrachte Fall (a). Nun gilt: (dank INV) (Fall (b) symmetrisch.) A[l..k] enthält die kleinsten k l + 1 Elem. sortiert L[i + 1] ist kleinstes noch nicht kopiertes Elem. in L. erhöhe i L[i] ist kleinstes noch nicht kopiertes Elem. in L. erhöhe k A[l..k 1] enthält die kleinsten k l Elem. sortiert INV!

11 Korrektheit von Merge... nach Schema F! 0. Schleifeninvariante A[l..k 1] enthält die k l kleinsten Elemente von L R sortiert. L[i] und R[j] sind die kleinsten Elemente in L bzw. R, die noch nicht in A kopiert wurden. Merge(array of int A, int l, int m, int r) n 1 = m l + 1; n 2 = r m lege L[1..n 1 + 1] und R[1..n 2 + 1] an L[1..n 1 ] = A[l..m] R[1..n 2 ] = A[m + 1..r] L[n 1 + 1] = R[n 2 + 1] = i = j = 1 for k = l to r do if L[i] R[j] then A[k] = L[i] i = i + 1 else A[k] = R[j] j = j Initialisierung 2. Aufrechterhaltung 3. Terminierung Nach Abbruch der for-schleife gilt k = r + 1. A[l..k 1] = A[l..r] enthält die r l + 1 kleinsten Elem. von L R sortiert. +2 Stopper L R = n 1 + n = r l + 3, d.h. A[l..r] korrekt sort.

12 Korrektheit von Merge... nach Schema F! 0. Schleifeninvariante A[l..k 1] enthält die k l kleinsten Elemente von L R sortiert. L[i] und R[j] sind die kleinsten Elemente in L bzw. R, die noch nicht in A kopiert wurden. Merge(array of int A, int l, int m, int r) n 1 = m l + 1; n 2 = r m lege L[1..n 1 + 1] und R[1..n 2 + 1] an L[1..n 1 ] = A[l..m] R[1..n 2 ] = A[m + 1..r] L[n 1 + 1] = R[n 2 + 1] = i = j = 1 for k = l to r do if L[i] R[j] then A[k] = L[i] i = i + 1 else A[k] = R[j] j = j Initialisierung 2. Aufrechterhaltung 3. Terminierung Also ist Merge korrekt! q.e.d. Laufzeit? Merge macht genau r l + 1 Vergleiche. Und MergeSort? Korrekt? Effizient?

13 8-12 MergeSort ein Beispiel MergeSort(array of int A, int l = 1, int r = A.length) if l < r then m = (l + r)/2 } teile MergeSort(A, l, m) } herrsche MergeSort(A, m + 1, r) Merge(A, l, m, r) } kombiniere

14 8-72 MergeSort ein Beispiel MergeSort(array of int A, int l = 1, int r = A.length) if l < r then m = (l + r)/2 } teile MergeSort(A, l, m) } herrsche MergeSort(A, m + 1, r) Merge(A, l, m, r) } kombiniere

15 8-78 MergeSort ein Beispiel MergeSort(array of int A, int l = 1, int r = A.length) if l < r then m = (l + r)/2 } teile MergeSort(A, l, m) } herrsche MergeSort(A, m + 1, r) Merge(A, l, m, r) } kombiniere Wurzel: erster Aufruf Rekursionsbaum von MergeSort: Baum der rekursiven Aufrufe Blätter: einzelne Feldelemente

16 9-10 Korrektheit von Mergesort MergeSort(array of int A, int l = 1, int r = A.length) if l < r then m = (l + r)/2 } teile MergeSort(A, l, m) } herrsche MergeSort(A, m + 1, r) Merge(A, l, m, r) } kombiniere Korrekt? Welche Beweistechnik? Hm, MergeSort ist rekursiv... Vollständige Induktion über n = r l + 1 (= A[l..r].length): n = 1: Induktionsanfang Dann ist l = r. if-block wird nicht betreten. D.h. nichts passiert. OK, da A[l..l] schon sortiert.

17 9-23 Korrektheit von Mergesort MergeSort(array of int A, int l = 1, int r = A.length) if l < r then m = (l + r)/2 } teile MergeSort(A, l, m) } herrsche MergeSort(A, m + 1, r) Merge(A, l, m, r) n > 1: } kombiniere Induktionsannahme: MergeSort korrekt für Felder d. Länge < n. Dann ist l < r. if-block wird betreten. Nach Wahl von m gilt l m < r. A[l..m] und A[m + 1..r] sind kürzer als A[l..r]. MergeSort(A, l, m) ist korrekt und MergeSort(A, l, r) MergeSort(A, m + 1, r) ist korrekt. ist korrekt., d.h. MS Schon bewiesen: Merge ist korrekt. für Felder d. Länge n. I.A. Induktionsschritt

18 10 Übersicht Techniken für Korrektheitsbeweise iterative Algorithmen (à la InsertionSort) Schleifeninvariante (Schema F ) rekursive Algorithmen (à la MergeSort) Induktion