Die Präsentation wird geladen. Bitte warten

Die Präsentation wird geladen. Bitte warten

LS 2 / Informatik Datenstrukturen, Algorithmen und Programmierung 2 (DAP2)

Ähnliche Präsentationen


Präsentation zum Thema: "LS 2 / Informatik Datenstrukturen, Algorithmen und Programmierung 2 (DAP2)"—  Präsentation transkript:

1 LS 2 / Informatik Datenstrukturen, Algorithmen und Programmierung 2 (DAP2)

2 LS 2 / Informatik 2 1. Teil der Vorlesung – Grundlagen der Algorithmenanalyse Inhalt Wie beschreibt man einen Algorithmus? Wie beweist man die Korrektheit eines Algorithmus? Rechenmodell Laufzeitanalyse

3 LS 2 / Informatik 3 Organisatorisches Anmeldung Praktikum Die Anmeldung zum Praktikum wird bis Montag 10 Uhr verlängert Bitte achten Sie nach Festlegung der (normalen) Übungen auf Überschneidungen mit angegebenen Terminen im Praktikum (Dies macht AsSESS nicht automatisch!)

4 LS 2 / Informatik 4 Was ist ein mathematischer Beweis? Informale Definition Ein Beweis ist eine Herleitung einer Aussage aus bereits bewiesenen Aussagen und/oder Grundannahmen (Axiomen).

5 LS 2 / Informatik 5 Korrektheitsbeweise Was muss ich eigentlich zeigen? Häufiges Problem: Was muss man in einem Korrektheitsbeweis beweisen? Was wissen wir? Problembeschreibung definiert zulässige Eingaben und zugehörige (gewünschte) Ausgaben

6 LS 2 / Informatik 6 Beispiel: Sortieren Problem: Sortieren Eingabe: Folge von n Zahlen (a,…,a ) Ausgabe: Permutation (a,…,a ) von (a,…, a ), so dass a a … a 1 1 n n 1n 1 n 2

7 LS 2 / Informatik 7 Korrektheitsbeweise Was müssen wir zeigen? Für jede gültige Eingabe sortiert unser Algorithmus korrekt Aber wie? (auf welchen Annahmen können wir aufbauen?) Die Grundannahme in der Algorithmik ist, dass ein Pseudocodebefehl gemäß seiner Spezifikation ausgeführt wird Z.B.: Die Anweisung x x + 1 bewirkt, dass die Variable x um eins erhöht wird

8 LS 2 / Informatik 8 Korrektheitsbeweise Ein triviales Beispiel EinfacherAlgorithmus(n) 1.X 10 2.Y n 3.X X +Y 4.return X Behauptung Der Algorithmus gibt der Wert 10+n zurück. Beweis:

9 LS 2 / Informatik 9 Korrektheitsbeweise Ein triviales Beispiel EinfacherAlgorithmus(n) 1.X 10 2.Y n 3.X X +Y 4.return X Behauptung Der Algorithmus gibt der Wert 10+n zurück. Beweis: Zu Beginn des Algorithmus sind alle Variablen bis auf den Parameter n undefiniert.

10 LS 2 / Informatik 10 Korrektheitsbeweise Ein triviales Beispiel EinfacherAlgorithmus(n) 1.X 10 2.Y n 3.X X +Y 4.return X Behauptung Der Algorithmus gibt der Wert 10+n zurück. Beweis: Zu Beginn des Algorithmus sind alle Variablen bis auf den Parameter n undefiniert. Der Befehl in Zeile 1 weist X den Wert 10 zu.

11 LS 2 / Informatik 11 Korrektheitsbeweise Ein triviales Beispiel EinfacherAlgorithmus(n) 1.X 10 2.Y n 3.X X +Y 4.return X Behauptung Der Algorithmus gibt der Wert 10+n zurück. Beweis: Zu Beginn des Algorithmus sind alle Variablen bis auf den Parameter n undefiniert. Der Befehl in Zeile 1 weist X den Wert 10 zu. Der Befehl in Zeile 2 weist Y den Wert n zu.

12 LS 2 / Informatik 12 Korrektheitsbeweise Ein triviales Beispiel EinfacherAlgorithmus(n) 1.X 10 2.Y n 3.X X +Y 4.return X Behauptung Der Algorithmus gibt der Wert 10+n zurück. Beweis: Zu Beginn des Algorithmus sind alle Variablen bis auf den Parameter n undefiniert. Der Befehl in Zeile 1 weist X den Wert 10 zu. Der Befehl in Zeile 2 weist Y den Wert n zu. Der Befehl in Zeile 3 weist X den Wert X + Y zu. Da X vor der Zuweisung den Wert 10 enthielt und Y den Wert n, wird X auf 10+n gesetzt.

13 LS 2 / Informatik 13 Korrektheitsbeweise Ein triviales Beispiel EinfacherAlgorithmus(n) 1.X 10 2.Y n 3.X X +Y 4.return X Behauptung Der Algorithmus gibt der Wert 10+n zurück. Beweis: Zu Beginn des Algorithmus sind alle Variablen bis auf den Parameter n undefiniert. Der Befehl in Zeile 1 weist X den Wert 10 zu. Der Befehl in Zeile 2 weist Y den Wert n zu. Der Befehl in Zeile 3 weist X den Wert X + Y zu. Da X vor der Zuweisung den Wert 10 enthielt und Y den Wert n, wird X auf 10+n gesetzt. Der Befehl in Zeile 4 gibt X zurück. Da X zu diesem Zeitpunkt den Wert 10+n hat, folgt die Behauptung.

14 LS 2 / Informatik 14 Korrektheitsbeweise Ein triviales Beispiel EinfacherAlgorithmus(n) 1.X 10 2.Y n 3.X X +Y 4.return X Behauptung Der Algorithmus gibt der Wert 10+n zurück. Beweis: Zu Beginn des Algorithmus sind alle Variablen bis auf den Parameter n undefiniert. Der Befehl in Zeile 1 weist X den Wert 10 zu. Der Befehl in Zeile 2 weist Y den Wert n zu. Der Befehl in Zeile 3 weist X den Wert X + Y zu. Da X vor der Zuweisung den Wert 10 enthielt und Y den Wert n, wird X auf 10+n gesetzt. Der Befehl in Zeile 4 gibt X zurück. Da X zu diesem Zeitpunkt den Wert 10+n hat, folgt die Behauptung. Ein Korrektheitsbeweis vollzieht also das Programm Schritt für Schritt nach.

15 LS 2 / Informatik 15 Korrektheitsbeweise Ein erstes nichttriviales Beispiel Algorithmus Max-Search(Array A) 1.max 1 2.for j 2 to length[A] do 3. if A[j] > A[max] then max j 4.return max Problem Wir wissen nicht, wieviele Durchläufe die for-Schleife benötigt. Dies hängt sogar von der Eingabelänge ab.

16 LS 2 / Informatik 16 Korrektheitsbeweise Ein erstes nichttriviales Beispiel Algorithmus Max-Search(Array A) 1.max 1 2.for j 2 to length[A] do 3. if A[j] > A[max] then max j 4.return max Abhilfe Wir benötigen eine Aussage, die den Zustand am Ende der Schleife nach einer beliebigen Anzahl Schleifendurchläufe angibt.

17 LS 2 / Informatik 17 Korrektheitsbeweise Ein erstes nichttriviales Beispiel Algorithmus Max-Search(Array A) 1.max 1 2.for j 2 to length[A] do 3. if A[j] > A[max] then max j 4.return max Definition (Schleifeninvariante) Eine Schleifeninvariante ist eine i.a. von der Anzahl i der Schleifendurchläufe abhängige Aussage A(i), die am Ende jedes Schleifendurchlaufs gilt. Mit A(0) beziehen wir uns auf den Zustand vor dem ersten Durchlauf.

18 LS 2 / Informatik 18 Korrektheitsbeweise Ein erstes nichttriviales Beispiel Algorithmus Max-Search(Array A) 1.max 1 2.for j 2 to length[A] do 3. if A[j] > A[max] then max j 4.return max Schleifeninvariante (Konventionen für for-Schleifen) Bei einer for-Schleife nehmen wir dabei an, dass bereits am Ende eines Schleifendurchlaufs die Laufvariable erhöht wird. Außerdem nehmen wir an, dass nach dem 0-ten Durchlauf die Laufvariable bereits auf ihren Startwert initialisiert wurde.

19 LS 2 / Informatik 19 Ein erstes nichttriviales Beispiel Algorithmus Max-Search(Array A) 1.max 1 2.for j 2 to length[A] do 3. if A[j] > A[max] then max j 4.return max Lemma 1 Sei 0 i length[A]-1 die Anzahl Schleifendurchläufe der for-Schleife in Algorithmus Max-Search. Dann gilt folgende Schleifeninvariante (Inv.) A[max] ist ein größtes Element aus A[1..i+1] und j = i+2. Korrektheitsbeweise

20 LS 2 / Informatik 20 Korrektheitsbeweise Lemma 1 Sei 0 i length[A]-1 die Anzahl Schleifendurchläufe der for-Schleife in Algorithmus Max-Search. Dann gilt folgende Schleifeninvariante Beweis: Der Befehl in Zeile 1 des Algorithmus setzt max auf 1. Wir zeigen per Induktion über die Anzahl der Schleifendurchläufe, dass (Inv.) erfüllt ist. (Inv.) A[max] ist ein größtes Element aus A[1..i+1] und j = i+2.

21 LS 2 / Informatik 21 Korrektheitsbeweise Lemma 1 Sei 0 i length[A]-1 die Anzahl Schleifendurchläufe der for-Schleife in Algorithmus Max-Search. Dann gilt folgende Schleifeninvariante Beweis: Der Befehl in Zeile 1 des Algorithmus setzt max auf 1. Wir zeigen per Induktion über die Anzahl der Schleifendurchläufe, dass (Inv.) erfüllt ist. (I.A.) Nach i=0 Schleifendurchläufen (also zu Beginn der Schleife) ist max=1. Außerdem enthält A[1..1] nur ein Element, nämlich A[1]. Da A[max] = A[1] ist, ist A[max] ein größtes Element aus A[1..1]. Außerdem ist j=2. (Inv.) A[max] ist ein größtes Element aus A[1..i+1] und j = i+2.

22 LS 2 / Informatik 22 Korrektheitsbeweise Lemma 1 Sei 0 i length[A]-1 die Anzahl Schleifendurchläufe der for-Schleife in Algorithmus Max-Search. Dann gilt folgende Schleifeninvariante Beweis: Der Befehl in Zeile 1 des Algorithmus setzt max auf 1. Wir zeigen per Induktion über die Anzahl der Schleifendurchläufe, dass (Inv.) erfüllt ist. (I.A.) Nach i=0 Schleifendurchläufen (also zu Beginn der Schleife) ist max=1. Außerdem enthält A[1..1] nur ein Element, nämlich A[1]. Da A[max] = A[1] ist, ist A[max] ein größtes Element aus A[1..1]. Außerdem ist j=2. (Inv.) A[max] ist ein größtes Element aus A[1..i+1] und j = i+2.

23 LS 2 / Informatik 23 Korrektheitsbeweise Lemma 1 Sei 0 i length[A]-1 die Anzahl Schleifendurchläufe der for-Schleife in Algorithmus Max-Search. Dann gilt folgende Schleifeninvariante Beweis(fortgesetzt): (I.V.) Sei nach i length[A]-1 Schleifendurchläufen A[max] ein größtes Element aus A[1..i+1] und j = i+2. (Inv.) A[max] ist ein größtes Element aus A[1..i+1] und j = i+2.

24 LS 2 / Informatik 24 Korrektheitsbeweise Lemma 1 Sei 0 i length[A]-1 die Anzahl Schleifendurchläufe der for-Schleife in Algorithmus Max-Search. Dann gilt folgende Schleifeninvariante Beweis(fortgesetzt): (I.V.) Sei nach i length[A]-1 Schleifendurchläufen A[max] ein größtes Element aus A[1..i+1] und j = i+2. (I.S.) Sei i+1 length[A]-1; ansonsten ist nichts zu zeigen. Nach I.V. gilt nach i Durchläufen zu Beginn der Schleife j= i+2. Wir betrachten den (i+1)-sten Durchlauf. (Inv.) A[max] ist ein größtes Element aus A[1..i+1] und j = i+2.

25 LS 2 / Informatik 25 Korrektheitsbeweise Lemma 1 Sei 0 i length[A]-1 die Anzahl Schleifendurchläufe der for-Schleife in Algorithmus Max-Search. Dann gilt folgende Schleifeninvariante Beweis(fortgesetzt): (I.V.) Sei nach i length[A]-1 Schleifendurchläufen A[max] ein größtes Element aus A[1..i+1] und j = i+2. (I.S.) Sei i+1 length[A]-1; ansonsten ist nichts zu zeigen. Nach I.V. gilt nach i Durchläufen zu Beginn der Schleife j= i+2. Wir betrachten den (i+1)-sten Durchlauf. Falls A[j] A[max] ist, so wird die then-Anweisung nicht ausgeführt. Dann ist A[max] größtes Element aus A[1..i+2]. (Inv.) A[max] ist ein größtes Element aus A[1..i+1] und j = i+2.

26 LS 2 / Informatik 26 Korrektheitsbeweise Lemma 1 Sei 0 i length[A]-1 die Anzahl Schleifendurchläufe der for-Schleife in Algorithmus Max-Search. Dann gilt folgende Schleifeninvariante Beweis(fortgesetzt): (I.V.) Sei nach i length[A]-1 Schleifendurchläufen A[max] ein größtes Element aus A[1..i+1] und j = i+2. (I.S.) Sei i+1 length[A]-1; ansonsten ist nichts zu zeigen. Nach I.V. gilt nach i Durchläufen zu Beginn der Schleife j= i+2. Wir betrachten den (i+1)-sten Durchlauf. Falls A[j] A[max] ist, so wird die then-Anweisung nicht ausgeführt. Dann ist A[max] größtes Element aus A[1..i+2]. Am Ende der Schleife wird j um eins erhöht und es gilt j = i+3. (Inv.) A[max] ist ein größtes Element aus A[1..i+1] und j = i+2.

27 LS 2 / Informatik 27 Korrektheitsbeweise Lemma 1 Sei 0 i length[A]-1 die Anzahl Schleifendurchläufe der for-Schleife in Algorithmus Max-Search. Dann gilt folgende Schleifeninvariante Beweis(fortgesetzt): (I.V.) Sei nach i length[A]-1 Schleifendurchläufen A[max] ein größtes Element aus A[1..i+1] und j = i+2. (I.S.) Sei i+1 length[A]-1; ansonsten ist nichts zu zeigen. Nach I.V. gilt nach i Durchläufen zu Beginn der Schleife j= i+2. Wir betrachten den (i+1)-sten Durchlauf. Falls A[j] A[max] ist, so wird die then-Anweisung nicht ausgeführt. Dann ist A[max] größtes Element aus A[1..i+2]. Am Ende der Schleife wird j um eins erhöht und es gilt j = i+3. Damit gilt das Lemma in diesem Fall auch für i+1. (Inv.) A[max] ist ein größtes Element aus A[1..i+1] und j = i+2.

28 LS 2 / Informatik 28 Korrektheitsbeweise Lemma 1 Sei 0 i length[A]-1 die Anzahl Schleifendurchläufe der for-Schleife in Algorithmus Max-Search. Dann gilt folgende Schleifeninvariante Beweis(fortgesetzt): (I.V.) Sei nach i length[A]-1 Schleifendurchläufen A[max] ein größtes Element aus A[1..i+1] und j = i+2. (I.S.) Sei i+1 length[A]-1; ansonsten ist nichts zu zeigen. Nach I.V. gilt nach i Durchläufen zu Beginn der Schleife j= i+2. Wir betrachten den (i+1)-sten Durchlauf. Falls A[j] A[max] ist, so wird die then-Anweisung nicht ausgeführt. Dann ist A[max] größtes Element aus A[1..i+2]. Am Ende der Schleife wird j um eins erhöht und es gilt j = i+3. Damit gilt das Lemma in diesem Fall auch für i+1. (Inv.) A[max] ist ein größtes Element aus A[1..i+1] und j = i+2.

29 LS 2 / Informatik 29 Korrektheitsbeweise Lemma 1 Sei 0 i length[A]-1 die Anzahl Schleifendurchläufe der for-Schleife in Algorithmus Max-Search. Dann gilt folgende Schleifeninvariante Beweis(fortgesetzt): Falls A[j] > A[max] ist, so ist nach I.V. A[j] größer als das größte Element aus A[1...i+1] und somit das größte Element aus A[1..i+2]. (Inv.) A[max] ist ein größtes Element aus A[1..i+1] und j = i+2.

30 LS 2 / Informatik 30 Korrektheitsbeweise Lemma 1 Sei 0 i length[A]-1 die Anzahl Schleifendurchläufe der for-Schleife in Algorithmus Max-Search. Dann gilt folgende Schleifeninvariante Beweis(fortgesetzt): Falls A[j] > A[max] ist, so ist nach I.V. A[j] größer als das größte Element aus A[1...i+1] und somit das größte Element aus A[1..i+2]. In der then- Anweisung wird max=j gesetzt. Damit ist A[max] das größte Element aus A[1..i+2]. (Inv.) A[max] ist ein größtes Element aus A[1..i+1] und j = i+2.

31 LS 2 / Informatik 31 Korrektheitsbeweise Lemma 1 Sei 0 i length[A]-1 die Anzahl Schleifendurchläufe der for-Schleife in Algorithmus Max-Search. Dann gilt folgende Schleifeninvariante Beweis(fortgesetzt): Falls A[j] > A[max] ist, so ist nach I.V. A[j] größer als das größte Element aus A[1...i+1] und somit das größte Element aus A[1..i+2]. In der then- Anweisung wird max=j gesetzt. Damit ist A[max] das größte Element aus A[1..i+2]. Am Ende der Schleife wird j um eins erhöht und es gilt j = i+3. (Inv.) A[max] ist ein größtes Element aus A[1..i+1] und j = i+2.

32 LS 2 / Informatik 32 Korrektheitsbeweise Lemma 1 Sei 0 i length[A]-1 die Anzahl Schleifendurchläufe der for-Schleife in Algorithmus Max-Search. Dann gilt folgende Schleifeninvariante Beweis(fortgesetzt): Falls A[j] > A[max] ist, so ist nach I.V. A[j] größer als das größte Element aus A[1...i+1] und somit das größte Element aus A[1..i+2]. In der then- Anweisung wird max=j gesetzt. Damit ist A[max] das größte Element aus A[1..i+2]. Am Ende der Schleife wird j um eins erhöht und es gilt j = i+3. Damit gilt das Lemma in diesem Fall auch für i+1. (Inv.) A[max] ist ein größtes Element aus A[1..i+1] und j = i+2.

33 LS 2 / Informatik 33 Korrektheitsbeweise Lemma 1 Sei 0 i length[A]-1 die Anzahl Schleifendurchläufe der for-Schleife in Algorithmus Max-Search. Dann gilt folgende Schleifeninvariante Beweis(fortgesetzt): Falls A[j] > A[max] ist, so ist nach I.V. A[j] größer als das größte Element aus A[1...i+1] und somit das größte Element aus A[1..i+2]. In der then- Anweisung wird max=j gesetzt. Damit ist A[max] das größte Element aus A[1..i+2]. Am Ende der Schleife wird j um eins erhöht und es gilt j = i+3. Damit gilt das Lemma in diesem Fall auch für i+1. (Inv.) A[max] ist ein größtes Element aus A[1..i+1] und j = i+2.

34 LS 2 / Informatik 34 Korrektheitsbeweise Satz 2 Algorithmus Max-Search berechnet den Index eines größten Element aus einem Feld A. Beweis Nach dem Lemma 1 gilt insbesondere nach length[A]-1 Durchläufen der for- Schleife, dass A[max] ein größtes Element aus A[1..length[A]] ist und das j=length[A]-1+2 = length[A]+1 ist. Damit wird die Schleife nicht noch ein weiteres mal durchlaufen. Der return-Befehl gibt max und somit den Index eines größten Elementes aus A zurück.

35 LS 2 / Informatik 35 InsertionSort(Array A) 1.for j 2 to length[A] do 2. key A[j] 3. i j-1 4. while i>0 and A[i]>key do 5. A[i+1] A[i] 6. i i-1 7. A[i+1] key Beispiel Insertion Sort

36 LS 2 / Informatik 36 InsertionSort(Array A) Eingabegröße n 1.for j 2 to length[A] do length[A] = n 2. key A[j] 3. i j-1 4. while i>0 and A[i]>key do 5. A[i+1] A[i] 6. i i-1 7. A[i+1] key Insertion Sort n j

37 LS 2 / Informatik 37 InsertionSort(Array A) Eingabegröße n 1.for j 2 to length[A] do length[A] = n 2. key A[j] 3. i j-1 4. while i>0 and A[i]>key do 5. A[i+1] A[i] 6. i i-1 7. A[i+1] key Insertion Sort n j key

38 LS 2 / Informatik 38 InsertionSort(Array A) Eingabegröße n 1.for j 2 to length[A] do length[A] = n 2. key A[j] 3. i j-1 4. while i>0 and A[i]>key do 5. A[i+1] A[i] 6. i i-1 7. A[i+1] key Insertion Sort i n j key

39 LS 2 / Informatik 39 InsertionSort(Array A) Eingabegröße n 1.for j 2 to length[A] do length[A] = n 2. key A[j] 3. i j-1 4. while i>0 and A[i]>key do 5. A[i+1] A[i] 6. i i-1 7. A[i+1] key Insertion Sort i n j key

40 LS 2 / Informatik 40 InsertionSort(Array A) Eingabegröße n 1.for j 2 to length[A] do length[A] = n 2. key A[j] 3. i j-1 4. while i>0 and A[i]>key do 5. A[i+1] A[i] 6. i i-1 7. A[i+1] key Insertion Sort n j

41 LS 2 / Informatik 41 InsertionSort(Array A) Eingabegröße n 1.for j 2 to length[A] do length[A] = n 2. key A[j] 3. i j-1 4. while i>0 and A[i]>key do 5. A[i+1] A[i] 6. i i-1 7. A[i+1] key Insertion Sort n j key

42 LS 2 / Informatik 42 InsertionSort(Array A) Eingabegröße n 1.for j 2 to length[A] do length[A] = n 2. key A[j] 3. i j-1 4. while i>0 and A[i]>key do 5. A[i+1] A[i] 6. i i-1 7. A[i+1] key Insertion Sort n j i key=3

43 LS 2 / Informatik 43 InsertionSort(Array A) Eingabegröße n 1.for j 2 to length[A] do length[A] = n 2. key A[j] 3. i j-1 4. while i>0 and A[i]>key do 5. A[i+1] A[i] 6. i i-1 7. A[i+1] key Insertion Sort n j key=3 i

44 LS 2 / Informatik 44 InsertionSort(Array A) Eingabegröße n 1.for j 2 to length[A] do length[A] = n 2. key A[j] 3. i j-1 4. while i>0 and A[i]>key do 5. A[i+1] A[i] 6. i i-1 7. A[i+1] key Insertion Sort n j key=3 i

45 LS 2 / Informatik 45 InsertionSort(Array A) Eingabegröße n 1.for j 2 to length[A] do length[A] = n 2. key A[j] 3. i j-1 4. while i>0 and A[i]>key do 5. A[i+1] A[i] 6. i i-1 7. A[i+1] key Insertion Sort i n j key=3

46 LS 2 / Informatik 46 InsertionSort(Array A) Eingabegröße n 1.for j 2 to length[A] do length[A] = n 2. key A[j] 3. i j-1 4. while i>0 and A[i]>key do 5. A[i+1] A[i] 6. i i-1 7. A[i+1] key Insertion Sort i n j key=3

47 LS 2 / Informatik 47 InsertionSort(Array A) Eingabegröße n 1.for j 2 to length[A] do length[A] = n 2. key A[j] 3. i j-1 4. while i>0 and A[i]>key do 5. A[i+1] A[i] 6. i i-1 7. A[i+1] key Insertion Sort i n j key=3

48 LS 2 / Informatik 48 InsertionSort(Array A) Eingabegröße n 1.for j 2 to length[A] do length[A] = n 2. key A[j] 3. i j-1 4. while i>0 and A[i]>key do 5. A[i+1] A[i] 6. i i-1 7. A[i+1] key Insertion Sort n j key=3 i

49 LS 2 / Informatik 49 InsertionSort(Array A) Eingabegröße n 1.for j 2 to length[A] do length[A] = n 2. key A[j] 3. i j-1 4. while i>0 and A[i]>key do 5. A[i+1] A[i] 6. i i-1 7. A[i+1] key Insertion Sort n ji key=3

50 LS 2 / Informatik 50 InsertionSort(Array A) Eingabegröße n 1.for j 2 to length[A] do length[A] = n 2. key A[j] 3. i j-1 4. while i>0 and A[i]>key do 5. A[i+1] A[i] 6. i i-1 7. A[i+1] key Insertion Sort n j key=3 i

51 LS 2 / Informatik 51 InsertionSort(Array A) Eingabegröße n 1.for j 2 to length[A] do length[A] = n 2. key A[j] 3. i j-1 4. while i>0 and A[i]>key do 5. A[i+1] A[i] 6. i i-1 7. A[i+1] key Insertion Sort n j Sortiert

52 LS 2 / Informatik 52 InsertionSort(Array A) Eingabegröße n 1.for j 2 to length[A] do length[A] = n 2. key A[j] 3. i j-1 4. while i>0 and A[i]>key do 5. A[i+1] A[i] 6. i i-1 7. A[i+1] key Insertion Sort n j Sortiert key

53 LS 2 / Informatik 53 InsertionSort(Array A) Eingabegröße n 1.for j 2 to length[A] do length[A] = n 2. key A[j] 3. i j-1 4. while i>0 and A[i]>key do 5. A[i+1] A[i] 6. i i-1 7. A[i+1] key Insertion Sort n j Sortiert key=14

54 LS 2 / Informatik 54 InsertionSort(Array A) Eingabegröße n 1.for j 2 to length[A] do length[A] = n 2. key A[j] 3. i j-1 verschiebe alle Elemente aus 4. while i>0 and A[i]>key do A[1…j-1], die größer als key 5. A[i+1] A[i] sind eine Stelle nach rechts 6. i i-1 7. A[i+1] key Insertion Sort n j Sortiert key=14 j-1

55 LS 2 / Informatik 55 InsertionSort(Array A) Eingabegröße n 1.for j 2 to length[A] do length[A] = n 2. key A[j] 3. i j-1 verschiebe alle Elemente aus 4. while i>0 and A[i]>key do A[1…j-1], die größer als key 5. A[i+1] A[i] sind eine Stelle nach rechts 6. i i-1 7. A[i+1] key Insertion Sort n j Sortiert key=14 j-1

56 LS 2 / Informatik 56 InsertionSort(Array A) Eingabegröße n 1.for j 2 to length[A] do length[A] = n 2. key A[j] 3. i j-1 verschiebe alle Elemente aus 4. while i>0 and A[i]>key do A[1…j-1], die größer als key 5. A[i+1] A[i] sind eine Stelle nach rechts 6. i i-1 7. A[i+1] key Insertion Sort n j key=14 j-1i

57 LS 2 / Informatik 57 InsertionSort(Array A) Eingabegröße n 1.for j 2 to length[A] do length[A] = n 2. key A[j] 3. i j-1 verschiebe alle Elemente aus 4. while i>0 and A[i]>key do A[1…j-1], die größer als key 5. A[i+1] A[i] sind eine Stelle nach rechts 6. i i-1 7. A[i+1] key Insertion Sort n j key=14 i+1i

58 LS 2 / Informatik 58 InsertionSort(Array A) Eingabegröße n 1.for j 2 to length[A] do length[A] = n 2. key A[j] 3. i j-1 verschiebe alle Elemente aus 4. while i>0 and A[i]>key do A[1…j-1], die größer als key 5. A[i+1] A[i] sind eine Stelle nach rechts 6. i i-1 7. A[i+1] key Speichere key in Lücke Insertion Sort n j key=14 i+1i

59 LS 2 / Informatik 59 InsertionSort(Array A) Eingabegröße n 1.for j 2 to length[A] do length[A] = n 2. key A[j] 3. i j-1 verschiebe alle Elemente aus 4. while i>0 and A[i]>key do A[1…j-1], die größer als key 5. A[i+1] A[i] sind eine Stelle nach rechts 6. i i-1 7. A[i+1] key Speichere key in Lücke Insertion Sort n j Sortiert

60 LS 2 / Informatik 60 InsertionSort(Array A) Eingabegröße n 1.for j 2 to length[A] do length[A] = n 2. key A[j] 3. i j-1 verschiebe alle Elemente aus 4. while i>0 and A[i]>key do A[1…j-1], die größer als key 5. A[i+1] A[i] sind eine Stelle nach rechts 6. i i-1 7. A[i+1] key Speichere key in Lücke Insertion Sort n j Sortiert key=7

61 LS 2 / Informatik 61 InsertionSort(Array A) Eingabegröße n 1.for j 2 to length[A] do length[A] = n 2. key A[j] 3. i j-1 verschiebe alle Elemente aus 4. while i>0 and A[i]>key do A[1…j-1], die größer als key 5. A[i+1] A[i] sind eine Stelle nach rechts 6. i i-1 7. A[i+1] key Speichere key in Lücke Insertion Sort n j Sortiert key=7

62 LS 2 / Informatik 62 InsertionSort(Array A) Eingabegröße n 1.for j 2 to length[A] do length[A] = n 2. key A[j] 3. i j-1 verschiebe alle Elemente aus 4. while i>0 and A[i]>key do A[1…j-1], die größer als key 5. A[i+1] A[i] sind eine Stelle nach rechts 6. i i-1 7. A[i+1] key Speichere key in Lücke Insertion Sort n j key=7

63 LS 2 / Informatik 63 InsertionSort(Array A) Eingabegröße n 1.for j 2 to length[A] do length[A] = n 2. key A[j] 3. i j-1 verschiebe alle Elemente aus 4. while i>0 and A[i]>key do A[1…j-1], die größer als key 5. A[i+1] A[i] sind eine Stelle nach rechts 6. i i-1 7. A[i+1] key Speichere key in Lücke Insertion Sort n j key=7

64 LS 2 / Informatik 64 InsertionSort(Array A) Eingabegröße n 1.for j 2 to length[A] do length[A] = n 2. key A[j] 3. i j-1 verschiebe alle Elemente aus 4. while i>0 and A[i]>key do A[1…j-1], die größer als key 5. A[i+1] A[i] sind eine Stelle nach rechts 6. i i-1 7. A[i+1] key Speichere key in Lücke Insertion Sort n j key=7

65 LS 2 / Informatik 65 InsertionSort(Array A) Eingabegröße n 1.for j 2 to length[A] do length[A] = n 2. key A[j] 3. i j-1 verschiebe alle Elemente aus 4. while i>0 and A[i]>key do A[1…j-1], die größer als key 5. A[i+1] A[i] sind eine Stelle nach rechts 6. i i-1 7. A[i+1] key Speichere key in Lücke Insertion Sort n j Sortiert

66 LS 2 / Informatik 66 InsertionSort(Array A) Eingabegröße n 1.for j 2 to length[A] do length[A] = n 2. key A[j] 3. i j-1 verschiebe alle Elemente aus 4. while i>0 and A[i]>key do A[1…j-1], die größer als key 5. A[i+1] A[i] sind eine Stelle nach rechts 6. i i-1 7. A[i+1] key Speichere key in Lücke Insertion Sort n j key=6 Sortiert

67 LS 2 / Informatik 67 InsertionSort(Array A) Eingabegröße n 1.for j 2 to length[A] do length[A] = n 2. key A[j] 3. i j-1 verschiebe alle Elemente aus 4. while i>0 and A[i]>key do A[1…j-1], die größer als key 5. A[i+1] A[i] sind eine Stelle nach rechts 6. i i-1 7. A[i+1] key Speichere key in Lücke Insertion Sort n j key=6 Sortiert

68 LS 2 / Informatik 68 InsertionSort(Array A) Eingabegröße n 1.for j 2 to length[A] do length[A] = n 2. key A[j] 3. i j-1 verschiebe alle Elemente aus 4. while i>0 and A[i]>key do A[1…j-1], die größer als key 5. A[i+1] A[i] sind eine Stelle nach rechts 6. i i-1 7. A[i+1] key Speichere key in Lücke Insertion Sort n j key=6

69 LS 2 / Informatik 69 InsertionSort(Array A) Eingabegröße n 1.for j 2 to length[A] do length[A] = n 2. key A[j] 3. i j-1 verschiebe alle Elemente aus 4. while i>0 and A[i]>key do A[1…j-1], die größer als key 5. A[i+1] A[i] sind eine Stelle nach rechts 6. i i-1 7. A[i+1] key Speichere key in Lücke Insertion Sort n j key=6

70 LS 2 / Informatik 70 InsertionSort(Array A) Eingabegröße n 1.for j 2 to length[A] do length[A] = n 2. key A[j] 3. i j-1 verschiebe alle Elemente aus 4. while i>0 and A[i]>key do A[1…j-1], die größer als key 5. A[i+1] A[i] sind eine Stelle nach rechts 6. i i-1 7. A[i+1] key Speichere key in Lücke Insertion Sort n j key=6

71 LS 2 / Informatik 71 InsertionSort(Array A) Eingabegröße n 1.for j 2 to length[A] do length[A] = n 2. key A[j] 3. i j-1 verschiebe alle Elemente aus 4. while i>0 and A[i]>key do A[1…j-1], die größer als key 5. A[i+1] A[i] sind eine Stelle nach rechts 6. i i-1 7. A[i+1] key Speichere key in Lücke Insertion Sort n j Sortiert

72 LS 2 / Informatik 72 InsertionSort(Array A) Eingabegröße n 1.for j 2 to length[A] do length[A] = n 2. key A[j] 3. i j-1 verschiebe alle Elemente aus 4. while i>0 and A[i]>key do A[1…j-1], die größer als key 5. A[i+1] A[i] sind eine Stelle nach rechts 6. i i-1 7. A[i+1] key Speichere key in Lücke Insertion Sort n j

73 LS 2 / Informatik 73 InsertionSort(Array A) Eingabegröße n 1.for j 2 to length[A] do length[A] = n 2. key A[j] 3. i j-1 verschiebe alle Elemente aus 4. while i>0 and A[i]>key do A[1…j-1], die größer als key 5. A[i+1] A[i] sind eine Stelle nach rechts 6. i i-1 7. A[i+1] key Speichere key in Lücke Insertion Sort n Sortiert

74 LS 2 / Informatik 74 InsertionSort(Array A) Eingabegröße n 1.for j 2 to length[A] do length[A] = n 2. key A[j] 3. i j-1 verschiebe alle Elemente aus 4. while i>0 and A[i]>key do A[1…j-1], die größer als key 5. A[i+1] A[i] sind eine Stelle nach rechts 6. i i-1 7. A[i+1] key Speichere key in Lücke Lemma 3 Ist A[1..j-1] bereits sortiert, so fügt der unterlegte Block (Zeilen 2-7 des Algorithmus) A[j] korrekt in die sortierte Folge A[1..j-1] ein. Die daraus resultierende Folge steht am Ende in A[1..j]. Insertion Sort

75 LS 2 / Informatik 75 Lemma 3 Ist A[1..j-1] bereits sortiert, so fügt der unterlegte Block (Zeilen 2-7 des Algorithmus) A[j] korrekt in die sortierte Folge A[1..j-1] ein. Die daraus resultierende Folge steht am Ende in A[1..j]. Beweis: Wir betrachten Zeile 2-7 des Algorithmus und nehmen an, das A[1..j-1] bereits sortiert ist. In Zeile 2 wird A[j] in key abgespeichert und in Zeile 3 wird i auf j-1 gesetzt. Korrektheit - Insertion Sort

76 LS 2 / Informatik 76 Lemma 3 Ist A[1..j-1] bereits sortiert, so fügt der unterlegte Block (Zeilen 2-7 des Algorithmus) A[j] korrekt in die sortierte Folge A[1..j-1] ein. Die daraus resultierende Folge steht am Ende in A[1..j]. Beweis: Wir betrachten Zeile 2-7 des Algorithmus und nehmen an, das A[1..j-1] bereits sortiert ist. In Zeile 2 wird A[j] in key abgespeichert und in Zeile 3 wird i auf j-1 gesetzt. Sei nun A das Feld A zum Zeitpunkt vor dem ersten Eintritt in die while-Schleife. Korrektheit - Insertion Sort

77 LS 2 / Informatik 77 Lemma 3 Ist A[1..j-1] bereits sortiert, so fügt der unterlegte Block (Zeilen 2-7 des Algorithmus) A[j] korrekt in die sortierte Folge A[1..j-1] ein. Die daraus resultierende Folge steht am Ende in A[1..j]. Beweis: Wir betrachten Zeile 2-7 des Algorithmus und nehmen an, das A[1..j-1] bereits sortiert ist. In Zeile 2 wird A[j] in key abgespeichert und in Zeile 3 wird i auf j-1 gesetzt. Sei nun A das Feld A zum Zeitpunkt vor dem ersten Eintritt in die while-Schleife. Außerdem sei i* der größte Index i {1,..,j-1} mit A[i]key und i*=0, falls kein solcher Index existiert. Damit bricht die while-Schleife genau dann ab, wenn i=i* ist. Korrektheit - Insertion Sort

78 LS 2 / Informatik 78 Lemma 3 Ist A[1..j-1] bereits sortiert, so fügt der unterlegte Block (Zeilen 2-7 des Algorithmus) A[j] korrekt in die sortierte Folge A[1..j-1] ein. Die daraus resultierende Folge steht am Ende in A[1..j]. Beweis: Wir betrachten Zeile 2-7 des Algorithmus und nehmen an, das A[1..j-1] bereits sortiert ist. In Zeile 2 wird A[j] in key abgespeichert und in Zeile 3 wird i auf j-1 gesetzt. Sei nun A das Feld A zum Zeitpunkt vor dem ersten Eintritt in die while-Schleife. Außerdem sei i* der größte Index i {1,..,j-1} mit A[i]key und i*=0, falls kein solcher Index existiert. Damit bricht die while-Schleife genau dann ab, wenn i=i* ist. Wir zeigen folgende Invariante. Für 0kj-i*-1 gilt: (Inv.) Am Ende des k-ten Durchlaufs der while-Schleife gilt (a) A[1..j-k] = A[1…j-k] (b) A[j-k+1..j] = A[j-k..j-1] (c) key A[j-k] und i = j-1-k Korrektheit - Insertion Sort

79 LS 2 / Informatik 79 Lemma 3 Ist A[1..j-1] bereits sortiert, so fügt der unterlegte Block (Zeilen 2-7 des Algorithmus) A[j] korrekt in die sortierte Folge A[1..j-1] ein. Die daraus resultierende Folge steht am Ende in A[1..j]. Beweis: Wir betrachten Zeile 2-7 des Algorithmus und nehmen an, das A[1..j-1] bereits sortiert ist. In Zeile 2 wird A[j] in key abgespeichert und in Zeile 3 wird i auf j-1 gesetzt. Sei nun A das Feld A zum Zeitpunkt vor dem ersten Eintritt in die while-Schleife. Außerdem sei i* der größte Index i {1,..,j-1} mit A[i]key und i*=0, falls kein solcher Index existiert. Damit bricht die while-Schleife genau dann ab, wenn i=i* ist. Wir zeigen folgende Invariante. Für 0kj-i*-1 gilt: (Inv.) Am Ende des k-ten Durchlaufs der while-Schleife gilt (a) A[1..j-k] = A[1…j-k] (b) A[j-k+1..j] = A[j-k..j-1] (c) key A[j-k] und i = j-1-k Korrektheit - Insertion Sort

80 LS 2 / Informatik 80 Beweis (fortgesetzt): Wir zeigen folgende Invariante. Für 0kj-i*-1 gilt: (Inv.) Am Ende des k-ten Durchlaufs der while-Schleife gilt (a) A[1..j-k] = A[1…j-k] (b) A[j-k+1..j] = A[j-k..j-1] (c) key A[j-k] und i=j-1-k Wir zeigen die Invariante per Induktion über die Anzahl Schleifendurchläufe k. Korrektheit - Insertion Sort

81 LS 2 / Informatik 81 Beweis (fortgesetzt): Wir zeigen folgende Invariante. Für 0kj-i*-1 gilt: (Inv.) Am Ende des k-ten Durchlaufs der while-Schleife gilt (a) A[1..j-k] = A[1…j-k] (b) A[j-k+1..j] = A[j-k..j-1] (c) key A[j-k] und i=j-1-k Wir zeigen die Invariante per Induktion über die Anzahl Schleifendurchläufe k. (I.A.) Für k=0 ist A[1..j] = A[1..j]. Außerdem sind A[j+1..j] und A[j..j-1] beide leer. Weiterhin ist i=j-1 und key=A[j]. Somit gilt die Invariante. Korrektheit - Insertion Sort

82 LS 2 / Informatik 82 Beweis (fortgesetzt): Wir zeigen folgende Invariante. Für 0kj-i*-1 gilt: (Inv.) Am Ende des k-ten Durchlaufs der while-Schleife gilt (a) A[1..j-k] = A[1…j-k] (b) A[j-k+1..j] = A[j-k..j-1] (c) key A[j-k] und i=j-1-k Wir zeigen die Invariante per Induktion über die Anzahl Schleifendurchläufe k. (I.A.) Für k=0 ist A[1..j] = A[1..j]. Außerdem sind A[j+1..j] und A[j..j-1] beide leer. Weiterhin ist i=j-1 und key=A[j]. Somit gilt die Invariante. (I.V.) Die Invariante gelte für festes k, 0kj-i*-1. Korrektheit - Insertion Sort

83 LS 2 / Informatik 83 Beweis (fortgesetzt): Wir zeigen folgende Invariante. Für 0kj-i*-1 gilt: (Inv.) Am Ende des k-ten Durchlaufs der while-Schleife gilt (a) A[1..j-k] = A[1…j-k] (b) A[j-k+1..j] = A[j-k..j-1] (c) key A[j-k] und i=j-1-k Wir zeigen die Invariante per Induktion über die Anzahl Schleifendurchläufe k. (I.A.) Für k=0 ist A[1..j] = A[1..j]. Außerdem sind A[j+1..j] und A[j..j-1] beide leer. Weiterhin ist i=j-1 und key=A[j]. Somit gilt die Invariante. (I.V.) Die Invariante gelte für festes k, 0kj-i*-1. (I.S.) Sei k+1j-i*-1. Nach I.V. gilt die Invariante nach k Durchläufen. Korrektheit - Insertion Sort

84 LS 2 / Informatik 84 Beweis (fortgesetzt): Wir zeigen folgende Invariante. Für 0kj-i*-1 gilt: (Inv.) Am Ende des k-ten Durchlaufs der while-Schleife gilt (a) A[1..j-k] = A[1…j-k] (b) A[j-k+1..j] = A[j-k..j-1] (c) key A[j-k] und i=j-1-k Wir zeigen die Invariante per Induktion über die Anzahl Schleifendurchläufe k. (I.A.) Für k=0 ist A[1..j] = A[1..j]. Außerdem sind A[j+1..j] und A[j..j-1] beide leer. Weiterhin ist i=j-1 und key=A[j]. Somit gilt die Invariante. (I.V.) Die Invariante gelte für festes k, 0kj-i*-1. (I.S.) Sei k+1j-i*-1. Nach I.V. gilt die Invariante nach k Durchläufen. In Zeile 5 wird nun A[i+1]= A[j-k] auf den Wert aus A[i]=A[j-k-1] gesetzt. Dieser ist nach I.V. gleich A[j-k-1]. Korrektheit - Insertion Sort

85 LS 2 / Informatik 85 Beweis (fortgesetzt): Wir zeigen folgende Invariante. Für 0kj-i*-1 gilt: (Inv.) Am Ende des k-ten Durchlaufs der while-Schleife gilt (a) A[1..j-k] = A[1…j-k] (b) A[j-k+1..j] = A[j-k..j-1] (c) key A[j-k] und i=j-1-k Wir zeigen die Invariante per Induktion über die Anzahl Schleifendurchläufe k. (I.A.) Für k=0 ist A[1..j] = A[1..j]. Außerdem sind A[j+1..j] und A[j..j-1] beide leer. Weiterhin ist i=j-1 und key=A[j]. Somit gilt die Invariante. (I.V.) Die Invariante gelte für festes k, 0kj-i*-1. (I.S.) Sei k+1j-i*-1. Nach I.V. gilt die Invariante nach k Durchläufen. In Zeile 5 wird nun A[i+1]= A[j-k] auf den Wert aus A[i]=A[j-k-1] gesetzt. Dieser ist nach I.V. gleich A[j-k-1]. Da sonst keine Änderung an A vorgenommen wird, gelten somit (a) und (b) auch für k+1. Korrektheit - Insertion Sort

86 LS 2 / Informatik 86 Beweis (fortgesetzt): Wir zeigen folgende Invariante. Für 0kj-i*-1 gilt: (Inv.) Am Ende des k-ten Durchlaufs der while-Schleife gilt (a) A[1..j-k] = A[1…j-k] (b) A[j-k+1..j] = A[j-k..j-1] (c) key A[j-k] und i=j-1-k Wir zeigen die Invariante per Induktion über die Anzahl Schleifendurchläufe k. (I.A.) Für k=0 ist A[1..j] = A[1..j]. Außerdem sind A[j+1..j] und A[j..j-1] beide leer. Weiterhin ist i=j-1 und key=A[j]. Somit gilt die Invariante. (I.V.) Die Invariante gelte für festes k, 0kj-i*-1. (I.S.) Sei k+1j-i*-1. Nach I.V. gilt die Invariante nach k Durchläufen. In Zeile 5 wird nun A[i+1]= A[j-k] auf den Wert aus A[i]=A[j-k-1] gesetzt. Dieser ist nach I.V. gleich A[j-k-1]. Da sonst keine Änderung an A vorgenommen wird, gelten somit (a) und (b) auch für k+1. Korrektheit - Insertion Sort

87 LS 2 / Informatik 87 Beweis (fortgesetzt): Wir zeigen folgende Invariante. Für 0kj-i*-1 gilt: (Inv.) Am Ende des k-ten Durchlaufs der while-Schleife gilt (a) A[1..j-k] = A[1…j-k] (b) A[j-k+1..j] = A[j-k..j-1] (c) key A[j-k] und i=j-1-k (I.S.) Sei k+1j-i*-1. Nach I.V. gilt die Invariante nach k Durchläufen. In Zeile 5 wird nun A[i+1]= A[j-k] auf den Wert aus A[i]=A[j-k-1] gesetzt. Dieser ist nach I.V. gleich A[j-k-1]. Da sonst keine Änderung an A vorgenommen wird, gelten somit (a) und (b) auch für k+1. Korrektheit - Insertion Sort

88 LS 2 / Informatik 88 Beweis (fortgesetzt): Wir zeigen folgende Invariante. Für 0kj-i*-1 gilt: (Inv.) Am Ende des k-ten Durchlaufs der while-Schleife gilt (a) A[1..j-k] = A[1…j-k] (b) A[j-k+1..j] = A[j-k..j-1] (c) key A[j-k] und i=j-1-k (I.S.) Sei k+1j-i*-1. Nach I.V. gilt die Invariante nach k Durchläufen. In Zeile 5 wird nun A[i+1]= A[j-k] auf den Wert aus A[i]=A[j-k-1] gesetzt. Dieser ist nach I.V. gleich A[j-k-1]. Da sonst keine Änderung an A vorgenommen wird, gelten somit (a) und (b) auch für k+1. Außerdem gilt key i* gilt. Korrektheit - Insertion Sort

89 LS 2 / Informatik 89 Beweis (fortgesetzt): Wir zeigen folgende Invariante. Für 0kj-i*-1 gilt: (Inv.) Am Ende des k-ten Durchlaufs der while-Schleife gilt (a) A[1..j-k] = A[1…j-k] (b) A[j-k+1..j] = A[j-k..j-1] (c) key A[j-k] und i=j-1-k (I.S.) Sei k+1j-i*-1. Nach I.V. gilt die Invariante nach k Durchläufen. In Zeile 5 wird nun A[i+1]= A[j-k] auf den Wert aus A[i]=A[j-k-1] gesetzt. Dieser ist nach I.V. gleich A[j-k-1]. Da sonst keine Änderung an A vorgenommen wird, gelten somit (a) und (b) auch für k+1. Außerdem gilt key i* gilt. Nach der Wahl von i* gilt somit key

90 LS 2 / Informatik 90 Beweis (fortgesetzt): Wir zeigen folgende Invariante. Für 0kj-i*-1 gilt: (Inv.) Am Ende des k-ten Durchlaufs der while-Schleife gilt (a) A[1..j-k] = A[1…j-k] (b) A[j-k+1..j] = A[j-k..j-1] (c) key A[j-k] und i=j-1-k (I.S.) Sei k+1j-i*-1. Nach I.V. gilt die Invariante nach k Durchläufen. In Zeile 5 wird nun A[i+1]= A[j-k] auf den Wert aus A[i]=A[j-k-1] gesetzt. Dieser ist nach I.V. gleich A[j-k-1]. Da sonst keine Änderung an A vorgenommen wird, gelten somit (a) und (b) auch für k+1. Außerdem gilt key i* gilt. Nach der Wahl von i* gilt somit key

91 LS 2 / Informatik 91 Beweis (fortgesetzt): Wir zeigen folgende Invariante. Für 0kj-i*-1 gilt: (Inv.) Am Ende des k-ten Durchlaufs der while-Schleife gilt (a) A[1..j-k] = A[1…j-k] (b) A[j-k+1..j] = A[j-k..j-1] (c) key A[j-k] und i=j-1-k (I.S.) Sei k+1j-i*-1. Nach I.V. gilt die Invariante nach k Durchläufen. In Zeile 5 wird nun A[i+1]= A[j-k] auf den Wert aus A[i]=A[j-k-1] gesetzt. Dieser ist nach I.V. gleich A[j-k-1]. Da sonst keine Änderung an A vorgenommen wird, gelten somit (a) und (b) auch für k+1. Außerdem gilt key i* gilt. Nach der Wahl von i* gilt somit key

92 LS 2 / Informatik 92 Beweis (fortgesetzt): Wir zeigen folgende Invariante. Für 0kj-i*-1 gilt: (Inv.) Am Ende des k-ten Durchlaufs der while-Schleife gilt (a) A[1..j-k] = A[1…j-k] (b) A[j-k+1..j] = A[j-k..j-1] (c) key A[j-k] und i=j-1-k (I.S.) Sei k+1j-i*-1. Nach I.V. gilt die Invariante nach k Durchläufen. In Zeile 5 wird nun A[i+1]= A[j-k] auf den Wert aus A[i]=A[j-k-1] gesetzt. Dieser ist nach I.V. gleich A[j-k-1]. Da sonst keine Änderung an A vorgenommen wird, gelten somit (a) und (b) auch für k+1. Außerdem gilt key i* gilt. Nach der Wahl von i* gilt somit key

93 LS 2 / Informatik 93 Beweis (fortgesetzt): Wir zeigen folgende Invariante. Für 0kj-i*-1 gilt: (Inv.) Am Ende des k-ten Durchlaufs der while-Schleife gilt (a) A[1..j-k] = A[1…j-k] (b) A[j-k+1..j] = A[j-k..j-1] (c) key A[j-k] und i=j-1-k Damit wissen wir insbesondere, dass nach j-i*-1 Durchläufen die Invariante erfüllt ist. Korrektheit - Insertion Sort

94 LS 2 / Informatik 94 Beweis (fortgesetzt): Wir zeigen folgende Invariante. Für 0kj-i*-1 gilt: (Inv.) Am Ende des k-ten Durchlaufs der while-Schleife gilt (a) A[1..j-k] = A[1…j-k] (b) A[j-k+1..j] = A[j-k..j-1] (c) key A[j-k] und i=j-1-k Damit wissen wir insbesondere, dass nach j-i*-1 Durchläufen die Invariante erfüllt ist. Es gilt dann i=i* und es wird somit kein weiterer Durchlauf durchgeführt. Korrektheit - Insertion Sort

95 LS 2 / Informatik 95 Beweis (fortgesetzt): Wir zeigen folgende Invariante. Für 0kj-i*-1 gilt: (Inv.) Am Ende des k-ten Durchlaufs der while-Schleife gilt (a) A[1..j-k] = A[1…j-k] (b) A[j-k+1..j] = A[j-k..j-1] (c) key A[j-k] und i=j-1-k Damit wissen wir insbesondere, dass nach j-i*-1 Durchläufen die Invariante erfüllt ist. Es gilt dann i=i* und es wird somit kein weiterer Durchlauf durchgeführt. In der letzten Zeile wird nun A[i+1] auf key gesetzt. Korrektheit - Insertion Sort

96 LS 2 / Informatik 96 Beweis (fortgesetzt): Wir zeigen folgende Invariante. Für 0kj-i*-1 gilt: (Inv.) Am Ende des k-ten Durchlaufs der while-Schleife gilt (a) A[1..j-k] = A[1…j-k] (b) A[j-k+1..j] = A[j-k..j-1] (c) key A[j-k] und i=j-1-k Damit wissen wir insbesondere, dass nach j-i*-1 Durchläufen die Invariante erfüllt ist. Es gilt dann i=i* und es wird somit kein weiterer Durchlauf durchgeführt. In der letzten Zeile wird nun A[i+1] auf key gesetzt. Nach unserer Invariante gilt key A[j-k]=A[i*+1]. Korrektheit - Insertion Sort

97 LS 2 / Informatik 97 Beweis (fortgesetzt): Wir zeigen folgende Invariante. Für 0kj-i*-1 gilt: (Inv.) Am Ende des k-ten Durchlaufs der while-Schleife gilt (a) A[1..j-k] = A[1…j-k] (b) A[j-k+1..j] = A[j-k..j-1] (c) key A[j-k] und i=j-1-k Damit wissen wir insbesondere, dass nach j-i*-1 Durchläufen die Invariante erfüllt ist. Es gilt dann i=i* und es wird somit kein weiterer Durchlauf durchgeführt. In der letzten Zeile wird nun A[i+1] auf key gesetzt. Nach unserer Invariante gilt key A[j-k]=A[i*+1]. Ist i*=0, so folgt mit (b), dass die Folge nach dem Einfügen sortiert ist. Korrektheit - Insertion Sort

98 LS 2 / Informatik 98 Beweis (fortgesetzt): Wir zeigen folgende Invariante. Für 0kj-i*-1 gilt: (Inv.) Am Ende des k-ten Durchlaufs der while-Schleife gilt (a) A[1..j-k] = A[1…j-k] (b) A[j-k+1..j] = A[j-k..j-1] (c) key A[j-k] und i=j-1-k Damit wissen wir insbesondere, dass nach j-i*-1 Durchläufen die Invariante erfüllt ist. Es gilt dann i=i* und es wird somit kein weiterer Durchlauf durchgeführt. In der letzten Zeile wird nun A[i+1] auf key gesetzt. Nach unserer Invariante gilt key A[j-k]=A[i*+1]. Ist i*=0, so folgt mit (b), dass die Folge nach dem Einfügen sortiert ist. Ist i*>0, so gilt nach der Wahl von i*, dass A[i*]key ist. Korrektheit - Insertion Sort

99 LS 2 / Informatik 99 Beweis (fortgesetzt): Wir zeigen folgende Invariante. Für 0kj-i*-1 gilt: (Inv.) Am Ende des k-ten Durchlaufs der while-Schleife gilt (a) A[1..j-k] = A[1…j-k] (b) A[j-k+1..j] = A[j-k..j-1] (c) key A[j-k] und i=j-1-k Damit wissen wir insbesondere, dass nach j-i*-1 Durchläufen die Invariante erfüllt ist. Es gilt dann i=i* und es wird somit kein weiterer Durchlauf durchgeführt. In der letzten Zeile wird nun A[i+1] auf key gesetzt. Nach unserer Invariante gilt key A[j-k]=A[i*+1]. Ist i*=0, so folgt mit (b), dass die Folge nach dem Einfügen sortiert ist. Ist i*>0, so gilt nach der Wahl von i*, dass A[i*]key ist. Nach (a) gilt A[1..i*+1] = A[1..i*+1], also insbesondere A[1..i*]= A[1..i*]. Korrektheit - Insertion Sort

100 LS 2 / Informatik 100 Beweis (fortgesetzt): Wir zeigen folgende Invariante. Für 0kj-i*-1 gilt: (Inv.) Am Ende des k-ten Durchlaufs der while-Schleife gilt (a) A[1..j-k] = A[1…j-k] (b) A[j-k+1..j] = A[j-k..j-1] (c) key A[j-k] und i=j-1-k Damit wissen wir insbesondere, dass nach j-i*-1 Durchläufen die Invariante erfüllt ist. Es gilt dann i=i* und es wird somit kein weiterer Durchlauf durchgeführt. In der letzten Zeile wird nun A[i+1] auf key gesetzt. Nach unserer Invariante gilt key A[j-k]=A[i*+1]. Ist i*=0, so folgt mit (b), dass die Folge nach dem Einfügen sortiert ist. Ist i*>0, so gilt nach der Wahl von i*, dass A[i*]key ist. Nach (a) gilt A[1..i*+1] = A[1..i*+1], also insbesondere A[1..i*]= A[1..i*]. Nach (b) gilt A[i*+2..j]=A[i*+1..j-1]. Korrektheit - Insertion Sort

101 LS 2 / Informatik 101 Beweis (fortgesetzt): Wir zeigen folgende Invariante. Für 0kj-i*-1 gilt: (Inv.) Am Ende des k-ten Durchlaufs der while-Schleife gilt (a) A[1..j-k] = A[1…j-k] (b) A[j-k+1..j] = A[j-k..j-1] (c) key A[j-k] und i=j-1-k Damit wissen wir insbesondere, dass nach j-i*-1 Durchläufen die Invariante erfüllt ist. Es gilt dann i=i* und es wird somit kein weiterer Durchlauf durchgeführt. In der letzten Zeile wird nun A[i+1] auf key gesetzt. Nach unserer Invariante gilt key A[j-k]=A[i*+1]. Ist i*=0, so folgt mit (b), dass die Folge nach dem Einfügen sortiert ist. Ist i*>0, so gilt nach der Wahl von i*, dass A[i*]key ist. Nach (a) gilt A[1..i*+1] = A[1..i*+1], also insbesondere A[1..i*]= A[1..i*]. Nach (b) gilt A[i*+2..j]=A[i*+1..j-1]. Somit ist nach Einfügen von key=A[j] an die Stelle i*+1 das Teilfeld A[1..j] sortiert. Korrektheit - Insertion Sort

102 LS 2 / Informatik 102 Beweis (fortgesetzt): Wir zeigen folgende Invariante. Für 0kj-i*-1 gilt: (Inv.) Am Ende des k-ten Durchlaufs der while-Schleife gilt (a) A[1..j-k] = A[1…j-k] (b) A[j-k+1..j] = A[j-k..j-1] (c) key A[j-k] und i=j-1-k Damit wissen wir insbesondere, dass nach j-i*-1 Durchläufen die Invariante erfüllt ist. Es gilt dann i=i* und es wird somit kein weiterer Durchlauf durchgeführt. In der letzten Zeile wird nun A[i+1] auf key gesetzt. Nach unserer Invariante gilt key A[j-k]=A[i*+1]. Ist i*=0, so folgt mit (b), dass die Folge nach dem Einfügen sortiert ist. Ist i*>0, so gilt nach der Wahl von i*, dass A[i*]key ist. Nach (a) gilt A[1..i*+1] = A[1..i*+1], also insbesondere A[1..i*]= A[1..i*]. Nach (b) gilt A[i*+2..j]=A[i*+1..j-1]. Somit ist nach Einfügen von key=A[j] an die Stelle i*+1 das Teilfeld A[1..j] sortiert. Korrektheit - Insertion Sort

103 LS 2 / Informatik 103 Vereinfachter Algorithmus InsertionSort(Array A) 1.for j 2 to length[A] do 2. A[j] wird in A[1..j-1] eingefügt Lemma 4 Sei 0klength[A]-1 die Anzahl der Schleifendurchläufe der for-Schleife von InsertionSort. Dann gilt folgende Invariante am Ende jedes Schleifendurchlaufs: (Inv.) A[1..k+1] ist sortiert und j=k+2. Korrektheit - Insertion Sort

104 LS 2 / Informatik 104 Lemma 4 Sei 0klength[A]-1 die Anzahl der Schleifendurchläufe der for-Schleife von InsertionSort. Dann gilt folgende Invariante am Ende jedes Schleifendurchlaufs: (Inv.) A[1..k+1] ist sortiert und j=k+2. Beweis: Der Beweis ist per Induktion über die Anzahl der Schleifendurchläufe k. Korrektheit - Insertion Sort

105 LS 2 / Informatik 105 Lemma 4 Sei 0klength[A]-1 die Anzahl der Schleifendurchläufe der for-Schleife von InsertionSort. Dann gilt folgende Invariante am Ende jedes Schleifendurchlaufs: (Inv.) A[1..k+1] ist sortiert und j=k+2. Beweis: Der Beweis ist per Induktion über die Anzahl der Schleifendurchläufe k. (I.A.) Nach k=0 Schleifendurchläufen ist A[1..1] sortiert und j=2. Korrektheit - Insertion Sort

106 LS 2 / Informatik 106 Lemma 4 Sei 0klength[A]-1 die Anzahl der Schleifendurchläufe der for-Schleife von InsertionSort. Dann gilt folgende Invariante am Ende jedes Schleifendurchlaufs: (Inv.) A[1..k+1] ist sortiert und j=k+2. Beweis: Der Beweis ist per Induktion über die Anzahl der Schleifendurchläufe k. (I.A.) Nach k=0 Schleifendurchläufen ist A[1..1] sortiert und j=2. (I.V.) Das Lemma gilt für ein festes k, 0klength[A]-1. Korrektheit - Insertion Sort

107 LS 2 / Informatik 107 Lemma 4 Sei 0klength[A]-1 die Anzahl der Schleifendurchläufe der for-Schleife von InsertionSort. Dann gilt folgende Invariante am Ende jedes Schleifendurchlaufs: (Inv.) A[1..k+1] ist sortiert und j=k+2. Beweis: Der Beweis ist per Induktion über die Anzahl der Schleifendurchläufe k. (I.A.) Nach k=0 Schleifendurchläufen ist A[1..1] sortiert und j=2. (I.V.) Das Lemma gilt für ein festes k, 0klength[A]-1. (I.S.) Sei k+1length[A]-1. Nach I.V. gilt nach k Durchläufen A[1..j-1] = A[1..k+1]. Somit ist A[1..j-1] bereits sortiert. Korrektheit - Insertion Sort

108 LS 2 / Informatik 108 Lemma 4 Sei 0klength[A]-1 die Anzahl der Schleifendurchläufe der for-Schleife von InsertionSort. Dann gilt folgende Invariante am Ende jedes Schleifendurchlaufs: (Inv.) A[1..k+1] ist sortiert und j=k+2. Beweis: Der Beweis ist per Induktion über die Anzahl der Schleifendurchläufe k. (I.A.) Nach k=0 Schleifendurchläufen ist A[1..1] sortiert und j=2. (I.V.) Das Lemma gilt für ein festes k, 0klength[A]-1. (I.S.) Sei k+1length[A]-1. Nach I.V. gilt nach k Durchläufen A[1..j-1] = A[1..k+1]. Somit ist A[1..j-1] bereits sortiert. Nach Lemma 3 wird A[j] korrekt eingefügt und somit ist nach Abarbeitung von Zeile 2-7 A[1..j] sortiert. Korrektheit - Insertion Sort

109 LS 2 / Informatik 109 Lemma 4 Sei 0klength[A]-1 die Anzahl der Schleifendurchläufe der for-Schleife von InsertionSort. Dann gilt folgende Invariante am Ende jedes Schleifendurchlaufs: (Inv.) A[1..k+1] ist sortiert und j=k+2. Beweis: Der Beweis ist per Induktion über die Anzahl der Schleifendurchläufe k. (I.A.) Nach k=0 Schleifendurchläufen ist A[1..1] sortiert und j=2. (I.V.) Das Lemma gilt für ein festes k, 0klength[A]-1. (I.S.) Sei k+1length[A]-1. Nach I.V. gilt nach k Durchläufen A[1..j-1] = A[1..k+1]. Somit ist A[1..j-1] bereits sortiert. Nach Lemma 3 wird A[j] korrekt eingefügt und somit ist nach Abarbeitung von Zeile 2-7 A[1..j] sortiert. Am Ende der Schleife wird j um eins erhöht. Korrektheit - Insertion Sort

110 LS 2 / Informatik 110 Lemma 4 Sei 0klength[A]-1 die Anzahl der Schleifendurchläufe der for-Schleife von InsertionSort. Dann gilt folgende Invariante am Ende jedes Schleifendurchlaufs: (Inv.) A[1..k+1] ist sortiert und j=k+2. Beweis: Der Beweis ist per Induktion über die Anzahl der Schleifendurchläufe k. (I.A.) Nach k=0 Schleifendurchläufen ist A[1..1] sortiert und j=2. (I.V.) Das Lemma gilt für ein festes k, 0klength[A]-1. (I.S.) Sei k+1length[A]-1. Nach I.V. gilt nach k Durchläufen A[1..j-1] = A[1..k+1]. Somit ist A[1..j-1] bereits sortiert. Nach Lemma 3 wird A[j] korrekt eingefügt und somit ist nach Abarbeitung von Zeile 2-7 A[1..j] sortiert. Am Ende der Schleife wird j um eins erhöht. Somit gilt die Invariante auch nach k+1 Durchläufen. Korrektheit - Insertion Sort

111 LS 2 / Informatik 111 Lemma 4 Sei 0klength[A]-1 die Anzahl der Schleifendurchläufe der for-Schleife von InsertionSort. Dann gilt folgende Invariante am Ende jedes Schleifendurchlaufs: (Inv.) A[1..k+1] ist sortiert und j=k+2. Beweis: Der Beweis ist per Induktion über die Anzahl der Schleifendurchläufe k. (I.A.) Nach k=0 Schleifendurchläufen ist A[1..1] sortiert und j=2. (I.V.) Das Lemma gilt für ein festes k, 0klength[A]-1. (I.S.) Sei k+1length[A]-1. Nach I.V. gilt nach k Durchläufen A[1..j-1] = A[1..k+1]. Somit ist A[1..j-1] bereits sortiert. Nach Lemma 3 wird A[j] korrekt eingefügt und somit ist nach Abarbeitung von Zeile 2-7 A[1..j] sortiert. Am Ende der Schleife wird j um eins erhöht. Somit gilt die Invariante auch nach k+1 Durchläufen. Korrektheit - Insertion Sort

112 LS 2 / Informatik 112 Korrektheit - Insertion Sort Satz 5 InsertionSort sortiert jedes Feld A korrekt. Beweis: Die Korrektheit folgt aus Lemma 4 mit k=length[A]-1.

113 LS 2 / Informatik 113 Korrektheitsbeweise - Rekursionen Algorithmus Sum(A,n) 1.If n=1 then return A[1] 2.else 3. W= Sum(A,n-1) 4. return A[n] + W Problem Wir können nicht genau sagen, wie häufig eine Rekursion ausgeführt wird.

114 LS 2 / Informatik 114 Korrektheitsbeweise - Rekursionen Algorithmus Sum(A,n) 1.If n=1 then return A[1] 2.else 3. W= Sum(A,n-1) 4. return A[n] + W Abhilfe Rekursion ist das Gegenstück zu Induktion. Man kann daher die Korrektheit leicht per Induktion zeigen.

115 LS 2 / Informatik 115 Korrektheitsbeweise - Rekursionen Algorithmus Sum(A,n) 1.If n=1 then return A[1] 2.else 3. W= Sum(A,n-1) 4. return A[n] + W Satz 6 Algorithmus Sum(A,n) berechnet die Summe der ersten n Einträge eines Feldes A. Beweis (Induktion über n): (I.A.) Ist n=1, so gibt der Algorithmus in Zeile 1 den Wert A[1] zurück. Dies ist korrekt.

116 LS 2 / Informatik 116 Korrektheitsbeweise - Rekursionen Algorithmus Sum(A,n) 1.If n=1 then return A[1] 2.else 3. W= Sum(A,n-1) 4. return A[n] + W Satz 6 Algorithmus Sum(A,n) berechnet die Summe der ersten n Einträge eines Feldes A. Beweis (Induktion über n): (I.A.) Ist n=1, so gibt der Algorithmus in Zeile 1 den Wert A[1] zurück. Dies ist korrekt. (I.V.) Für fest n-1>0 berechnet Sum(A,n-1) die Summe der ersten n-1 Einträge von A.

117 LS 2 / Informatik 117 Korrektheitsbeweise - Rekursionen Algorithmus Sum(A,n) 1.If n=1 then return A[1] 2.else 3. W= Sum(A,n-1) 4. return A[n] + W Satz 6 Algorithmus Sum(A,n) berechnet die Summe der ersten n Einträge eines Feldes A. Beweis (Induktion über n): (I.A.) Ist n=1, so gibt der Algorithmus in Zeile 1 den Wert A[1] zurück. Dies ist korrekt. (I.V.) Für fest n-1>0 berechnet Sum(A,n-1) die Summe der ersten n-1 Einträge von A. (I.S.) Wir betrachten den Aufruf von Sum(A,n).

118 LS 2 / Informatik 118 Korrektheitsbeweise - Rekursionen Algorithmus Sum(A,n) 1.If n=1 then return A[1] 2.else 3. W= Sum(A,n-1) 4. return A[n] + W Satz 6 Algorithmus Sum(A,n) berechnet die Summe der ersten n Einträge eines Feldes A. Beweis (Induktion über n): (I.A.) Ist n=1, so gibt der Algorithmus in Zeile 1 den Wert A[1] zurück. Dies ist korrekt. (I.V.) Für fest n-1>0 berechnet Sum(A,n-1) die Summe der ersten n-1 Einträge von A. (I.S.) Wir betrachten den Aufruf von Sum(A,n). Da n>1 ist, wird der else-Fall der ersten if-Anweisung aufgerufen. Dort wird W auf Sum(A,n-1) gesetzt.

119 LS 2 / Informatik 119 Korrektheitsbeweise - Rekursionen Algorithmus Sum(A,n) 1.If n=1 then return A[1] 2.else 3. W= Sum(A,n-1) 4. return A[n] + W Satz 6 Algorithmus Sum(A,n) berechnet die Summe der ersten n Einträge eines Feldes A. Beweis (Induktion über n): (I.A.) Ist n=1, so gibt der Algorithmus in Zeile 1 den Wert A[1] zurück. Dies ist korrekt. (I.V.) Für fest n-1>0 berechnet Sum(A,n-1) die Summe der ersten n-1 Einträge von A. (I.S.) Wir betrachten den Aufruf von Sum(A,n). Da n>1 ist, wird der else-Fall der ersten if-Anweisung aufgerufen. Dort wird W auf Sum(A,n-1) gesetzt. Nach I.V. ist dies die Summe der ersten n-1 Einträge von A.

120 LS 2 / Informatik 120 Korrektheitsbeweise - Rekursionen Algorithmus Sum(A,n) 1.If n=1 then return A[1] 2.else 3. W= Sum(A,n-1) 4. return A[n] + W Satz 6 Algorithmus Sum(A,n) berechnet die Summe der ersten n Einträge eines Feldes A. Beweis (Induktion über n): (I.A.) Ist n=1, so gibt der Algorithmus in Zeile 1 den Wert A[1] zurück. Dies ist korrekt. (I.V.) Für fest n-1>0 berechnet Sum(A,n-1) die Summe der ersten n-1 Einträge von A. (I.S.) Wir betrachten den Aufruf von Sum(A,n). Da n>1 ist, wird der else-Fall der ersten if-Anweisung aufgerufen. Dort wird W auf Sum(A,n-1) gesetzt. Nach I.V. ist dies die Summe der ersten n-1 Einträge von A. Nun wird in Zeile 4 A[n]+W, also die Summe der ersten n Einträge von A zurückgegeben.

121 LS 2 / Informatik 121 Korrektheitsbeweise - Rekursionen Algorithmus Sum(A,n) 1.If n=1 then return A[1] 2.else 3. W= Sum(A,n-1) 4. return A[n] + W Satz 6 Algorithmus Sum(A,n) berechnet die Summe der ersten n Einträge eines Feldes A. Beweis (Induktion über n): (I.A.) Ist n=1, so gibt der Algorithmus in Zeile 1 den Wert A[1] zurück. Dies ist korrekt. (I.V.) Für fest n-1>0 berechnet Sum(A,n-1) die Summe der ersten n-1 Einträge von A. (I.S.) Wir betrachten den Aufruf von Sum(A,n). Da n>1 ist, wird der else-Fall der ersten if-Anweisung aufgerufen. Dort wird W auf Sum(A,n-1) gesetzt. Nach I.V. ist dies die Summe der ersten n-1 Einträge von A. Nun wird in Zeile 4 A[n]+W, also die Summe der ersten n Einträge von A zurückgegeben.

122 LS 2 / Informatik 122 Zusammenfassung - Korrektheitsbeweise Grundannahme der Korrektheitsbeweise ist die korrekte Ausführung der Pseudocode Befehle Keine Schleifen: Schrittweises Nachvollziehen des Programms Schleifen: Korrektheit mittels Invarianten und Induktion Rekursion: Korrektheit mittels Induktion


Herunterladen ppt "LS 2 / Informatik Datenstrukturen, Algorithmen und Programmierung 2 (DAP2)"

Ähnliche Präsentationen


Google-Anzeigen