11. Rekursion, Komplexität von Algorithmen

Transkript

1 nwendung der Rekursion 11. Rekursion, Komplexität von lgorithmen Teil 2 Java-eispiele: Power1.java Hanoi.java Rekursiv definierte Funktionen - Fibonacci-Funktion - Fakultät, Potenz -... Rekursiver ufbau der zu verarbeitenden Daten - Programme (ENF)-> ompiler - äume und Listen (Teil III) Natürliche rekursive Problemlösungen - Sortierverfahren - Türme von Hanoi -... Version: 23. Nov Programmstruktur: rekursiv definiert nweisung Rekursiver ufbau von Daten: Syntax von Programmiersprachen nweisung nweisung nweisung if ( x > 1 ) x = y ; else { y = z ; z = 1 ; 3 4

2 eispiel: rekursiver ufbau der Daten ompiler: Parser (Syntaxanalyse) ENF: Eingabedaten für ompiler/parser? nweisung ::= uswahlanweisung lock... uswahlanweisung ::= if ( usdruck ) nweisung [ else nweisung ] lock ::= { nweisung... Parser: 1. testet, ob nweisung vorliegt 2. findet if-nweisung 3. testet im Innern der if-nweisung: liegen 1 (2) innere nweisungen vor rekursiver ufruf des Tests, ob nweisung anliegt Parser : testet in jedem Zustand, ob bestimmte Syntaxeinheit anliegt if ( x > 1 ) else { x = y ; y = z ; z = 1 ; 1. Ebene 2. Ebene Einzelheiten: ompilerbau lgorithmus: Test auf nweisung lock / Verbundanweisung 3. Ebene 1. Ebene: Einstieg in den lgorithmus ompiler muss rekursiv arbeiten 2. Ebene: 1. rekursiver ufruf (zwei mal) 3. Ebene: 2. rekursiver ufruf (in lock, zwei mal) 5 6 nwendung der Rekursion Rekursiv definierte Funktionen - Fibonacci-Funktion - Fakultät, Potenz -... Rekursiver ufbau der zu verarbeitenden Daten - Programme (ENF)-> ompiler - äume und Listen (Teil III) Rekursive Problemlösungen: Türme von Hanoi Natürliche rekursive Problemlösungen - Sortierverfahren (II.12) - Türme von Hanoi

3 ufgabe: Rekursive Problemlösungen: Türme von Hanoi Scheiben liegen der Größe nach geordnet auf einem Platz und sollen auf einen Platz unter Zuhilfenahme eines Platzes transportiert werden. Randbedingungen: - immer nur eine Scheibe bewegen (die obere) - niemals größere über einer kleineren Scheibe ufgabe (Fortsetzung) Gesucht: Folge von Einzelbewegungen, die zum Ziel führen % java Hanoi nzahl der Scheiben: 5 Scheibenbewegungen: von nach von nach von nach von nach 9 10 Lösungsalgorithmus: iterativ oder rekursiv? Rekursiver Lösungsalgorithmus Gesucht: Folge von Einzelbewegungen, die zum Ziel führen. 0 d. h. lgorithmus muss für wiederholte erechnung von Einzelschritten sorgen. 1 Iterativer lgorithmus? Möglich - aber: nicht naheliegend Solange (noch nicht am Ziel) erechne nächste ewegung Rekursiver lgorithmus? Natürliche Lösung des Problems: Zerlegung des Problems in einfachere Teilprobleme, die rekursiv bearbeitet werden bewege n Scheiben bewege n-1 Scheiben

4 Rekursiver Lösungsalgorithmus Rekursiver Lösungsalgorithmus 0 1 Problem: ewege n Scheiben zurückgeführt auf 3 Teilprobleme: ewege n-1 Scheiben ewege n Scheiben von start über hilfe nach ziel nfang: n = 1 (e i n e Scheibe) Transportiere die Scheibe direkt von start nach ziel 2 3 ewege 1 Scheibe ewege n-1 Scheiben Schritt: n > 1 1. ewege n - 1 Scheiben *) von start über ziel nach hilfe 2. Transportiere eine (größte) Scheibe direkt von start nach ziel 3. ewege n - 1 Scheiben *) von hilfe über start nach ziel *) ewege : Kein gleichzeitiger Transport von n -1 > 1 Scheiben! Sondern: nwendung des lgorithmus auf weniger als n Scheiben (Rekursivität) Hanoi-Programm: rekursiver lgorithmus Hanoi-Programm: Rahmen static void bewege (int n, char start, char hilfe, char ziel) { public static void main (String argv[]) { int n; if (n == 1) System.out.println(" von " + start + " nach " + ziel); else { bewege(n - 1, start, ziel, hilfe); System.out.println(" von " + start + " nach " + ziel); bewege(n - 1, hilfe, start, ziel); Gesamtproblem 3 Teilprobleme (mit 2 rekursiven ufrufen) System.out.print("nzahl der Scheiben: "); n = Keyboard.readInt(); Plätze durch Zeichen if (n > 0) { bezeichnet bewege(n,,, ); else System.out.println("Zahl nicht positiv"); 15 16

5 Hanoi-Programm: Rahmen Hanoi-Programm: Visualisierung public static void main (String argv[]) { int n; System.out.print("nzahl der Scheiben: "); n = Keyboard.readInt(); if (n > 0) { bewege(n,,, ); else System.out.println("Zahl nicht positiv"); % java Hanoi nzahl der Scheiben: 5 Scheibenbewegungen: von nach von nach von nach von nach % java Hanoi nzahl der Scheiben: 10 Scheibenbewegungen: von nach 1023 ewegungen..% java Hanoi nzahl der Scheiben: 100 ca. 10 Mrd. Scheibenbewegungen: ufrufbeziehungen: Hanoi bk.: bewege(5,,, ) = b(5,,, ) b(5,,, ) Überführung: Rekursion Iteration b(4,,, ) b(4,,, ) Warum? b(3,,, ) b(3,,, ) b(2,...) b(2,...) Rekursion: zeit- und speicheraufwendig (ufrufe von Methoden) Es gibt Programmiersprachen ohne Rekursion b(1,...) b(1,...)

6 Hanoi: rekursiv iterativ (mit bspeicherung von zu lösenden Problemen: Stack) Grundprinzip: In einem (Zyklus-)Schritt: Löse immer das aktuelle Problem und merke die später zu lösenden Probleme in einem Problemspeicher (Stack) Ein Problem: ewege n Scheiben von 'start' über 'hilfe' nach 'ziel' Im Problemspeicher (Stack / Stapel): das aktuelle Problem ist 'oben' gespeichert, die anderen Probleme liegen darunter lgorithmus: Wie? Solange noch Probleme zu lösen sind while (!isempty(problemstack)) { // bearbeite das aktuelle (oberste) Problem eispiel: 'Problem-Stack' bewege (5, '', '', ''); Stackentwicklung (Speicher aller zu lösenden Probleme): nfang: 1. Zyklusschritt: aktuelles Problem alle zu lösenden Probleme while (!isempty(problemstack)) { // bearbeite das aktuelle (oberste) Problem aktuelles Problem n = 1 drucken und Problem streichen n > 1 Problem streichen + speichere drei neue Probleme 21 n = 1 drucken und Problem streichen n > 1 Problem streichen + speichere drei neue Probleme 22 eispiel: 'Problem-Stack' bewege (5, '', '', ''); eispiel: 'Problem-Stack' bewege (5, '', '', ''); nfang: 1. Zyklusschritt: 2. Zyklusschritt: Stackentwicklung: Weitere Zyklusschritte? 3. Zyklusschritt: 4. Zyklusschritt: nfang: 1. Zyklusschritt: 2. Zyklusschritt: Stackentwicklung: Zyklusschritt: 4 * drucken und 4 Probleme streichen: 3. Zyklusschritt: 4. Zyklusschritt:

7 Modifizierte ufgabe: Modifiziertes Problem: Türme von Hanoi Scheiben liegen der Größe nach geordnet auf einem Platz und sollen auf einen Platz unter Zuhilfenahme eines Platzes transportiert werden. Randbedingungen: Idee? - immer nur eine Scheibe bewegen (die obere) - niemals größere über einer kleineren Scheibe - Transport nur zwischen Nachbarplätzen, d.h. verboten, nzahl der Scheibenbewegungen? Wertung: Rekursion lternative iterative Lösung immer möglich - weil alles in Maschinensprache ablaufen muss ohne Rekursion - Idee für iterative Lösung: natürliche rekursive Lösung Iterative Variante: oft schneller (Methodenaufrufe: zeitintensiv) Rekursive Lösung: oft lesbarer, eleganter aber zeit- und speicheraufwendig Rekursion: nicht um jeden Preis Nur wenn Lesbarkeit erhöht, anwenden auf : rekursive Funktionen rekursive Daten rekursive Problemlösungen Rekursive Lösung dort meist die einzige sinnvolle! Komplexitätsbetrachtungen von lgorithmen Warum? Komplexität von lgorithmen: Rechenaufwand Nicht: Komplexität von Programmen Unterschied? Oft wichtig: - Vor Entwicklung von Programmen: Lohnt sich die Entwicklung eines Programms überhaupt: rechnet Jahre - Vor Nutzung von Programmen: Welche Eingaben verkraftet das Programm bzgl. der Laufzeit? Programm: Größe/Länge des Programms lgorithmus: Laufzeit/erechnungsaufwand 27 28

8 eispiel: Welche Eingaben verkraftet das Hanoi-Programm? Dauer aller Scheibenbewegungen % java Hanoi nzahl der Scheiben: 1000 Scheibenbewegungen: von nach Wie viele usgaben (welche Zeit)? Scheiben ewegungen 1 31 ~ 1 Mrd. ~ Zahl mit 100 Nullen ei einer Scheibe pro Sekunde nzahl Scheiben enötigte Zeit 5 31 Sekunden 10 17,1 Minuten Tage Jahre Jahrhunderte 60 36,6 Milliarden Jahre Milliarden Jahre Falls schneller Rechner: 1 Mia ewegungen pro Sekunde 585 Jahre für 64 Scheiben! 1000 Scheiben? Komplexitätsbetrachtungen: H a n o i Komplexitätsbetrachtungen: H a n o i n n nzahl ewegungen ~ nzahl ewegungen ~ llgemein: anz(n) = 2 n - 1 llgemein: anz(n) = 2 n - 1 eweis: Vollständige Induktion eweis: Vollständige Induktion nfang: anz(1) = 2-1 = 1 (gilt nach dem lgorithmus) nfang: anz(1) = 2-1 = 1 (gilt nach dem lgorithmus) Schritt: anz(n+1) = 2 (n+1) - 1 = 2 * 2 n - 1 = 2 * (2 n -1) + 1 = 2 * anz(n) + 1 (nach Vor.) Damit gilt: für (n+1) wird die bisher ermittelte nzahl für n verdoppelt + 1 Gilt nach: Hanoi-lgorithmus -> siehe eschreibung des lgorithmus Schritt: anz(n+1) = 2 (n+1) - 1 = 2 * 2 n - 1 = 2 * (2 n -1) + 1 = 2 * anz(n) + 1 bewege(n (nach- 1, Vor.) start, ziel, hilfe); Transportiere eine Scheibe(start " nach ziel); bewege(n - 1, hilfe, start, ziel); Damit gilt: für (n+1) wird die bisher ermittelte nzahl für n verdoppelt + 1 Gilt nach: Hanoi-lgorithmus -> siehe eschreibung des lgorithmus 31 32

9 Teilgebiete der Informatik und ihre eziehungen Komplexitätstheorie: Theorie des erechnungsaufwands von lgorithmen Praktische Informatik: - Datenbanken - Software Engineering - Programmiersprachen - ompilerbau - etriebssysteme - Systemanalyse Technische Informatik: Theoretische Informatik: (Teilbereiche:) - lgorithmentheorie - erechnungstheorie - odierungstheorie - formale Sprachen - utomatentheorie - Komplexitätstheorie - Logik ngewandte Informatik: 33 Komplexität von lgorithmen Zusammenhang zwischen Größe der Eingabe n erechnungsaufwand O(n) eispiele: Exponent n bei power n n (power) n log 2 n (power1) nzahl n der Scheiben bei Hanoi n 2 n -1 nzahl n der Elemente beim Sortieren Multiplikationen usgabeoperationen (Scheibenbewegungen) nzahl: Vergleiche, Vertauschungen 34 Komplexitätsklassen von lgorithmen Komplexitätsklassen: Zusammenhänge lgorithmen heißen..., falls der Zusammenhang zwischen n und dem erechnungsaufwand O in dem angegebenen Verhältnis steht. konstant: O(n) = Konstante k Größe der Eingabe: n logarithmisch: (power1) linear: (power) n log 2 n: O(n) = k * log 2 n O(n) = k * n O(n) = k * n log 2 n erechnungsaufwand: nzahl der Operationen (z.. Multiplikationen, Scheibenbewegungen) O (n) quadratisch: O(n) = k * n 2 polynomiell: O(n) = k * n m (m>1) exponentiell: O(n) = k * 2 n (Hanoi) genauer Wert bei Hanoi: 2 n -1 kleinere Dimension bei O(n) weggelassen es kommt auf Größenordnung an 35 k k log 2 n? power1 k * n power k * 2 n Hanoi 36

10 Komplexitätsklassen: ausgewählte Werte Komplexitätsbetrachtungen n konstant logarithmisch (power1) linear (power) quadratisch Programmierung: Suche nach effizienten lgorithmen nicht jeder lgorithmus ist geeignet Lohnt sich die Entwicklung eines Programms überhaupt (rechnet Jahre)? Welche Eingaben verkraftet das Programm bzgl. der Laufzeit (vgl. Hanoi-Programm)? exponentiell (Hanoi) ~10 Mrd. ~ (Größere Dimension entscheidet, kleinere Dimension weggelassen) 37 38