4. Fortgeschrittene Algorithmen 4.1 Rekursion 4.2 Daten und Datenstrukturen 4.3 Bäume

Transkript

1 4. Fortgeschrittene Algorithmen 4.1 Rekursion 4.2 Daten und Datenstrukturen 4.3 Bäume 4.1-1

2 4.1 Rekursion Ein Algorithmus heißt rekursiv, wenn er sich selbst aufruft. Meist werden nur einzelne Module eines Gesamtalgorithmus rekursiv verwendet. Klassisches Beispiel: Berechnung von n! (Fakultät von n) Definition: n! = 1*2*3*4*...*n oder: 1! = 1 n! = n*(n-1)!, n>1 Wir sehen: Die Berechnung von n! wird auf die Berechnung von (n-1)! zurück geführt, diese auf die Berechnung von (n-2)! usw

3 Rekursive Berechnung der Fakultät (1) Pseudocode Modul Fakultät (n) // Berechne die Fakultät von n für alle Ganzzahlen n mit n > 0 // d.h. n! = Fakultät (n) = 1 * 2 * 3 *...* n; z. B. Fakultät(4) = 24 Falls n = 1 dann Ergebnis ist 1 sonst multipliziere n mit Fakultät (n-1) 4.1-3

4 Rekursive Berechnung der Fakultät (2) Anmerkung: Die Berechnung von n! kann auch ohne Rekursion (iterativ) beschrieben werden. Allgemein gilt sogar: für jeden rekursiven Algorithmus gibt es einen gleich-wertigen iterativen Algorithmus. Rekursive Algorithmen sind aber häufig knapper und leichter zu verstehen

5 Vermeidung endloser Rekursion Die Definition des rekursiven Moduls muss einen Ausgang vorsehen, bei dem die Berechnung ohne erneuten Aufruf desselben Moduls erfolgt. Es muss sichergestellt sein, dass dieser Ausgang nach endlich vielen Modulaufrufen erreicht wird

6 Beispiel: Umkehrung einer Buchstabenfolge (1) Algorithmus Entferne ersten Buchstaben Kehre den Rest des Wortes um Hänge den ersten Buchstaben hinten an Modul Umkehrung(Buchstabenfolge) // Kehrt die Folge der Buchstaben eines gegebenen // Strings um Falls Buchstabenfolge enthält nur einen Buchstaben dann schreibe ihn nieder sonst entferne ersten Buchstaben von Buchstabenfolge Umkehrung(Rest der Buchstabenfolge) hänge entfernten Buchstaben hinten an 4.1-6

7 Beispiel: Umkehrung einer Buchstabenfolge (2) Kehre "GRAS" um 4.1-7

8 Beispiel: Umkehrung einer Buchstabenfolge (3) Anmerkung Die Rückkehr aus einem rekursiven Modul erfolgt stets an die Stelle, von der aus das Modul aufgerufen wurde

9 Berühmtes Beispiel: Die Türme von Hanoi (1) Das Problem Bringe 64 Scheiben von a (Quelle) nach b (Senke) unter Zuhilfenahme von c (Arbeitsbereich). Es darf niemals eine größere Scheibe über einer kleineren Scheibe liegen, und es darf immer nur eine Scheibe auf einmal bewegt werden

10 Beispiel: Die Türme von Hanoi (2) Schrittweise Verfeinerung 1. Übertrage die oberen 63 Scheiben von Stab a nach Stab c Bewege die unterste Scheibe von Stab a nach Stab b Übertrage die oberen 63 Scheiben von Stab c nach Stab b 2. Übertrage n-1 Scheiben von der Quelle zum Arbeitsbereich Bewege 1 Scheibe von der Quelle zur Senke Übertrage n - 1 Scheiben vom Arbeitsbereich zur Senke

11 Beispiel: Die Türme von Hanoi (3) Modul Turmbewegung(n, Quelle, Senke, Arbeitsbereich) // Bewegt einen Turm mit n Scheiben von Quelle zu Senke und benutzt den Arbeits- // bereich, falls erforderlich. Falls n = 1 dann bewege Scheibe von der Quelle zur Senke sonst Turmbewegung(n-1, Quelle, Arbeitsbereich, Senke) bewege 1 Scheibe von der Quelle zur Senke Turmbewegung(n-1, Arbeitsbereich, Senke, Quelle)

12 Beispiel: Die Türme von Hanoi (1) Falls 3 = 1 dann sonst übertrage 2 Scheiben von a nach c Falls 2 = 1 dann sonst übertrage 1 Scheiben von a nach b a b c Falls 1 = 1 dann bewege Scheibe von a nach b sonst Bewege Scheibe von a nach c Übertrage 1 Scheibe von b nach c Falls 1 = 1 dann bewege Scheibe von b nach c sonst Bewege Scheibe von a nach b Übertrage 2 Scheiben von c nach b Quelle Senke

13 Beispiel: Die Türme von Hanoi (2) Falls 2 = 1 dann sonst übertrage 1 Scheibe von c nach a a b c Falls 1 = 1 dann bewege Scheibe von c nach a sonst Bewege Scheibe von c nach b Übertrage 1 Scheibe von a nach b Falls 1 = 1 dann bewege Scheibe von a nach b sonst Quelle Senke Anmerkung Die Lösung des Problems "Türme von Hanoi" durch einen iterativen Algorithmus ist wenig elegant und schwerer zu verstehen

14 Strategie zum Entwurf rekursiver Algorithmen 1. Definiere Schritt i durch Rückgriff auf Schritt i-1, wobei Schritt i-1 ein "einfacheres" Problem löst. 2. Finde eine Ausstiegsbedingung zum Abbruch der Rekursion

15 Weiteres Beispiel: Rekursives Sortieren (1) Algorithmus Sortiere erste Hälfte der Liste Sortiere zweite Hälfte der Liste Mische beide Hälften zusammen (engl.: merge) Modul Sortiere (Liste) // Sortiert eine gegebene Liste von n Namen alphabetisch Falls n > 1 dann Sortiere (erste Listenhälfte) Sortiere (zweite Listenhälfte) Mische die zwei Hälften zusammen

16 Beispiel: Rekursives Sortieren (2)

17 Beweis von rekursiven Formeln Mathematische Formeln, die rekursiv definiert sind, werden meist durch Induktion bewiesen. Induktionsbasis: Formel ist korrekt für n = 1, n N Induktionsannahme: Formel sei korrekt für ein n 1, n N Schluss von n auf n+1: Berechnung des Formelwertes für n+1 unter Verwendung der Formel für n

18 Komplexität Bei rekursiver Berechnung ist die Komplexität eines Algorithmus oft wesentlich höher als bei geschlossenen Ausdrücken! Beispiel: Berechnen der Summe aller Zahlen von 1 bis n s(1) = 1, n = 1 s(n) = n + s(n-1), n > 1 erfordert n-1 Operationen. n(n+1) 2 erfordert drei Operationen für beliebig große n

19 Beweis der Korrektheit für die Türme von Hanoi (1) Behauptung Der Algorithmus Turmbewegung(n, Quelle, Senke, Arbeitsbereich) ist korrekt (tut das Gewünschte und terminiert). Beweis Behauptung 1: Turmbewegung tut das Gewünschte

20 Beweis der Korrektheit für die Türme von Hanoi (2) Beweis durch Induktion über die Anzahl der Scheiben n: Induktionsbasis: n = 1: klar Induktionsannahme: Der Algorithmus funktioniere für n Scheiben, n 1 Induktionsschluss: Algorithmus bewegt zunächst n Scheiben von der Quelle zum Arbeitsbereich (funktioniert nach Induktionsannahme), bewegt dann die n+1-te Scheibe zur Senke (funktioniert nach Induktionsbasis) und bewegt schließlich die n Scheiben vom Arbeitsbereich zur Senke (funktioniert nach Induktionsannahme)

21 Beweis der Korrektheit für die Türme von Hanoi (3) Behauptung 2: Turmbewegung terminiert Beweis: Da jeder Aufruf höchstens zwei neue Aufrufe erzeugen kann und bei jedem Aufruf weniger Scheiben bewegt werden, wird irgendwann der Algorithmus mit n = 1 aufgerufen

22 Rekursion in Java Wir werden uns jetzt näher mit der Rekursion in Java beschäftigen

23 Binomische Formel Aus der Schule bekannt: (a+b) 2 = a * a * b+b 2 (a+b) 3 = a * a 2 *b + 3 * a * b 2 + b 3 (a+b) n = Σn n k a n-k b k = a n n * a (n-k) *b k b n k heißt Binominalkoeffizient und ist definiert durch das Pascalsche Dreieck n k=0 n k k Pascalsches Dreieck n-1 k-1 + n k Bauprinzip n-1 k

24 Binomische Formel in BlueJ 2 rekursive Aufrufe Aufruf Parameter Resultat

25 Verfolgung des Codes Wir verfolgen die Berechnung von n!, indem wir diagnostische Ausgabe einbauen: static int fakultaet(int n){ if (n==0) return 1; else { System.out.println( ">>>fakultaet("+ n +")"); int result = fakultaet(n-1)*n; System.out.println( "<<< fakultaet("+ n +")="+result); return result; Wer zuletzt kommt, mahlt zuerst

26 Entfaltung der Berechnung Die Berechnung fakt(4) = = fakt(3) 4 int fakt(int n){ kann man als Aufrufbaum darstellen: if(n==0) return 1; else return fakt(n-1)*n; * * * 4 = * * 4 fakt(2) 3 * fakt(1) 2 * 3 * = * * 3 4 = * * 3 4 * 2 * 2 fakt(0)

27 Rekursion kann jede Schleife ersetzen Jede Schleife while(bedingung) {... tuwas();... lässt sich ersetzen durch einen Aufruf schleife(); wobei schleife() definiert ist durch void schleife(){ if(bedingung) {... tuwas();... schleife(); Ulam-Schleife int n = 17; while (n>1){ if (n mod 2==0) n=n/2; else n=3*n+1; Ulam - Rekursion void ulam(int n){ if (n>1){ if (n%2==0) n=n/2; else n=3*n+1; ulam(n); ulam(17);

28 Wechselseitige Rekursion Wenn zwei oder mehr Funktionen wechselseitig aufeinander Bezug nehmen, spricht man von wechselseitiger Rekursion boolean istgerade(int n){ if (n==0) return true; else return istungerade(n-1); boolean istungerade(int n){ if (n==0) return false; else return istgerade(n-1);

29 Das Spiel Zwei Spieler dürfen von einem Haufen von n Smarties abwechselnd 3, 7, oder 11 Smarties entfernen Wer nicht mehr ziehen kann, hat verloren. Wir beginnen mit n Smarties (z.b. n=137) Sie machen den ersten Zug Haben Sie eine Gewinnstrategie? Wie lautet diese ggf.? Schreiben Sie eine Java-Methode, um optimal zu spielen

30 Einer wird gewinnen Wenn ich am Zug bin Wenn n < 3 habe ich verloren Wenn Du am Zug bist Wenn n < 3 hast Du verloren Wenn Ich am Zug bin Wenn Du bei (n-3) verloren hast, kann ich gewinnen Wenn Du bei (n-7) verloren hast, kann ich gewinnen Wenn Du bei (n-11) verloren hast, kann ich gewinnen Wenn Du am Zug bist Wenn ich bei (n-3) verloren habe, kannst Du gewinnen Wenn ich bei (n-7) verloren habe, kannst Du gewinnen Wenn ich bei (n-11) verloren habe, kannst Du gewinnen Für die letzten beiden Punkte müssen natürlich mindestens noch 3, 7 bzw. 11 Smarties vorhanden sein

31 Erster Entwurf Funktion boolean iwin(int n) Soll genau dann true zurückliefern, wenn noch n Smarties auf dem Tisch liegen, ich am Zug bin, und es eine Gewinnstrategie gibt für mich. Funktion boolean youwin(int n) Analog für den Gegner Kann noch eleganter programmiert werden

32 Das Spiel Man käme sogar mit nur einer Funktion firstplayerwins aus, denn iwin und youwin stellen die gleiche Funktion dar!

33 Testen der Zugoptionen iwin(137) = true Ich kann also gewinnen Aber wie? Wir testen youwin(137-3) = true youwin(137-7) = true youwin(137-11)= false Wir schließen 11 Smarties wegnehmen ist der Siegeszug

34 Terminierung rekursiver Funktionen Damit eine rekursive Funktion t rekfunk(t 1 n 1,..., t k n k ){... rekfunk(e 1,...,e k )... terminiert, müssen die Parameterwerte e 1,..., e k des rekursiven Aufrufes einfacher sein als die Parameterwerte n 1,..., n k des ursprünglichen Aufrufs Was heißt einfacher? Es muss eine mathematische Funktion F : t 1... t k N geben mit F(n 1,...,n k ) > F(e 1,...,e k )

35 Beispiele int ggt(int m,int n){ if (m==n) return m; else if (m > n) return ggt(m-n,n); else return ggt(m,n-m); int fakt(int n){ if (n==0) return 1; else return fakt(n-1)*n; int fibo(int n){ if (n < 2) return 1; else return fibo(n-1)+fibo(n-2); int mccarthy(int n){ if (n > 100) return n-10; else return mccarthy(mccarthy(n+11)); F(m,n) = m+n F(n) = n F(n) = n Experimentieren Sie mit dieser Funktion Zeigen Sie, dass sie immer terminiert

36 Die Fibonacci-Folge (F n ) = 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89,... Bildungsgesetz: F 0 = 1, F 1 = 1, F n+1 =F n + F n-1 Anwendungen Natürliche Wachstumsprozesse Kaninchenvermehrung Blütenstände, Tannenzapfen Schneckenhäuser Die Fibonacci-Folge ist eng mit dem goldenen Schnitt verknüpft Populäres Thema im Internet, z.b. hier:

37 Effizienz Mit jeder Programmiermethodologie kann man ineffiziente Programme schreiben Anfängerfehler bei rekursiven Funktionen: Wiederberechnung bereits bekannter Werte int fibo(int n){ if (n < 2) return 1; else return fibo(n-2)+fibo(n-1); Dieser Aufruf muss fibo(n-2) erneut berechnen Aufrufbaum: fibo(4) fibo(2) fibo(3) fibo(0) fibo(1) fibo(1) fibo(2) fibo(0) fibo(1)

38 Effizienzsteigerung Iterative Version von fibo: static int fibonacci(int n){ int letzte=1, vorletzte = 1; for(int k=0; k<=n; k++){ {int temp = letzte; letzte = letzte+vorletzte; vorletzte = temp; return vorletzte; Zwei Hilfsvariablen: letzte, vorletzte letzte fibo(n+1) vorletzte fibo(n) In jedem Schritt: vorletzte letzte letzte letzte + vorletzte Da das nicht gleichzeitig geht, braucht man Hilfsvariable temp. fibo(n) : n letzte vorletzte

39 Rekursiv: effizient und klarer Rekursiv geht auch dies einfacher Vertauschen der Variablen bei der Parameterübergabe Keine Hilfsvariable benötigt Trick: Hilfsvariablen werden zu Parametern static int fibrek(int n, int k, int letzte, int vorletzte){ if(k==n) return vorletzte; else return fibrek(n, k+1,letzte+vorletzte, letzte); static int fibo(int n){ return fibrek(n,0,1,1); fibo(n) : n letzte vorletzte

40 Weitere Vereinfachung Wir können fibrek noch vereinfachen: In fibrek(n,k,...,...) wird k hochgezählt bis n. Stattdessen können wir n bis zu 0 hinunterzählen: static int fibrek(int n, int letzte, int vorletzte){ if(n==0) return vorletzte; else return fibrek(n-1, letzte+vorletzte, letzte); static int fibo(int n){ return fibrek(n,1,1); Wie können wir sicher sein, dass alles stimmt? Testen? Beweisen? n letzte vorletzte

41 Fazit Rekursion bedeutet Selbstbezüglichkeit. Die Rekursion stellt eine einfache und elegante Ausdrucksmöglichkeit für die Berechnung vieler Probleme dar. Sie ist grundsätzlich gleichwertig mit der Iteration (Schleife). Der Beweis der Korrektheit erfolgt durch Induktion