Vorlesung Informatik 2 Algorithmen und Datenstrukturen (02 – Funktionenklassen) Prof. Dr. Th. Ottmann

Beschreibung und Analyse von Algorithmen Sprache zur Formulierung von Algorithmen : natürliche Sprache (Englisch), Java, C, Assembler, Pseudocode Mathematisches Instrumentarium zur Messung der Komplexität (des Zeit- und Platzbedarfs von Algorithmen): Groß-O-Kalkül

Primitive Operationen Grundlegende Berechnungen, die von einem Algorithmus ausgeführt werden Ablesbar aus Pseudocode oder Programmstück Überwiegend unabhängig von einer (imperativen) Programmiersprache Exakte Definition ist nicht bedeutend Beispiele einen Ausdruck auswerten einer Variablen einen Wert zuweisen Indexierung in einem Array Aufrufen einer Methode Verlassen einer Methode

Zählen von primitiven Operationen Durch Untersuchen des Pseudocode können wir die maximale Zahl von primitiven Operationen, die durch einen Algorithmus ausgeführt wurden, als eine Funktion der Eingabegröße bestimmen. Algorithmus arrayMax(A,n) # Operationen currentMax A[0] 2 for i 1 to n-1 do 2(n-1) if A[i] > currentMax then 2(n-1) currentMax A[i] 2(n-1) { erhöhe Zähler i } return currentMax 1 Total 6n-3

Laufzeit abschätzen Der Algorithmus arrayMax führt im worst case 6n - 3 primitive Operationen aus Definiere a Zeit, die die schnellste primitive Operation verbraucht hat b Zeit, die die langsamste primitive Operation verbraucht hat T(n) sei die tatsächliche worst-case Laufzeit von arrayMax . Dann ist : Daher ist die Laufzeit T(n) durch zwei lineare Funktionen beschränkt.

Funktionenklassen Groß-O-Notation: Mit -, - und -Notation sollen obere, untere bzw. genaue Schranken für das Wachstum von Funktionen beschrieben werden. Idee: Konstante Summanden und Faktoren dürfen bei der Aufwandsbestimmung vernachlässigt werden. Gründe: • Man ist an asymptotischem Verhalten für große Eingaben interessiert • Genaue Analyse kann technisch oft sehr aufwendig oder unmöglich sein • Lineare Beschleunigungen sind ohnehin immer möglich (Ersatz von Hardware/Software) Ziel: Komplexitätsmessungen mit Hilfe von Funktionenklassen. Etwa sind die Funktionen, die (höchstens) in der Größenordnung von f sind.

Die Θ -Notation Sei eine Funktion gegeben, dann ist folgende Menge von Funktionen: Die -Notation gibt also eine asymptotisch feste Grenze für eine Funktion. Wenn zu gehört, sagt man und schreibt oder auch (mathematisch fragwürdig) ist Gross-Theta von

Veranschaulichung der Θ -Notation c1g(n) f(n) c2g(n) n n0

Die O-Notation Sei eine Funktion gegeben, dann ist folgende Menge von Funktionen: Die -Notation gibt also eine asymptotisch obere Grenze für eine Funktion. Wenn zu gehört, sagt man und schreibt oder auch (mathematisch fragwürdig) ist Gross - O von

Veranschaulichung der O-Notation f(n) c g(n) n

Die Ω -Notation Sei eine Funktion gegeben, dann ist folgende Menge von Funktionen: Die -Notation gibt also eine asymptotisch untere Grenze für eine Funktion. Wenn zu gehört, sagt man und schreibt oder auch (mathematisch fragwürdig) ist Gross - Omega von

Veranschaulichung der Ω -Notation f(n) g(n)

Bemerkungen zu den O-Notationen In manchen Quellen findet man leicht abweichende Definitionen, etwa Für die relevantesten Funktionen (etwa die monoton steigenden nicht kongruent 0) sind diese Definitionen äquivalent.

Der O-Kalkül Einfache Regeln: Additionsregel: Multiplikationsregel: Additionsregel findet Anwendung bei der Berechnung der Komplexität, wenn Programmteile hintereinander ausgeführt werden. Multiplikationsregel findet Anwendung bei der Berechnung der Komplexität, wenn Programmteile ineinander geschachtelt werden.

Hierarchie von Größenordnungen O(1) O(log n) O(log2 n) O(n) O(n log n) O(n2) O(n3) O(nk) k konstant Name konstante Funktionen logarithmische Funktionen quadratisch logarithmische Funktionen lineare Funktionen n log n-wachsende Funktionen quadratische Funktionen kubische Funktionen polynomielle Funktionen f heißt polynomiell beschränkt ,wenn es ein Polynom p mit gibt. f wächst exponentiell , wenn es ein gibt mit .

Skalierbarkeiten Annahme: 1 Rechenschritt 0.001 Sekunden. Maximale Eingabelänge bei gegebener Rechenzeit. Annahme: Es kann auf einen 10-fach schnelleren Rechner gewechselt werden. Statt eines Problems der Größe kann in gleicher Zeit dann berechnet werden: Laufzeit T(n) 1 Sekunde 1 Minute 1 Stunde Laufzeit T(n) neue Problemgröße

Bestimmung des Zeitaufwands Sei A ein Programmstück, dessen Zeitaufwand cost(A) zu bestimmen ist: A ist einfache Anweisung (read, write, +, -, . . . ): A ist Folge von Anweisungen: Additionsregel anwenden A ist if-Anweisung: (a) if (cond) B; cost(A) = cost(cond) + cost(B) (b) if (cond) B; else C; cost(A) = cost(cond) + max(cost(B), cost(C)) A ist eine Schleife (while, for, . . . ): A ist Rekursion . . .

Implementation in Java class Mult { public static void main ( String [] args ) { int x = new Integer (args[0]). intValue(); int y = new Integer (args[1]). IntValue(); System.out.println (“Das Produkt von “ +x+ “ und “ +y+ “ ist “ +mult(x,y)); public static int mult (int x, int y) { int z = 0; while (y>0) if (y % 2 == 0) { y = y / 2; x = x+x ;} else { y = y-1; z = z+x; } return z; } }