Kapitel 3 Zur Korrektheit und Effizienz von Algorithmen

Transkript

1 Kapitel 3 Zur Korrektheit und Effizienz von Algorithmen Ziel: Kurze Einführung in den Pseudocode zur Beschreibung von Algorithmen Induktionsbeweise als wichtiges Hilfsmittel, um die Korrektheit eines Algorithmus nachzuweisen Komplexität/Effizienz von Algorithmen: wie misst man das, wie ist dazu das ganz allgemeine Vorgehen 3.1. Einführung in den verwendeten Pseudocode Bem.: Hier werden nur die wichtigsten Konzepte kurz vorgestellt. Eine ausführlichere Erläuterung finden Sie unter AuD, Kapitel 3 Effizienz, WS010/11, C. Eckert 1

2 Pseudocode umfasst Anweisungen/Befehle Einrücken Kennzeichnet die Blockstruktur Beispiel: // Rest der Zeile ist Kommentar. Kommentare werden nicht ausgeführt! Technische Universität München Beispiel for j = 2 to länge(a) do key = A[ j ] // Füge A[ j ] in die // sortierte Liste i = 0 A[1.. // Kommentar j - 1] ein. i = j 1 // Auch Kommentar while i > 0 und A[ i ] > key do A[i + 1] = A[ i ] i = i 1 A[i + 1] = key // Ausgabe: i = 7 print Gibt etwas aus. Zeichenketten in Anführungszeichen werden unverändert ausgegeben. Z.B. print X gibt den Wert der Variablen X aus. AuD, Kapitel 3 Effizienz, WS010/11, C. Eckert 2

3 Pseudocode Fortsetzung: Zuweisung: z.b. X = 5 Weist der Variable X den Wert 5 zu for j = 2 to länge(a) do key = A[ j ] // Füge A[ j ] in die // sortierte Liste A[1.. j - 1] ein. i = j 1 while i > 0 und A[ i ] > key do A[i + 1] = A[ i ] i = i 1 A[i + 1] = key Feld A[Wert1.. Wert2] Ein Feld ist eine Folge von Werten. Auf den Wert an Position i des Feldes A[i], wird mit einem Indexwert i zugegriffen. A[1..j] bezeichnet die Elemente A[1], A[2],, A[j]. AuD, Kapitel 3 Effizienz, WS010/11, C. Eckert 3

4 Pseudocode Fortsetzung: for i = Wert1 to Wert2 Variable i nimmt schrittweise die for j = 2 to länge(a) do Werte von Wert1 bis Wert2 an. key = A[ j ] // Füge A[ j ] in die Jedes Mal werden die Anweisung des For-Schleifenkörpers ausgeführt. i = j 1 while i > 0 und A[ i ] > key do Nach Beendigung der ganzen A[i + 1] = A[ i ] Schleife hat die Variable i den Wert i = i 1 Wert2+1 A[i + 1] = key while Bedingung do Führt einen While-Schleifenkörper aus, solange die Bedingung erfüllt ist. Problem? // sortierte Liste A[1.. j - 1] ein. AuD, Kapitel 3 Effizienz, WS010/11, C. Eckert 4

5 Pseudocode Fortsetzung: if Bedingung Anweisungsblock // Bedingung erfüllt else Anweisungsblock Verzweigung im Code anhand der Bedingung. else kennzeichnet den Beispiel i = 3 if i == 0 X= 0 else X= 2 Zweig, der gewählt wird,falls die Bedingung nicht erfüllt ist. <obj>.<attr> Per. wird auf das Attribut <attr> des Objekts <obj> zugegriffen. // A: Feld, 5 Elemente i = A.länge // i hat den Wert 5 AuD, Kapitel 3 Effizienz, WS010/11, C. Eckert 5

6 3.2. Einführendes Beispiel: Sortieren Sortieren ist eine wichtige Basis-Operation für komplexe Algorithmen Sortierproblem Eingabe: Folge von n natürlichen Zahlen a 1, a 2,, a n, die Folge ist nicht sortiert Ausgabe: Permutation der Eingabefolge Sortieren der Eingabewerte: a 1 a 2 a 3 a n Beispiel Eingabe: 41, 31, 26, 59, 58 Ausgabe: 26, 31, 41, 58, 59 sortierte Liste AuD, Kapitel 3 Effizienz, WS010/11, C. Eckert 6

7 3.2.1 Konkreter Sortieralgorithmus: Sortieren durch Einfügen, Algorithmus in Pseudo-Code Insertion Sort A[1..n] ist die Eingabe, ein Feld von natürlichen Zahlen key ist der bei jeder Iteration der Schleife einzusortierende Wert Insertion_Sort (A) Beispiel Beispiel: for j = 2 to länge(a) do Eingabe A[1.. 6] = 5, 2, 4, 6, 1, 3 key = A[ j ] Prinzipieller Ablauf: // Füge A[ j ] in die // sortierte Liste A[1.. j - 1] ein. i = j 1 while (i > 0 und A[ i ] > key) do A[i + 1] = A[ i ] i = i 1 A[i + 1] = key // Ende der For-Schleife AuD, Kapitel 3 Effizienz, WS010/11, WS09/10, C. C. Eckert 7

8 Algorithmus in Pseudo-Code Insertion Sort A[1..n] ist die Eingabe, ein Feld von natürlichen Zahlen key ist der einzusortierende Wert Insertion_Sort (A) for j = 2 to länge(a) do key = A[ j ] // Füge A[ j ] in die // sortierte Liste A[1.. j - 1] ein. i = j 1 while (i > 0 und A[ i ] > key) do A[i + 1] = A[ i ] i = i 1 A[i + 1] = key // Ende der For-Schleife j key A[1.. j-1] i Beispielablauf im Detail Eingabe 5, 2, 4, 6, 1, 3 AuD, Kapitel 3 Effizienz, WS010/11, C. Eckert 8

9 3.2.2 Korrektheit von Insertion Sort Anhand des Beispiels wird exemplarisch gezeigt, wie man prinzipiell vorgehen kann, um die Korrektheit zu beweisen Beobachtung: Insertion Sort berechnet das Ergebnis, indem die For-Schleife n-1 mal durchlaufen wird (n-1 Iterationen der Schleife) In jeder Iteration: A[j] bezeichnet den einzusortierenden Wert In jeder Iteration: alle Werte A[1.. j-1] liegen bereits sortiert vor und sind eine Permutation der ursprünglichen Werte der Positionen A[1.. j-1] Die Eigenschaft des Teilfeldes A[1.. j-1] ist eine so genannte Schleifeninvariante. AuD, Kapitel 3 Effizienz, WS010/11, C. Eckert 9

10 Eine Schleifeninvariante muss 3 Eigenschaften erfüllen: 1 Die Bedingung gilt vor dem Schleifen-Durchlauf 2 Wenn sie vor dem Durchlauf gilt, dann gilt sie auch bis zum nächsten Durchlauf, also auch nach dem Durchlauf 3 Beim Abbruch der Schleife liefert die Schleifeninvariante nützliche Informationen im Hinblick auf Korrektheit. Bem: Idee ist ähnlich einem Induktionsbeweis Schleifeninvariante für Insertion Sort Zu Beginn jeder Iteration der For-Schleife besteht das Teilfeld A[1.. j - 1] aus den ursprünglich in A[1.. j - 1] enthaltenen Werten und A[1.. j - 1] ist geordnet. AuD, Kapitel 3 Effizienz, WS010/11, C. Eckert 10

11 Nutzung der Schleifeninvariante für Korrektheitsnachweis: Vor dem erstem Schleifen-Durchlauf gilt: j = 2, und das Feld A[1.. j - 1] enthält nur ein Element: A[1], d.h. Das Feld ist sortiert, die Invariante ist erfüllt. Zeilen 4 7: Werte A[ j - 1], A[ j - 2] werden jeweils eine Position nach rechts verschoben, bis die korrekte Position A[ j ] für das einzusortierende Element mit dem Wert key gefunden ist. An dieser Position wird der Wert eingefügt. D.h. die Invariante ist erfüllt. Der Algorithmus terminiert, wenn j = n + 1 gilt, d.h. da die Invariante gilt: A[1.. j - 1], also A[1.. n], ist geordnet. AuD, Kapitel 3 Effizienz, WS010/11, C. Eckert 11

12 3.2.3 Komplexität von Insertion Sort? Zu klären ist, wie man anhand des Pseudocodes abschätzen kann, wie viel Rechenzeit (oder Speicherplatz) ein Algorithmus bei einer Eingabe n benötigt. Anders formuliert: kann man eine Funktion definieren, die in Abhängigkeit von der Eingabegröße n beschreibt, in welcher Weise der Aufwand, der zur Ausführung des Algorithmus notwendig ist, wächst? D.h. man ist daran interessiert, einen Algorithmus A über eine Funktion f zu charakterisieren, die das Wachstumsverhalten von A insbesondere bei sehr großen Werten der Eingabe n beschreibt. AuD, Kapitel 3 Effizienz, WS010/11, C. Eckert 12

13 Wachstums- Verhalten von Funktionen f(x) z.b. Linear: f(x) = x Logarithmisch: f(x)= log x Quadratisch: f(x) = x 2 AuD, Kapitel 3 Effizienz, WS010/11, C. Eckert 13

14 Bem.: Bevor wir eine allgemeine, systematische Vorgehensweise vorstellen, soll das Vorgehen am Beispiel Insertion Sort motiviert werden. Berechnung der Laufzeit von Insertion Sort Wir treffen folgende vereinfachende Annahme: Jede Grundoperation i (dies entspricht einer Zeile im Pseudo- Code) benötigt eine konstante Zeit c i Sei n die Größe des zu sortierenden Feldes von Insertion Sort, dann ist n die Problemgröße und wir berechnen die Laufzeit von Insertion Sort als Laufzeitfunktion T(n). D.h. mit T(n) beschreiben wir das Wachstumsverhalten von Insertion Sort abhängig von der Eingabegröße n. AuD, Kapitel 3 Effizienz, WS010/11, C. Eckert 14

15 Vorüberlegungen für Insertion-Sort: Zeile Kosten Zeit für alle pro Zeile Durchläufe Technische Universität München 1 c 1 2 c c 4 5 c 5 6 c 6 7 c 7 1 for j = 2 to länge(a) do 2 key = A[ j ] 3 // Füge A[ j ] in die // sortierte Liste A[1.. j - 1] ein. 4 i = j 1 5 while i > 0 und A[ i ] > key do 6 A[i + 1] = A[ i ] 7 i = i 1 8 A[i + 1] = key 8 c 8 AuD, Kapitel 3 Effizienz, WS010/11, C. Eckert 15

16 Berechnung der Laufzeit T(n) von Insertion Sort: T(n): Summe aller Laufzeiten der ausgeführten Grundoperationen Beispiel: Anweisung, die c i Schritte benötigt und n-mal ausgeführt wird, erfordert eine Laufzeit von c. i n Laufzeit T(n) = c 1 n + c 2 (n 1) + c 4 (n 1) Beobachtung? n Σ + c 5 t j + c 6 (t j 1) j=2 n Σ j=2 + c 7 (t j 1) + c 8 (n 1) n Σ j=2 AuD, Kapitel 3 Effizienz, WS010/11, C. Eckert 16

17 T(n) im Besten Fall (Best-Case)? AuD, Kapitel 3 Effizienz, WS010/11, C. Eckert 17

18 T(n) im Schlechtesten Fall (Worst-Case)? AuD, Kapitel 3 Effizienz, WS010/11, C. Eckert 18

19 Das Beispiel lehrt: (1) Wir haben von den tatsächlichen Kosten (Zeitdauer, Speicherplatz) einer auszuführenden Anweisung abstrahiert und eine Konstante c i verwendet. Dieses Vorgehen wendet man bei Laufzeituntersuchungen häufig an. Man abstrahiert von der realen Maschine, auf der ein Algorithmus ausgeführt wird, und geht von einem einfachen Maschinenmodell, der RAM-Maschine aus (siehe 3.3). (2) Eine detaillierte Analyse der Laufzeitfunktion ist bereits für ein sehr einfaches Beispiel sehr aufwändig. Was uns eigentlich interessiert ist der Grad des Wachstums einer Funktion, insbesondere der Laufzeitfunktion. Von besonderem Interesse ist die Frage des asymptotischen Verhaltens der Komplexität für n (siehe 3.4). AuD, Kapitel 3 Effizienz, WS010/11, C. Eckert 19

20 3.3 RAM-Modell Um die Laufzeit von Algorithmen zu analysieren, benutzen wir ein einfaches Modell der zugrundeliegenden Rechner. Ziel ist es, die erforderlichen Ressourcen zur Ausführung eines Algorithmus abschätzen zu können. Die exakte Zeit, die verschiedene Maschinenbefehle auf unterschiedlichen Rechnern erfordern, sind hier nicht relevant. Als Modell wird die Random-Access Machine (RAM) verwendet. Festlegungen des RAM-Modells: Wir betrachten nur sequentielle Ausführungen, also eine 1- Prozessor-Architektur, keine Parallelität. AuD, Kapitel 3 Effizienz, WS010/11, C. Eckert 20

21 Alle Daten liegen im direkt zugreifbaren Speicher. Was bedeutet das? Technische Universität München Alle Speicherzugriffe dauern gleich lang. Wieso ist das eine Abstraktion, Vereinfachung? Elementare Operationen erfordern eine Zeiteinheit. Wertzuweisung: = Arithmetische Operationen, wie Addition, Subtraktion, Multiplikation: *, /, +, - Logische Operationen, wie und und oder Vergleichsoperationen, wie < und > Befehle zur Steuerung des Kontrollflusses, wie if then else AuD, Kapitel 3 Effizienz, WS010/11, C. Eckert 21

22 Zur Bestimmung der Laufzeit eines Algorithmus wird die Anzahl der bei seiner Ausführung durchgeführten elementaren Operationen ermittelt. Beispiel: Anweisung (Alg.) Anzahl der Schritte X=X+1 for i=1 to n do X=X+1 for i=1 to n do for j=1 to n do X=X+1 AuD, Kapitel 3 Effizienz, WS010/11, C. Eckert 22

23 Etwas komplexeres Beispiel: Gegeben sei der fiktive Algorithmus A, der aus drei Teilen besteht, die sequentiell bearbeitet werden, also: P= Teil1; Teil2; Teil3 Der Pseudocode von P sei wie folgt gegeben: Teil1: X=X+1 Y=Y+1 Z=Z+1 Teil2: for i=1 to n do X=X+Y Y=Y*Z Teil3: for i=1 to n do for j=1 to n do X=X+1, X=Y+2, Z=Z+3 T(n) = AuD, Kapitel 3 Effizienz, WS010/11, C. Eckert 23

24 Frage: Wie ist der Grad des Wachstums der Funktion T(n) aus dem vorherigen Beispiel? Dazu betrachten wir unterschiedliche Eingabewerte n: n=2 T(2)= n=10 T(10)= n=100 T(100)= Erkenntnis? AuD, Kapitel 3 Effizienz, WS010/11, C. Eckert 24

25 3.4. Die Landau-Notation Die Landau-Notation ermöglicht die Bestimmung des Zusammenhangs zwischen der Länge der Eingabe und der Laufzeit bzw. dem Speicherplatzaufwand. Die Landau-Symbole erlauben Aussagen der Form: Die Funktion f wächst nicht schneller als die Funktion g. Mit der Landau-Notation beschreibt man das asymptotische Wachstumsverhalten, also den Grad des Wachstums (die Wachstumsrate) bei großen Eingabewerten. Wachstumsrate ist ein Kriterium, um die Effizienz eines Algorithmus zu bestimmen und um Algorithmen zu vergleichen. Beispiel: AuD, Kapitel 3 Effizienz, WS010/11, C. Eckert 25

26 3.4.1 Die Landau-Symbole Für eine gegebene Funktion g bezeichnen wir mit Ө(g) die Menge der Funktionen, für die gilt: Ө(g) = {f: es existieren positive Konstanten c 1, c 2 und n 0, so dass 0 c 1 g(n) f(n) c 2 g(n) für alle n n 0 } Notation: wir schreiben f(n) = Ө(g) Die Funktion f(n) ist bis auf einen konstanten Faktor für alle n n 0 gleich g(n). Wir sagen, dass g(n) eine asymptotisch scharfe Schranke von f(n) ist. AuD, Kapitel 3 Effizienz, WS010/11, C. Eckert 26

27 Intuitiv besagt die Landau-Notation, dass Terme niedriger Ordnung für große Eingabewerte n nicht signifikant sind, konstante Anteile können ignoriert werden. Die Ө-Funktion beschränkt eine Funktion f(n) asymptotisch von oben und von unten. Beispiel: Insertion Sort, Laufzeit T(n) = 1/2n 2 3n Behauptung: T(n) = Ө(n 2 ) AuD, Kapitel 3 Effizienz, WS010/11, C. Eckert 27

28 Beispiel: Gegeben quadratische Funktion f(n) = an 2 + bn + c Behauptung: f(n) = Ө(n 2 ) Allgemein gilt für jedes Polynom p(n) = ain i a i sind Konstanten, a d > 0: p(n) = Ө(n d ) d i 0 AuD, Kapitel 3 Effizienz, WS010/11, C. Eckert 28

29 Wenn wir nur über eine asymptotisch obere Schranke verfügen, benutzen wir die O-Notation. Gegeben sei die Funktion g(n). Mit O(g(n)) (gesprochen O von g von n) ist die Menge definiert: O(g) = {f: es existieren positive Konstanten c >0 und n 0, so dass 0 f(n) c g(n) für alle n n 0 } Bem.: Notation: f(n) = O(n). Falls f(n) = Ө(g(n)), dann gilt auch f(n) = O(g(n)) AuD, Kapitel 3 Effizienz, WS010/11, C. Eckert 29

30 Beispiel 1: Sei T(n) = 60n + 12 T(n) c g(n) T(n) g(n) n n 0 AuD, Kapitel 3 Effizienz, WS010/11, C. Eckert 30

31 Beispiel 2 T(n) = 31n + 12n 2 T(n) = O(n 2 ) Beispiel 3: Lineare Suche in einem sortierten Feld mit n Elementen i=0; while (i < n) und A[i] x )do i= i+1 ; Laufzeit T(n)= O(n) Best Case: 1 Schritt Average Case: n / 2 Schritte Worst Case: n Schritte AuD, Kapitel 3 Effizienz, WS010/11, C. Eckert 31

32 Bemerkungen: Mit der O-Notation wird eine obere Schranke für die Laufzeit angegeben. Das heißt, die O-Funktion beschreibt die Laufzeit im schlechtesten Fall. Mit Hilfe der O-Notation können wir nun eine Aussage treffen, wie effizient ein Algorithmus ist. O(1): Solche Algorithmen liefern unabhängig von der Problemgröße in konstanter Zeit ein Ergebnis. Das ist z.b. der Fall, wenn die Anweisungen des Algorithmus höchstens 1 mal ausgeführt werden. Beispiel: Entfernen des ersten Elementes einer Liste. AuD, Kapitel 3 Effizienz, WS010/11, C. Eckert 32

33 O(log n): Die benötigte Zeit ist proportional zum Logarithmus der Problemgröße, d.h. der Algorithmus wird mit wachsendem n langsamer. Bei jeder Verdopplung von n wächst log n um einen gewissen konstanten Wert. Dies tritt z.b. bei Algorithmen auf, die ein komplexes Problem in ein kleineres Problem umwandeln und den Aufwand auf einen konstanten Anteil verringern. Beispiel: Suche in einer sortierten Liste. O(n): Der Aufwand für einen Algorithmus ist linear in n, i.a. entfällt ein kleiner Anteil der Verarbeitung auf jedes Element der Eingabe. Beispiel: Suche in einer unsortierten Liste. AuD, Kapitel 3 Effizienz, WS010/11, C. Eckert 33

34 O(nlog n): z.b. Algorithmen, die das zu lösende Problem in Teilprobleme aufteilen, diese unabhängig lösen und die Teillösungen kombinieren. Beispiel: vergleichsbasiertes Sortieren einer Liste. O(n 2 ): Quadratische Laufzeit: typisch für Algorithmen, die alle paarweisen Kombinationen von Datenelementen verarbeiten. Beispiel: Multiplikation einer Matrix mit einem Vektor O(n 3 ): Beispiel: Multiplikation von Matrizen O(2 n ): Beispiel: Bestimmung aller möglichen Teilmengen Bem. zur log-funktion: Die Basis bewirkt nur eine Änderung um einen konstanten Faktor, d.h. die Basis ist nicht von Bedeutung. AuD, Kapitel 3 Effizienz, WS010/11, C. Eckert 34

35 Das Wachstumsverhalten von Funktionen Technische Universität München lg N lg 2 N N N N lg N N lg 2 N N 3/2 N Milliarden Milliarde 1 Billion Quelle R. Sedgewick, Algorithmen, Pearson Studium, 2002, S. 97 AuD, Kapitel 3 Effizienz, WS010/11, C. Eckert 35

36 O-Notation: Konstante c Bisher haben wir nur die Komplexitätsklassen (O(1), O(log n), O(n), ) betrachtet und eine Größe ignoriert: die Konstante c. Die Konstante c erlaubt uns den Vergleich von verschiedenen Funktionen und ist im asymptotischen Verhalten für n vernachlässigbar. Bemerkung: Dies gilt jedoch nicht für kleine Problemgrößen! Unter Umständen kann es deshalb sinnvoll sein, z.b. wenn die Eingabegröße n sehr klein ist, einen Algorithmus zu verwenden, der eigentlich einer höheren Komplexitätsklasse angehört, aber ein kleine Konstante c besitzt. AuD, Kapitel 3 Effizienz, WS010/11, C. Eckert 36

37 3.4.2 Rechenregeln für die O-Notation Nach dem Prinzip: teile und herrsche kann man auch die Analyse des Laufzeitverhaltens aufteilen und jeweils einzelne Teile analysieren. Die Frage bleibt: wie berechnet sich aus Teilergebnissen das Gesamtlaufzeitverhalten? Addition in der O-Notation Annahme: Laufzeiten für die Programme P 1 und P 2 seien: T 1 (n) = O( f (n)), T 2 (n) = O( g (n)) Im Algorithmus werde erst P 1 und dann P 2 ausgeführt Die Gesamtlaufzeit ergibt sich dann durch: T 1 (n) + T 2 (n) = O(max (f (n), g (n))) AuD, Kapitel 3 Effizienz, WS010/11, C. Eckert 37

38 Wieso ist das so? Behauptung: Gegeben sei Eingabegröße n T 1 (n) + T 2 (n) = O(max(f (n), g (n))) Beweis: Gegeben seien die Konstanten c 1, c 2, n 1, n 2 mit folgender Eigenschaft wenn n n 1, dann T 1 (n) c 1 f (n); wenn n n 2, dann T 2 (n) c 2 g(n). Sei n 0 = max(n 1, n 2 ). Wenn n n 0, dann ist T 1 (n) + T 2 (n) c 1 f (n) + c 2 g (n). D.h. Wenn n n 0, dann ist T 1 (n) + T 2 (n) (c 1 + c 2 ) max(f (n), g (n)). d.h. T 1 (n) + T 2 (n) = O(max(f (n), g (n))) AuD, Kapitel 3 Effizienz, WS010/11, C. Eckert 38

39 Beispiel 3 sequentiell ausgeführte Programmteile mit Laufzeiten P1: O(n 2 ) P2: O(n 3 ) P3: O(nlog n) Laufzeit der ersten beiden Programme: P1, P2: O(max (n 2, n 3 )) = O(n 3 ) Gesamtlaufzeit: (P1, P2), P3: O(max (n 3, nlog n)) = O(n 3 ) AuD, Kapitel 3 Effizienz, WS010/11, C. Eckert 39

40 Wichtigste Rechenregeln der O-Notation 1. f (n) = O( f (n)) 2. c O( f (n)) = O( f (n)), c ist eine Konstante 3. O( f (n)) + O( f (n)) = O( f (n)) 4. O( f (n)) + O( g (n)) = O( max( f (n), g (n))) 5. O( O( f (n))) = O( f (n)) 6. O( f (n)) O( g(n)) = O( f (n) g(n)) 7. O( f (n) g(n)) = O(f (n)) O( g(n)) AuD, Kapitel 3 Effizienz, WS010/11, C. Eckert 40

41 Allgemeine Regeln für die Analyse von Algorithmen Laufzeit für jede einzelne Grundoperation/Anweisung: O(1) uniforme Kostenfunktion (logarithmische Kostenfunktion) Laufzeit für eine Folge sequentiell ausgeführter Anweisungen: Summenformel Laufzeit für eine if Abfrage: Zeit für den if-block + Zeit O(1) für Bedingungsauswertung Laufzeit für einen if then else Block der größere Zeitbedarf des then- oder des else-blockes Laufzeit von Schleifen (for, while, ) Summe aller Zeiten innerhalb des Schleifenkörpers + Überprüfen der Schleifenbedingung O(1) multipliziert mit der Anzahl der Schleifendurchläufe AuD, Kapitel 3 Effizienz, WS010/11, C. Eckert 41