2. Imperative Algorithmen 2.1 Variable, Anweisungen und Zustände 2.2 Felder 2.3 Komplexität von Algorithmen 2.4 Korrektheit von Algorithmen 2.5 Konzepte imperativer Sprachen 2.6 Rekursionen Paradigmen zur Algorithmenbeschreibung In einem imperativen Algorithmus gibt es Variable, die verschiedene Werte annehmen können. Die Menge aller Variablen und ihrer Werte sowie der Programmzähler beschreiben den Zustand zu einem bestimmten Zeitpunkt. Ein Algorithmus bewirkt eine Zustandstransformation. Ein funktionaler Algorithmus formuliert die Berechnung durch Funktionen. Die Funktionen können rekursiv sein; auch gibt es Funktionen höherer Ordnung. 2.1 Variable, Anweisungen und Zustände 2-1 Paradigmen zur Algorithmenbeschreibung In einem objektorientierten Algorithmus werden Datenstrukturen und Methoden zu einer Klasse zusammengefasst. Von jeder Klasse können Objekte gemäß der Datenstruktur erstellt und über die Methoden manipuliert werden. Ein logischer (deduktiver) Algorithmus führt Berechnungen durch, indem er aus Fakten und Regeln durch Ableitungen in einem logischem Kalkül weitere Fakten beweist. 2.1 Variable, Anweisungen und Zustände 2-2 Beispiel: Algorithmus von Euklid Der folgende, in einer imperativen Programmiersprache formulierte Algorithmus von Euklid berechnet den größten gemeinsamen Teiler der Zahlen x , y ∈ N mit x ≥ 0 und y > 0: a := x; b := y; while b do r := a := b := od # 0 a mod b; b; r Anschließend gilt a = ggT(x , y ). 2.1 Variable, Anweisungen und Zustände 2-3 Beispiel: Algorithmus von Euklid Variable r a b z2 – 36 52 z5 36 52 36 z8 16 36 16 z11 4 16 4 z14 0 4 0 ggT(36, 52) = 4 Durchlaufene Zustände: z0 , z1 , z2 , . . . , z14 Zustandstransformation: z0 #−→ z14 2.1 Variable, Anweisungen und Zustände 2-4 Imperative Konzepte ! Variable: Abstraktion eines Speicherbereichs, ein Wert eines gegebenen Datentyps kann gespeichert und beliebig oft gelesen werden, solange nicht ein neuer Wert gespeichert und der alte damit überschrieben wird. ! Zustand: Abstraktion des Speicherinhalts, Gesamtheit der momentanen Werte aller Variablen, ändert sich durch die Ausführung von Anweisungen. ! Anweisung: Vorschrift zur Ausführung einer Operation, ändert im Allgemeinen den Zustand. 2.1 Variable, Anweisungen und Zustände 2-5 Datentypen ! Datentyp: Die Zusammenfassung von Wertebereichen und Operationen zu einer Einheit. ! Abstrakter Datentyp: Schwerpunkt liegt auf den Eigenschaften, die die Operationen und Wertebereiche besitzen. ! Konkreter Datentyp: Beschreibt die Implementierung eines Datentyps. 2.1 Variable, Anweisungen und Zustände 2-6 Grundlegende Datentypen Oft werden mathematische Konzepte als Grundlage für einen Datentyp verwendet. Ein Datentyp besteht aus einem Wertebereich und einer Menge von Operationen. ! bool: die booleschen Werte „wahr“ und „falsch“ Operationen: logische Verknüpfungen, wie zum Beispiel „und“ und „oder“. ! int: ganze Zahlen, {minint, · · · , −1, 0, 1, · · · , maxint} ⊆ Z minint und maxint besitzen etwa den gleichen Betrag. Operationen: arithmetische und Vergleichsoperationen. Die Rechengesetze gelten in der Regel nicht, wenn man über die Darstellungsgrenzen gerät. 2.1 Variable, Anweisungen und Zustände 2-7 Grundlegende Datentypen ! real, float: Näherungswerte für reelle Zahlen, dargestellt durch Gleitpunktzahlen: r = m · be m∈Z Mantisse, b∈N Basis, e∈Z Exponent Die Darstellung erschließt den Zahlenbereich mit konstanter relativer Genauigkeit. Operationen: arithmetische und Vergleichsoperationen. Die Rechengesetze gelten im Allgemeinen nur näherungsweise. Gleitpunktzahlen sollten nicht auf Gleichheit überprüft werden, stattdessen sollte |x − y | < ε für einen kleinen Wert von ε getestet werden. 2.1 Variable, Anweisungen und Zustände 2-8 Grundlegende Datentypen ! char: Zeichen aus einem Alphabet Mit Vergleichsoperationen und den Funktionen ord : char → int und chr : int → char, die eine Zuordnung zwischen den Zeichen aus dem Alphabet und ganzen Zahlen herstellen. 2.1 Variable, Anweisungen und Zustände 2-9 Variable ! ! Variable x : t: Abstraktion eines Speicherplatzes und Zuordnung eines Datentyps X Menge der Variablen x:t x ∈X Typ von x t = τ(x ) v = σ(x ) Wert von x v ∈ W (t ) Wertemenge von t Deklaration: Ein Variablenname wird einem Speicherbereich und einem Typ zugeordnet. var i, j: int; var r: real; var c: char; 2.1 Variable, Anweisungen und Zustände 2-10 Zustand Ein Zustand bezeichnet die Belegung aller Variablen zu einem Zeitpunkt. ! Modellierung: σ : x1 #→ v1 , . . . , xn #→ vn xi ∈ X , vi ∈ W (ti ) ∀i ∈ {1, . . . , n} ! ! x1 · · · xn v1 · · · vn Mathematisch: Abbildung σ : X → W = {v1 , . . . , vn }, wobei σ(xi ) ∈ W (ti ) ∀i ∈ {1, . . . , n} Tabellarisch: σ(x ) ist die Belegung der Variablen x im Zustand σ. 2.1 Variable, Anweisungen und Zustände 2-11 Zuweisung ! ! Syntax: x ← v v ∈ W (τ(x )) Zuweisung, Grundbaustein: Nach Ausführung der Zuweisung gilt σ(x ) = v . Ist σ : X → W ein Zustand und wählt man eine Variable x ∈ X sowie einen Wert v vom passenden Typ, so ist der transformierte Zustand σ<x ←v > wie folgt definiert: σ<x ←v > (y ) = 2.1 Variable, Anweisungen und Zustände ! v σ(y ) falls x = y sonst 2-12 Semantik Die Semantik beschreibt die Bedeutung eines Algorithmus. Sie ist eine (partielle) Funktion, die jeder Anweisung eine Zustandsänderung zuordnet: [ ] : A → ((X → W ) → (X → W )) mit [a ](σ) = σ" Semantik einer Zuweisung: [x ← v ](σ) = σ<x ←v > 2.1 Variable, Anweisungen und Zustände 2-13 Ausdrücke/Terme Beispiele für Ausdrücke: ! Konstante: 3, 2.7182, " A " ! Variable: x1 , x2 , y ! Operatoren und Funktionsaufrufe: x1 + 3, f (x1 ) ! Zusammengesetzte Ausdrücke: f (x1 + 3) − 2.7182 + y Falls ein Ausdruck t die Variablen x1 , . . . , xn enthält, schreiben wir t (x1 , . . . , xn ). Beispiel eines booleschen Ausdrucks: x ≤ 5 ∧ y < 4 2.1 Variable, Anweisungen und Zustände 2-14 Wert eines Ausdrucks Die Auswertung von Ausdrücken mit Variablen ist zustandsabhängig. An die Stelle der Variablen wird ihr aktueller Wert gesetzt. Beispiel: Für den Ausdruck 2 · x + 1 ist sein Wert im Zustand σ durch 2σ(x ) + 1 gegeben. Der so bestimmte Wert des Ausdrucks t (x1 , . . . , xn ) im Zustand σ wird mit σ(t (x1 , . . . , xn )) bezeichnet. Beispiel: σ(2 · x + 1) = 2σ(x ) + 1 2.1 Variable, Anweisungen und Zustände 2-15 Zuweisungen Diese Festlegung erlaubt Wertzuweisungen mit Ausdrücken auf der rechten Seite y ← t ( x 1 , . . . , xn ) Der transformierte Zustand hierfür ist wie folgt definiert: [y ← t (x1 , . . . , xn )](σ) = σ<y ←σ(t (x1 ,...,xn ))> 2.1 Variable, Anweisungen und Zustände 2-16 Zuweisungen Beispiel: Semantik der Zuweisung x ←2·x +1 Transformation: [x ← 2 · x + 1](σ) = σ<x ←2·σ(x )+1> Hier handelt es sich nicht um eine rekursive Gleichung für x , da auf der rechten Seite der „alte“ Wert von x benutzt wird. Wertzuweisungen sind die einzigen elementaren Anweisungen imperativer Algorithmen. Aus ihnen werden zusammengesetzte Anweisungen gebildet, aus denen imperative Algorithmen bestehen. 2.1 Variable, Anweisungen und Zustände 2-17 Zusammengesetzte Anweisungen Elementare Anweisungen können auf unterschiedliche Arten zu komplexen Anweisungen zusammengesetzt werden: 1. sequenzielle Ausführung, 2. bedingte Ausführung, 3. wiederholte Ausführung, 4. Ausführung als Unterprogramm, 5. rekursive Ausführung eines Unterprogramms. Diese Möglichkeiten werden als Kontrollstrukturen bezeichnet. Wir betrachten jetzt die ersten drei dieser zusammengesetzten Anweisungen. Auf die anderen kommen wir am Schluss des Kapitels zu sprechen. 2.1 Variable, Anweisungen und Zustände 2-18 Sequenzielle Ausführung von Anweisungen ! Definition: Sind a1 und a2 Anweisungen, so auch a1 ; a2 ! Informelle Bedeutung: „Führe erst a1 , dann a2 aus.“ ! Semantik: [a1 ; a2 ](σ) = [a2 ]([a1 ](σ)) ! Darstellung im Flussdiagramm: 2.1 Variable, Anweisungen und Zustände 2-19 Bedingte Ausführung von Anweisungen ! Definition: Sind a1 und a2 Anweisungen und P ein boolescher Ausdruck, so ist auch if P then a1 else a2 fi eine Anweisung. ! Voraussetzung: σ(P ) kann ausgewertet werden (ansonsten ist die Anweisung undefiniert) ! Informelle Bedeutung: „Falls P gilt, führe a1 aus, sonst a2 .“ 2.1 Variable, Anweisungen und Zustände 2-20 Bedingte Ausführung von Anweisungen ! ! Sematik: [a1 ](σ) falls σ(P ) = true [ if P then a1 else a2 fi ](σ) = [a2 ](σ) falls σ(P ) = false Darstellung im Flussdiagramm: 2.1 Variable, Anweisungen und Zustände 2-21 Wiederholte Ausführung von Anweisungen ! Definition: Ist a eine Anweisung und P ein boolescher Ausdruck, so ist auch while P do a od eine Anweisung. ! Voraussetzung: σ(P ) kann ausgewertet werden (ansonsten ist die Anweisung undefiniert) ! Informelle Bedeutung: „Solange P gilt, führe a aus.“ 2.1 Variable, Anweisungen und Zustände 2-22 Wiederholte Ausführung von Anweisungen ! Semantik: [ while P do a od ](σ) = falls σ(P ) = false σ [ while P do a od ]([a ](σ)) sonst ! Diese Definition ist rekursiv. While-Schleifen müssen nicht terminieren. Darstellung im Flussdiagramm: 2.1 Variable, Anweisungen und Zustände 2-23 Flussdiagramme Normierte Methode (DIN 66001) zur Darstellung von Programmen ! Beginn: ! Ende: ! Elementare Anweisung: ! Entscheidung durch booleschen Ausdruck: ! Eingabe nach n: ! Ausgabe von p: 2.1 Variable, Anweisungen und Zustände 2-24 Konkrete Umsetzung ! Sprachen mit nur diesen Anweisungen sind bereits berechnungsuniversell. ! In existierenden Programmiersprachen gibt es fast immer diese Anweisungen, oft jedoch mehr. Beispiel: case- oder repeat-Anweisung. ! Schlüsselwörter und Syntax der Kontrollstrukturen variieren von Sprache zu Sprache. Beispiel: end if statt fi. ! Hierarchische Struktur der Anweisungen: Anweisungen können Bestandteil anderer Anweisungen sein. 2.1 Variable, Anweisungen und Zustände 2-25 Imperative Algorithmen ! Es werden die Datentypen int, real und bool verwendet. ! Aufbau imperativer Algorithmen (Syntax): <Programmname> var x ,y ,. . . : int ; p ,q: bool ; input : x1 , . . . , xn ; a; output : y1 , . . . , ym ! Variablendeklarationen Eingabevariablen Anweisung(en) Ausgabevariablen Die Semantik wird durch eine Zustandsüberführungsfunktion beschrieben. 2.1 Variable, Anweisungen und Zustände 2-26 Imperative Algorithmen Die Semantik eines imperativen Algorithmus ist eine partielle Funktion [PROG ] : W1 × · · · × Wn → V1 × · · · × Vm [PROG ](w1 , . . . , wn ) = (σ(y1 ), . . . , σ(ym )) σ = [a ](σ0 ) σ0 (xi ) = wi ∈ Wi für i = 1, . . . , n wobei PROG: <Programmname> Wi : Wertebereich des Typs von xi , für i = 1, . . . , n Vj : Wertebereich des Typs von yj , für j = 1, . . . , m 2.1 Variable, Anweisungen und Zustände 2-27 Imperative Algorithmen ! Der Algorithmus legt eine Zustandstransformation fest. Die Eingabe befindet sich im Zustand σ0 . ! Die Ausführung imperativer Algorithmen besteht aus einer Abfolge von Zuweisungen. Diese Folge wird mittels „Sequenz“, „bedingter Ausführung“ und „wiederholter Ausführung“ aus den Zuweisungen gebildet. ! Jede Zuweisung definiert eine Transformation des Zustands. Die Semantik des Algorithmus ist durch die Kombination all dieser Zustandstransformationen festgelegt. ! Falls die Auswertung von a nicht terminiert, ist die Funktion [PROG ] nicht definiert. 2.1 Variable, Anweisungen und Zustände 2-28 Algorithmus von Euklid Der Algorithmus von Euklid lautet in dieser Notation: EUKLID var a, b, r, x, y: int; input x, y; a ← x; b ← y; while b # 0 do r ← a mod b; a ← b; b ← r; od; output a; 2.1 Variable, Anweisungen und Zustände 2-29 Fakultätsfunktion FAK k! = 1 · 2 · 3 · · · k var x, y: int; input x; y ← 1; while x > 1 do y ← y * x; x ← x - 1; od; output y; Es gilt: [FAK ](w ) = ! w ! für w > 0 1 2.1 Variable, Anweisungen und Zustände sonst 2-30 Auswertung der Fakultätsfunktion ! ! Signatur der Semantikfuntion: [FAK ] : int → int Das Ergebnis der Berechnung ist die Belegung der Variablen y im Endzustand: σ(y ). ! Der Endzustand σ ist laut Definition σ = [a ](σ0 ), wobei a die Folge aller Anweisungen des Algorithmus ist. ! σ0 ist der Startzustand. Die Eingabe befindet sich in σ0 (x ). ! Da nur die zwei Variablen x und y auftreten, können wir einen Zustand σ als Paar (σ(x ), σ(y )) schreiben. ! ⊥ bedeutet, dass der Wert der Variablen keine Rolle spielt bzw. undefiniert ist. 2.1 Variable, Anweisungen und Zustände 2-31 Auswertung der Fakultätsfunktion Gesucht: [FAK ](3) σ = [a ](σ0 ) = [a ](3, ⊥) = [y ← 1; while x > 1 do y ← y ∗ x ; x ← x − 1 od ](3, ⊥) = [ while x > 1 do y ← y ∗ x ; x ← x − 1 od ]([y ← 1](3, ⊥)) =: [ while B do β od ]([y ← 1](3, ⊥)) = [ while B do β od ](3, 1) ! falls σ(B ) = false σ = [ while B do β od ]([β](σ)) sonst ! (3, 1) falls σ(x > 1) = false = [ while B do β od ]([y ← y ∗ x ; x ← x − 1](σ)) sonst 2.1 Variable, Anweisungen und Zustände 2-32 Auswertung der Fakultätsfunktion · · · = [ while B do β od ]([y ← y ∗ x ; x ← x − 1](3, 1)) = [ while B do β od ]([x ← x − 1]([y ← y ∗ x ](3, 1))) = [ while B do β od ]([x ← x − 1](3, 3)) = [ while B do β od ](2, 3) = [ while B do β od ]([y ← y ∗ x ; x ← x − 1](2, 3)) = [ while B do β od ](1, 6) ! falls σ(x > 1) = false (1, 6) = [ while B do β od ]([y ← y ∗ x ; x ← x − 1](1, 6)) sonst = (1, 6) [FAK](3) = 6 2.1 Variable, Anweisungen und Zustände 2-33 Fibonacci-Zahlen (iterativ) f0 = 0, f1 = 1, fn = fn−1 + fn−2 , n > 1 FIB: var x,a,b,c: int; input x; a ← 0; b ← 1; while x > 0 do c ← a + b; a ← b; b ← c; x ← x - 1; od; output a; [FIB ](x ) = 2.1 Variable, Anweisungen und Zustände ! die x -te Fibonacci-Zahl, falls x > 0, 0, sonst. 2-34 Fibonacci-Zahlen (rekursiv) Einzelheiten zu rekursiven Programmen werden später behandelt! f0 = 0, f1 = 1, fn = fn−1 + fn−2 , n > 1 FIB: var n, x: int; input n; if n = 0 then x ← 0 fi; if n = 1 then x ← 1 fi; if n > 1 then x ← FIB(n - 1) + FIB(n - 2) fi; output x; Ein rekursiv ausgedrückter Algorithmus ist häufig eleganter als sein iteratives Äquivalent. Nachteil ist evtl. eine längere Laufzeit. 2.1 Variable, Anweisungen und Zustände 2-35 Felder ! Definition: Ein Feld ist eine indizierte Menge von Variablen des gleichen Typs. Felder sind generische Datentypen. ! Deklaration: var x[I]: T; var coords[1..3]: real; var str[0..4095]: char; ! Indexmenge: I endlich, häufig I ⊆ N, aber andere Indexmengen sind möglich. ! Zugriff: x [i ] sowohl lesend als auch schreibend, wobei i ∈ I. Längenänderungen von Feldern sind nicht in allen Programmiersprachen möglich. Felder werden auch als Arrays bezeichnet. 2.2 Felder 2-36 Verbreitete Spezialfälle von Feldern ! Vektor: var v[1..3]: real; ! Matrix: var v[1..4, 1..4]: real; ! Strings: var str[0..102]: char; 2.2 Felder 2-37 For-Schleife Die For-Schleife ist eine weitere Kontrollstruktur zur Wiederholung von Anweisungen. Es seien j , k ∈ N Konstante, var i : int eine Variable und a eine Anweisung. for i ← j to k do a; od entspricht i ← j; while i ≤ k do a; i ← i + 1; od i wird Laufvariable der Schleife genannt. Viele Programmiersprachen enthalten Varianten dieser Schleife. 2.2 Felder 2-38 Maximale Summe eines Teilfelds Die folgenden Programme berechnen die maximale Summe aufeinanderfolgender Zahlen in einem Feld var x [1..n] : int . j & m = max x [ k ] | 1 ≤ i ≤ j ≤ n k =i x sei das Feld: 2 3 4 5 6 7 8 9 10 1 31 −41 59 26 −53 58 97 −93 −23 84 Die maximale Summe aufeinanderfolgender Zahlen ist x [3] + x [4] + x [5] + x [6] + x [7] = 187. Keine andere Summe besitzt einen höheren Wert. Beispielsweise ist x [1] + x [2] + x [3] + x [4] = 75. 2.2 Felder 2-39 Maximale Summe eines Teilfelds Idee: Berechne alle möglichen Summen. MaxSum1 var x[1..n]: int; var i,j,k,s,m: int; input x; m ← 0; // Wert der leeren Summe for i ← 1 to n do for j ← i to n do s ← 0; for k ← i to j do s ← s + x[k]; od; m ← max(m, s); od; od; output m; Dieser Algorithmus enthält drei ineinandergeschachtelte Schleifen. 2.2 Felder 2-40 Maximale Summe eines Teilfelds Idee: Einsparen der inneren Schleife durch Wiederverwenden bereits bekannter Summen. MaxSum2 var x[1..n]: int; var i,j,s,m: int; input x; m ← 0; // Wert der leeren Summe for i ← 1 to n do s ← x[i]; m ← max(m, s); for j = i+1 to n do s ← s + x[j]; m ← max(m, s); od; od; output m; Dieser Algorithmus besitzt zwei ineinandergeschachtelte Schleifen. 2.2 Felder 2-41 Maximale Summe eines Teilfelds Idee: Genau überlegen, was eine hohe Summe ausmacht. Diese Lösung stammt von M. Shamos (1977). MaxSum3 var x[1..n]: int; var i,s,m: int; input x; m ← 0; s ← 0; for i ← 1 to n do s ← max(0, s + x[i]); m ← max(m, s); od; output m; Dieser Algorithmus hat nur noch eine Schleife. 2.2 Felder 2-42 Einführung ! In der Regel lässt sich ein Problem durch verschiedene Algorithmen lösen (zum Beispiel „maximale Summe aufeinanderfolgender Elemente“). ! Welcher Algorithmus soll gewählt werden? ! Die Algorithmen müssen hinsichtlich ihres Verhaltens verglichen werden. ! Man benötigt ein Maß für den Aufwand eines Algorithmus. 2.3 Komplexität von Algorithmen 2-43 Komplexität von Algorithmen und Problemen ! Unter der Komplexität eines Algorithmus versteht man den Aufwand, den der Algorithmus zur Lösung des Problems benötigt. Typischerweise ist hier die ! ! Laufzeit des Algorithmus oder der Speicherbedarf des Algorithmus gemeint. Man unterscheidet die ! ! ! ! Komplexität im günstigsten Fall (best-case), die Komplexität im mittleren Fall (average-case) und die Komplexität im ungünstigsten Fall (worst-case). Unter der Komplexität eines Problems versteht man die Komplexität des besten Algorithmus zur Lösung des Problems im ungünstigsten Fall. 2.3 Komplexität von Algorithmen 2-44 Komplexität eines Algorithmus ! Umfang n eines Problems: „Anzahl der Eingabewerte“ oder „Größe der Eingabewerte“ oder . . . ! Aufwand T (n) eines Algorithmus: „Anzahl der Schritte“ oder „Anzahl bestimmter Operationen“ oder „Anzahl der benötigten Speicherplätze“ oder . . . , die der Algorithmus braucht, um ein Problem vom Umfang n zu lösen. Um sinnvolle Aussagen über die Komplexität eines Algorithmus zu treffen, müssen n und T (n) mit Bedacht gewählt werden. Beispiel: Im Algorithmus „Sortieren durch Einfügen“ war n die Anzahl der zu sortierenden Zahlen und T (n) die Anzahl der benötigten Vergleiche. 2.3 Komplexität von Algorithmen 2-45 Wachstum von Funktionen ! In der Regel stellt die Wachstumsrate der Laufzeit ein einfaches und geeignetes Kriterium zur Messung der Effizienz eines Algorithmus dar. ! Die Wachstumsrate erlaubt es uns, die relative Leistungsfähigkeit alternativer Algorithmen zu vergleichen. ! Die Wachstumsrate von Algorithmen wird meistens mithilfe der asymptotischen Notation angegeben. ! Die asymptotische Notation lässt konstante Faktoren unberücksichtigt. 2.3 Komplexität von Algorithmen 2-46 Asymptotische Notation Es sei eine Funktion g : N −→ R gegeben. Θ(g ) = {f : N −→ R | ∃c1 > 0, c2 > 0, n0 > 0 ∀n ≥ n0 . 0 ≤ c1 g (n) ≤ f (n) ≤ c2 g (n)} O (g ) = {f : N −→ R | ∃c > 0, n0 > 0 ∀n ≥ n0 . 0 ≤ f (n) ≤ cg (n)} Ω(g ) = {f : N −→ R | ∃c > 0, n0 > 0 ∀n ≥ n0 . 0 ≤ cg (n) ≤ f (n)} o (g ) = {f : N −→ R | ∀c > 0 ∃n0 > 0 ∀n ≥ n0 . 0 ≤ f (n) < cg (n)} ω(g ) = {f : N −→ R | ∀c > 0 ∃n0 > 0 ∀n ≥ n0 . 0 ≤ cg (n) < f (n)} 2.3 Komplexität von Algorithmen 2-47 Gebräuchliche Wachstumsklassen Θ(1) Θ(log(n)) Θ(n) Θ(n log(n)) Θ(n2 ) Θ(nk ) Θ(2n ) konstantes Wachstum logarithmisches Wachstum lineares Wachstum „fast lineares“ Wachstum quadratisches Wachstum polynomiales Wachstum exponentielles Wachstum O (n 2 ) Ω(n) höchstens quadratisches Wachstum mindestens lineares Wachstum Beispiel: Die Laufzeit beim „Sortieren durch Einfügen“ beträgt im günstigsten Fall Θ(n) und im ungünstigsten Falls Θ(n 2 ). Die Laufzeit kann also durch Ω(n) nach unten und durch O (n 2 ) nach oben abgeschätzt werden. Die Laufzeit wird auch durch O (n 3 ) nach oben abgeschätzt! In der Praxis werden häufig möglichst scharfe obere Schranken gesucht. 2.3 Komplexität von Algorithmen 2-48 Graphen einiger Funktionen 2.3 Komplexität von Algorithmen 2-49 Graphen einiger Funktionen 2.3 Komplexität von Algorithmen 2-50 Exemplarische Werte n= log2 (n) ≈ n log2 (n) ≈ n2 = 2n ≈ 1 0 0 1 2 10 3 33 100 103 100 7 664 10000 1030 1000 10 9966 1000000 10301 10000 13 132877 100000000 103010 Maximales n bei gegebener Zeit, Ann.: 1 Schritt benötigt 1µs n n2 n3 2n 1 Min. 1 Std. 1 Tag 1 Woche 1 Jahr 6 · 107 7750 391 25 3.6 · 109 6 · 104 1530 31 8.6 · 1010 2.9 · 105 4420 36 6 · 1011 7.9 · 105 8450 39 3 · 1013 5.6 · 106 31600 44 2.3 Komplexität von Algorithmen 2-51 Asymptotische Notationen in Gleichungen ! 2n2 + 3n + 1 = Θ(n2 ) heißt 2n2 + 3n + 1 ∈ Θ(n2 ). ! 2n2 + 3n + 1 = 2n2 + Θ(n) heißt: Es gibt eine Funktion f (n) ∈ Θ(n) mit 2n 2 + 3n + 1 = 2n2 + f (n). ! 2n2 + Θ(n) = Θ(n2 ) heißt: Für jede Funktion f (n) ∈ Θ(n) gibt es eine Funktion g (n) ∈ Θ(n 2 ) mit 2n2 + f (n) = g (n). ! In Gleichungsketten 2n2 + 3n + 1 = 2n2 + Θ(n) = Θ(n2 ) werden die Gleichungen einzeln gelesen: Die erste Gleichung besagt, dass es eine Funktion f (n) ∈ Θ(n) mit 2n2 + 3n + 1 = 2n2 + f (n) gibt. Die zweite Gleichung sagt aus, dass es für jede Funktion g (n) ∈ Θ(n) eine Funktion h (n) ∈ Θ(n2 ) mit 2n2 + g (n) = h (n) gibt. Aus der Hintereinanderausführung folgt 2n 2 + 3n + 1 = Θ(n2 ). 2.3 Komplexität von Algorithmen 2-52 Eigenschaften der asymptotischen Notation Eine Funktion f : N −→ R heißt asymptotisch positiv, wenn gilt: ∃n0 > 0 ∀n ≥ n0 . f (n) > 0. Für alle asymptotisch positiven Funktionen f , g : N −→ R gelten die folgenden Aussagen. Transitivität: f (n) = Θ(g (n)) ∧ g (n) = Θ(h (n)) =⇒ f (n) = Θ(h (n)), f (n) = O (g (n)) ∧ g (n) = O (h (n)) =⇒ f (n) = O (h (n)), f (n) = Ω(g (n)) ∧ g (n) = Ω(h (n)) =⇒ f (n) = Ω(h (n)), f (n) = o (g (n)) ∧ g (n) = o (h (n)) =⇒ f (n) = o (h (n)), f (n) = ω(g (n)) ∧ g (n) = ω(h (n)) =⇒ f (n) = ω(h (n)). 2.3 Komplexität von Algorithmen 2-53 Eigenschaften der asymptotischen Notation Reflexivität: f (n) = Θ(f (n)), f (n) = O (f (n)), f (n) = Ω(f (n)). Symmetrie: f (n) = Θ(g (n)) ⇐⇒ g (n) = Θ(f (n)). Austausch-Symmetrie: f (n) = Θ(g (n)) ⇐⇒ f (n) = O (g (n)) ∧ f (n) = Ω(g (n)), f (n) = O (g (n)) ⇐⇒ g (n) = Ω(f (n)), f (n) = o (g (n)) ⇐⇒ g (n) = ω(f (n)). Θ, O , Ω, o und ω werden landausche Symbole genannt. 2.3 Komplexität von Algorithmen 2-54 Beispiele 8 = Θ(1) 3n2 − 5n + 8 = Θ(n2 ) 3n2 − 5n + 8 = O (n2 ) 3n2 − 5n + 8 = Ω(n2 ) logb (n) loga (n) = logb (a ) Θ(loga (n)) = Θ(logb (n)) 12 log10 (n) = Θ(log(n)) 12 log2 (n) = Θ(log(n)) 2.3 Komplexität von Algorithmen 2-55 Laufzeit von imperativen Algorithmen Folgende Annahmen werden zur Analyse der Laufzeit von imperativen Algorithmen getroffen: ! Zuweisung: Die Laufzeit ist konstant. ! Sequenz: Die Laufzeit ist die Summe der Laufzeiten der Einzelanweisungen. ! Alternative: Die Laufzeit ist im ungünstigsten Fall die Laufzeit der Bedingungsauswertung plus dem Maximum der Laufzeiten der Alternativen. ! Iteration: Die Laufzeit errechnet sich aus dem Produkt der Laufzeit der inneren Anweisung und der Anzahl der Iterationen. Hinzu kommt die Laufzeit für einen weiteren Test. 2.3 Komplexität von Algorithmen 2-56 Sortieren durch Einfügen Code Kosten insertionSort(A) j ← 2; c1 while j ≤ length(A) do c2 key ← A;[j] c3 i ← j - 1; c4 while i > 0 und A[i] > key c5 do c6 A[i + 1] ← A[i]; c7 i ← i - 1; od; A[i + 1] ← key; c8 j ← j + 1; c9 od; 2.3 Komplexität von Algorithmen Anzahl 1 n n−1 n−1 *n j =2 tj , *n + j =2 +tj − 1, *n j =2 tj − 1 n−1 n−1 2-57 Abschätzung durch die O-Notation Code Kosten insertionSort(A) j ← 2; O (1) O (n ) while j ≤ length(A) do key ← A[j]; O (n ) i ← j - 1; O (n ) while i > 0 und A[i] > key; O (n 2 ) do O (n 2 ) A[i + 1] ← A[i]; i ← i - 1; O (n 2 ) od; A[i + 1] ← key; O (n ) j ← j + 1; O (n ) od; Die Laufzeit T (n) liegt in O (n 2 ), d. h. T (n) = O (n 2 ). 2.3 Komplexität von Algorithmen 2-58 Korrektheit von Softwaresystemen In vielen Situationen ist eine korrekte Funktionsweise eines Softwaresystems von großer Bedeutung. Dies gilt insbesondere, wenn das System ! sicherheitskritisch (z. B. Atomreaktor), ! kommerziell kritisch (z. B. massenproduzierte Chips) oder ! politisch kritisch (z. B. Militär) ist. 2.4 Korrektheit von Algorithmen 2-59 Korrektheit von Softwaresystemen Es gibt mehrere Möglichkeiten, die Zuverlässigkeit von Softwaresystemen zu erhöhen: ! Software Engineering: Maßnahmen während des gesamten Softwareentwicklungsprozesses. ! Programmierung: Beispiel: Ausnahmebehandlung, Zusicherungen. ! Validation: Systematische Tests unter Einsatzbedingungen; Tests zeigen die Anwesenheit, aber nicht die Abwesenheit von Fehlern. ! Verifikation: Mathematischer Nachweis der Korrektheit von Algorithmen. 2.4 Korrektheit von Algorithmen 2-60 Korrektheit von Softwaresystemen Um ein System zu verifizieren zu können benötigt man Methoden, Werkzeuge und Sprachen, zur ! Modellierung von Systemen auf hoher Abstraktionsebene, ! Spezifikation nachzuweisender Eigenschaften dieser Systeme (Terminierungsverhalten, berechnete Funktionswerte, . . . ) und zur ! Verifikation, d. h. zum formalen Beweis, dass ein implementiertes System die spezifizierten Eigenschaften hat. In diesem Abschnitt behandeln wir eine Möglichkeit zur Spezifikation und Verifikation imperativer Algorithmen. 2.4 Korrektheit von Algorithmen 2-61 Hoaresche Logik Es seien ein Algorithmus S sowie Bedingungen p und q gegeben. ! Wir schreiben in diesem Fall {p} S {q} und nennen ! p Vorbedingung, ! q Nachbedingung und ! (p,q) Spezifikation von S. 2.4 Korrektheit von Algorithmen 2-62 Hoaresche Logik ! S heißt partiell-korrekt bezüglich der Spezifikation (p,q), wenn jede Ausführung von S, die in einem Zustand beginnt, der p erfüllt und die terminiert, zu einem Zustand führt, der q erfüllt. |= {p} S {q} ! S wird total-korrekt bezüglich der Spezifikation (p,q) genannt, wenn jede Ausführung von S, die in einem Zustand beginnt, der p erfüllt, terminiert und zu einem Zustand führt, der q erfüllt. 2.4 Korrektheit von Algorithmen 2-63 Beispiele ! ! ! ! ! ! ! ! ! ! |= {true }x ← 1{x = 1} |= {x = 1}x ← x + 1{x = 2} |= {y = a }x ← y {x = a ∧ y = a } |= {x = a ∧ y = b }z ← x ; x ← y ; y ← z {x = b ∧ y = a } |= {false }x ← 1{x = 42} |= {true } while 0 = 0 do x ← 1 od {x = 23} |= {x > 0} while x ! 0 do x ← x − 1 od {x = 0} |= {true } while x ! 0 do x ← x − 1 od {x = 0} |= {true } while p (x ) do α od {¬p (x )} |= {x + y = a } while x ! 0 do x ← x − 1; y ← y + 1 od {x = 0 ∧ x + y = a} 2.4 Korrektheit von Algorithmen 2-64 Hoarescher Kalkül Zuweisung: Sequenz: If: While: Anpassungsregel: 2.4 Korrektheit von Algorithmen {pxt } x ← t {p } {p } S1 {r }, {r } S2 {q} {p } S1 ; S2 {q} {p ∧ e } S1 {q}, {p ∧ ¬e } S2 {q} {p } if e then S1 else S2 fi {q} {p ∧ e } S {p } {p } while e do S od {p ∧ ¬e } p ⊃ q, {q} S {r }, r ⊃ s {p } S {s } 2-65 Hoarescher Kalkül ! Der hoaresche Kalkül besteht aus dem Axiomenschema für die Zuweisung und Ableitungsregeln. ! Falls {p} S {q} mithilfe des hoareschen Kalküls hergeleitet werden kann, schreibt man 3 {p} S {q}. 2.4 Korrektheit von Algorithmen 2-66 Schleifeninvariante Die Bedingung p in der While-Regel heißt Schleifeninvariante. {p ∧ e } S {p } {p } while e do S od {p ∧ ¬e } Eine Schleifeninvariante gilt vor jedem Schleifendurchlauf und damit auch nach jedem Schleifendurchlauf, speziell also nach Beendigung der Wiederholungsanweisung. Dann gilt zudem ¬e . 2.4 Korrektheit von Algorithmen 2-67 Schleifeninvariante Beispiel: Für den folgenden Algorithmus ist q = k − 1 eine Schleifeninvariante. {q = 0 ∧ k = 1} while k ! n + 1 do q ← q + 1; k ← k + 1; od; {q = n } Nach Ausführung der Schleife gilt: q = k − 1 ∧ ¬(k ! n + 1) Daraus folgt: q = n 2.4 Korrektheit von Algorithmen 2-68 Eigenschaften des Kalküls Korrektheit: 3 {p } S {q} =⇒ |= {p } S {q} relative Vollständigkeit: 3 {p } S {q} ⇐= |= {p } S {q} 2.4 Korrektheit von Algorithmen 2-69 Beispiel: Division mit Rest ! Es sollen zwei ganze Zahlen x , y ∈ Z mit x ≥ 0 und y > 0 durcheinander dividiert werden. ! Das Ergebnis ist der Quotient q und der Rest r mit x = qy + r ∧ 0 ≤ r < y . var r, q, x: int; input x; q ← 0; r ← x; while r >= y do r = r - y; q = q + 1; od; output q, r; 2.4 Korrektheit von Algorithmen 2-70 Beispiel: Division mit Rest ! Mithilfe des hoareschen Kalküls leiten wir jetzt den Ausdruck {x ≥ 0} S {x = qy + r ∧ 0 ≤ r < y } her, wobei S der obige imperative Algorithmus ist. ! Wegen der Korrektheit des Kalküls können wir dann schließen, dass der Algorithmus bezüglich der angegebenen Vor- und Nachbedingung partiell-korrekt ist. ! Die Bedingung y > 0 wird zum Nachweis der totalen Korrektheit benötigt. 2.4 Korrektheit von Algorithmen 2-71 Beispiel: Division mit Rest Wir zeigen zuerst, dass x = qy + r ∧ 0 ≤ r eine Schleifeninvariante ist. Dies ergibt sich aus: x = qy + r ∧ 0 ≤ r ∧ r ≥ y 2.4 Korrektheit von Algorithmen =⇒ x = (q + 1)y + (r − y ) ∧ 0 ≤ r − y 2-72 Beispiel: Division mit Rest Die Behauptung folgt dann aus den beiden Aussagen x ≥ 0 =⇒ 0 ≤ x und x = qy + r ∧ 0 ≤ r ∧ ¬(r ≥ y ) 2.4 Korrektheit von Algorithmen =⇒ x = qy + r ∧ 0 ≤ r < y . 2-73 Beispiel: Division mit Rest ! Da nach Voraussetzung y > 0 gilt, durchläuft die Variable r eine monoton streng fallende Folge natürlicher Zahlen: r0 , r1 , r2 , . . . ! Da y konstant ist, wird deshalb für ein i die Bedingung ri < y wahr. Das heißt, das Programm terminiert schließlich und ist deshalb total-korrekt bezüglich der angegebenen Bedingungen. Bemerkung: Es gibt auch Kalküle zum Nachweis der totalen Korrektheit. 2.4 Korrektheit von Algorithmen 2-74 Beispiel: Division mit Rest Vor- und Nachbedingung, Schleifeninvariante als Annotation: static private int remainder (int x, int y) { assert x >= 0 && y > 0; int q = 0, r = x; assert x == q * y + r && 0 <= r; while (r >= y) { r = r - y; q = q + 1; assert x == q * y + r && 0 <= r; } assert x == q * y + r && 0 <= r && r < y; return r; } 2.4 Korrektheit von Algorithmen 2-75 Wunschtraum Es ist ein Algorithmus gesucht, der für beliebige p, S und q beweist oder widerlegt, dass 3 {p} S {q} gilt. Solch ein Algorithmus kann nicht existieren! Dann existiert natürlich erst recht kein analoger Algorithmus für die totale Korrektheit. 2.4 Korrektheit von Algorithmen 2-76 Totale Korrektheit ! Zum Nachweis der totalen Korrektheit muss zusätzlich zur partiellen Korrektheit die Terminierung gezeigt werden. ! Um die Terminierung von Schleifen nachzuweisen, gibt es keine allgemeine Methode, oft funktioniert aber die Vorgehensweise vom obigen Beispiel: 1. Man suche einen Ausdruck u, dessen Wert eine natürliche Zahl ist. 2. Man beweise, dass u bei jedem Schleifendurchlauf echt kleiner wird. 3. Da die natürlichen Zahlen wohlgeordnet sind, muss die Schleife terminieren. 2.4 Korrektheit von Algorithmen 2-77 Beispiel: Insertionsort P (j ): Das Feld A [1 · · · j ] ist eine Permutation des Ausgangsfeldes A [1 · · · j ]. S (j ): Das Feld A [1 · · · j ] ist sortiert. A ∗ [j ]: Der ursprünglich in A [j ] enthaltene Wert. Pk∗ (j ): Das Feld A [1 · · · k − 1, k + 1 · · · j ] ist eine Permutation des Ausgangsfeldes A [1 · · · j − 1]. Sk∗ (j ): Das Feld A [1 · · · k − 1, k + 1 · · · j ] ist sortiert. 2.4 Korrektheit von Algorithmen 2-78 Beispiel: Insertionsort {n ≥ 1} {P (1) ∧ S (1) ∧ n ≥ 1} j ← 2; {P (j − 1) ∧ S (j − 1) ∧ 2 ≤ j ≤ n + 1} while j ≤ n do key ← A[j]; i ← j - 1; while i > 0 ∧ A[i] > key do A[i+1] ← A[i]; i ← i - 1; od; A[i+1] ← key; j ← j + 1; od; {P (j − 1) ∧ S (j − 1) ∧ 2 ≤ j ≤ n + 1 ∧ j > n} {P (n) ∧ S (n)} 2.4 Korrektheit von Algorithmen 2-79 Beispiel: Insertionsort {P (j − 1) ∧ S (j − 1) ∧ 2 ≤ j ≤ n + 1 ∧ j ≤ n} {Pj∗ (j ) ∧ Sj∗ (j ) ∧ 0 ≤ j − 1} key ← A[j]; i ← j - 1; {Pi∗+1 (j ) ∧ Si∗+1 (j ) ∧ key < A [i + 2], . . . , A [j ] ∧0 ≤ i ≤ j − 1 ∧ key = A ∗ [j ]} while i > 0 ∧ A[i] > key do A[i+1] ← A[i]; i ← i - 1; od; A[i+1] ← key; j ← j + 1; {P (j − 1) ∧ S (j − 1) ∧ 2 ≤ j ≤ n + 1} 2.4 Korrektheit von Algorithmen 2-80 Konzepte imperativer Sprachen ! Anweisungen ! ! ! Ausdrücke ! ! ! primitive Anweisungen: Zuweisung, Block, Prozeduraufruf zusammengesetzte Anweisungen: Sequenz, Auswahl, Iteration primitive Ausdrücke: Konstante, Variable, Funktionsaufruf zusammengesetzte Ausdrücke: Operanden/Operatoren Datentypen ! ! primitive Datentypen: Wahrheitswerte, Zeichen, Zahlen, Aufzählung zusammengesetzte Datentypen: Felder, Verbund, Vereinigung, Zeiger 2.5 Konzepte imperativer Sprachen 2-81 Konzepte imperativer Sprachen ! Abstraktion ! ! ! ! Anweisung: Prozedurdeklaration Ausdruck: Funktionsdeklaration Datentyp: Typdeklaration Weitere Konzepte ! ! ! ! ! Ein- und Ausgabe Ausnahmebehandlung Bibliotheken Parallele und verteilte Berechnungen ... 2.5 Konzepte imperativer Sprachen 2-82 Blöcke ! Motivation: Ein Block fasst mehrere Anweisungen und Deklarationen zu einer Einheit zusammen. ! Syntax: Die Abgrenzung erfolgt durch syntaktische Elemente, wie z. B. Schlüsselwörter (begin, end), Klammerung oder Einrückung. Blöcke dürfen überall statt einer einzelnen Anweisung stehen. ! Kontrollfluss: Die Ausführung eines Blocks beginnt mit der ersten Anweisung und wird im Normalfall nach der letzten beendet. Es gibt auch Anweisungen zum Verlassen des Blocks: break, return. ! Lokale Variablen: Innerhalb eines Blocks können Variablen deklariert werden, die nur in diesem Block verfügbar sind. 2.5 Konzepte imperativer Sprachen 2-83 Blöcke ! Globale Variable: Innerhalb eines Blocks sind alle Bezeichner aus den umschließenden Blöcken sichtbar, soweit sie nicht von einer inneren Deklaration überdeckt werden. ! Gültigkeitsbereich (scope): Ein Bezeichner ist innerhalb des Blocks gültig, in dem er deklariert wurde, nicht aber außerhalb. Die Gültigkeit ist eine statische Eigenschaft, die sich aus dem Programmtext ableitet. ! Lebensdauer: Ist eine dynamische Eigenschaft und bezeichnet den Zeitraum der Verfügbarkeit eines Wertes während der Laufzeit. Werte von überdeckten Variablen sind nach Beendigung des überdeckenden Blocks wieder verfügbar. 2.5 Konzepte imperativer Sprachen 2-84 Blöcke Code var x,y: int; · · · do var x: int; ··· ··· od; ··· Gültig | | | x Sichtbar | | | | | | | y | | | | | | | x | | | x | | | | | | | y | | | | x Einzelheiten lernen Sie in der Vorlesung „Programmieren“. 2.5 Konzepte imperativer Sprachen 2-85 Prozeduren ! Abstraktion: Eine Prozedur fasst mehrere Anweisungen zusammen und gibt ihnen einen Namen. Der Aufruf einer Prozedur führt die Anweisungen aus und wirkt dabei wie eine elementare Anweisung. Über Parameter können die Anweisungen gesteuert werden. ! Wiederverwertung: Eine Prozedur wird nur einmal deklariert und kann beliebig oft verwendet werden. ! Modularisierung: Die Implementation der Prozedur muss dem aufrufenden Programm nicht bekannt sein. Veränderungen innerhalb der Prozedur erfordern keine Änderung des aufrufenden Programms. 2.5 Konzepte imperativer Sprachen 2-86 Deklaration von Prozeduren ! Deklaration: proc P(p1 , . . . , pn ) begin a; end ! Name: P ist der Name der Prozedur und frei wählbar. ! Parameter: p1 , . . . , pn sind die Parameter der Prozedur. Sie sind lokale Variablen mit eigenem Typ (formale Parameter), denen beim Aufruf der Prozedur Werte (aktuelle Parameter) zugewiesen werden. Die Gültigkeit der Parameter ist auf den Rumpf der Prozedur beschränkt. ! Rumpf: a ist der Rumpf der Prozedur. Er enthält die auszuführenden Anweisungen. 2.5 Konzepte imperativer Sprachen 2-87 Werte- und Referenzparameter Werteparameter (call by value): ! Der aktuelle Parameter kann ein Ausdruck oder speziell auch eine Variable sein. ! Es wird der Wert des Ausdrucks übergeben. ! Die Deklaration erfolgt (zum Beispiel) ohne das Präfix var. 2.5 Konzepte imperativer Sprachen 2-88 Werte- und Referenzparameter Referenzparameter (call by reference): ! Der aktuelle Parameter muss eine Variable sein. ! Es wird die Variable (Adresse) übergeben. ! In der Deklaration werden Referenzparameter (zum Beispiel) mit var bezeichnet. Es gibt weitere Arten der Parameterübergabe. 2.5 Konzepte imperativer Sprachen 2-89 Beispiel Aufgabe: Vertausche die Inhalte der Variablen x und y und addiere zu beiden den Wert a . proc vertausche(a: int; var x, y: int) begin var z: int; // lokale Variable z ← x; x ← y; y ← z; x ← x + a; y ← y + a; end Die Wirkung ist die „simultane“ Ersetzung. (x , y ) ← (y + a , x + a ) 2.5 Konzepte imperativer Sprachen 2-90 Beispiel Aufrufen lässt sich die Prozedur in unterschiedlichen Umgebungen mit verschiedenen aktuellen Parametern: vertausche(0, i, j); vertausche(3, a[1], a[2]); vertausche(a[3], a[1], a[2]); vertausche(i, i, j); 2.5 Konzepte imperativer Sprachen 2-91 Funktionen ! Abstraktion: Funktionen sind Abstraktionen von Ausdrücken. Der Aufruf einer Funktion berechnet einen Wert eines Typs τ. ! Deklaration: func F(p1 , . . . , pn ): τ begin a; end ! Auswertung: Der Rückgabewert der Funktion wird (zum Beispiel) durch eine spezielle return-Anweisung angegeben. Diese Anweisung verlässt den Funktionsblock mit sofortiger Wirkung. Häufig wird auch der letzte Term innerhalb einer Funktion als Rückgabewert genommen, oder eine Zuweisung zum Funktionsnamen legt den Rückgabewert fest. ! Seiteneffekt: Wenn der Aufruf einer Funktion den Wert einer globalen Variablen verändert, spricht man von einem Seiteneffekt. 2.5 Konzepte imperativer Sprachen 2-92 Beispiel func EUKLID(x, y: int): int begin var a,b,r: int a ← x; b ← y; while b # 0 do r ← a mod b; a ← b; b ← r; od; return a; end Für negative Werte der Parameter x und y hängt das Verhalten der Funktion von der Implementierung des mod-Operators ab. 2.5 Konzepte imperativer Sprachen 2-93 Rekursive Definitionen Die Funktion f : N −→ N wird durch 1 1+ , f (n ) = n f 2 f (3n + 1) n = 0, n = 1, n ≥ 2, n gerade, n ≥ 2, n ungerade. rekursiv definiert. Damit eine rekursive Funktion einen Wert liefern kann, muss mindestens eine Alternative eine Abbruchbedingung enthalten. 2.6 Rekursionen 2-94 Auswertung von Funktionen Funktionsdefinitionen können als Ersetzungssysteme gesehen werden. Funktionswerte lassen sich aus dieser Sicht durch wiederholtes Einsetzen berechnen. Die Auswertung von f (3) ergibt f (3) → f (10) → f (5) → f (16) → f (8) → f (4) → f (2) → f (1) → 1. Terminiert der Einsetzungsprozess stets? 2.6 Rekursionen 2-95 Formen der Rekursion ! Lineare Rekursion In jedem Zweig einer Fallunterscheidung tritt die Rekursion höchstens einmal auf. Bei der Auswertung ergibt sich eine lineare Folge von rekursiven Aufrufen. ! Endrekursion Der Spezialfall einer linearen Rekursion bei dem in jedem Zweig die Rekursion als letzte Operation auftritt. Endrekursionen können effizient implementiert werden. 2.6 Rekursionen 2-96 Formen der Rekursion ! ! Verzweigende Rekursion oder Baumrekursion 1 k = 0, k = n, - . n . . = n−1 n−1 k sonst. k −1 + k Geschachtelte Rekursion m+1 n = 0, f (n , m ) = f (n − 1, 1) m = 0, f (n − 1, f (n, m − 1)) sonst. 2.6 Rekursionen 2-97 Formen der Rekursion ! Verschränkte Rekursion oder wechselseitige Rekursion Der rekursive Aufruf erfolgt indirekt. n = 0, true even(n) = odd(n − 1) n > 0. n = 0, false odd(n) = even(n − 1) n > 0. 2.6 Rekursionen 2-98 Fibonacci-Zahlen Definition: 0 n=0 fib(n) = n=1 1 fib(n − 1) + fib(n − 2) n ≥ 2 Funktionswerte: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, . . . 2.6 Rekursionen 2-99 Fibonacci-Zahlen Auswertung: fib 5 fib 4 fib 3 fib 3 fib 2 2.6 Rekursionen fib 1 fib 0 1 0 fib 2 fib 2 fib 1 fib 1 fib 1 fib 0 fib 1 fib 0 1 1 0 1 0 1 2-100 Algorithmus von Euklid Rekursive Version: falls b = 0 a ggT(a , b ) = ggT(b , a mod b ) falls b > 0 Auswertung: ggT(36, 52) → ggT(52, 36) → ggT(36, 16) → ggT(16, 4) → ggT(4, 0) → 4 ggT(36, 52) = 4 2.6 Rekursionen 2-101 Fakultät Definition: Auswertung: x≤0 1 x! = x · (x − 1)! sonst 4! = 4 · 3! = 4 · 3 · 2! = 4 · 3 · 2 · 1! = 4 · 3 · 2 · 1 · 0! = 4 · 3 · 2 · 1 · 1 = 24 2.6 Rekursionen 2-102 Fakultät (rekursiv) func FAK(x: int): int begin if x <= 0 then return 1 else return x * FAK(x - 1) fi end 2.6 Rekursionen 2-103 Fakultät (rekursiv) Berechnung von FAK(2): 1. Anlegen einer lokalen Variable x , mit Wert 2. 2. x ! 0, daher Rückgabewert x · FAK (x − 1) = 2 · FAK (1) 2.1 Anlegen einer neuen lokalen Variable x mit dem Wert 1. 2.2 x ! 0, daher Rückgabewert x · FAK (x − 1) = 1 · FAK (0) 2.2.1 Anlegen einer neuen lokalen Variable x mit dem Wert 0. 2.2.2 x = 0, daher ist der Rückgabewert 1. 2.3 Rückgabewert ist 1 · 1 = 1 3. Rückgabewert ist 2 · 1 = 2 2.6 Rekursionen 2-104 Fakultät (iterativ) func FAK(x: int): int begin var result: int; result ← 1; while x > 0 do result ← result * x; x ← x - 1; od; return result; end Diese Lösung hat einen von x unabhängigen Speicherbedarf. 2.6 Rekursionen 2-105 Rekursive Probleme Viele Probleme besitzen eine rekursive Struktur. Für sie können rekursive Lösungen häufig kurz und elegant formuliert werden: ! Berechnung rekursiv definierter mathematischer Funktionen, ! Überprüfen der Syntax von Ausdrücken, ! Operationen auf rekursiv definierten Datenstrukturen. Wichtige Unterschiede: ! Rekursive Formulierungen sparen explizite Laufvariablen und Kontrollstrukturen. ! Rekursive Aufrufe verbrauchen Speicher auf dem Stack, es sei denn, es handelt sich um Endrekursion, die von modernen Compilern optimiert wird. 2.6 Rekursionen 2-106