Vorlesung Informatik 2 Algorithmen und Datenstrukturen (02 – Funktionenklassen) Tobias Lauer.

Slides:



Advertisements
Ähnliche Präsentationen
Algorithmentheorie 08 – Dynamische Programmierung (1)
Advertisements

ALP II: Objektorientierte Programmierung Sommersemester 2006
der Universität Oldenburg
der Universität Oldenburg
der Universität Oldenburg
Asymptotische Notation
3. Kapitel: Komplexität und Komplexitätsklassen
2. Kapitel: Komplexität und Komplexitätsklassen
der Universität Oldenburg
Java: Objektorientierte Programmierung
Java: Dynamische Datentypen
Indirekte Adressierung
Java: Referenzen und Zeichenketten
Java: Grundlagen der Objektorientierung
SWITCH - Anweisung.
WHILE - Anweisung. Aufgabe : Ausgabe aller ganzen Zahlen von 0 bis 100 auf dem Bildschirm.
FOR Anweisung. Aufgabe : Ausgabe aller ganzen Zahlen von 0 bis 100 auf dem Bildschirm.
DO...WHILE Anweisung.
WS Algorithmentheorie 02 - Polynomprodukt und Fast Fourier Transformation Prof. Dr. Th. Ottmann.
Dynamische Programmierung (2) Matrixkettenprodukt
Algorithmentheorie 02 – Polynomprodukt und Fast Fourier Transformation
1 Vorlesung Informatik 2 Algorithmen und Datenstrukturen 01 – Einleitung Prof. Dr. Th. Ottmann.
Funktionenklassen zur Messung der Komplexität
1 Vorlesung Informatik 2 Algorithmen und Datenstrukturen (02 – Funktionenklassen) Prof. Dr. Th. Ottmann.
Algorithmen und Datenstrukturen
1 Vorlesung Informatik 2 Algorithmen und Datenstrukturen (03 – Verschiedene Algorithmen für dasselbe Problem) Prof. Dr. Th. Ottmann.
Vorlesung Informatik 2 Algorithmen und Datenstrukturen 01 – Einleitung
Vorlesung Informatik 2 Algorithmen und Datenstrukturen (10 - Suchverfahren) T. Lauer.
1 Vorlesung Informatik 2 Algorithmen und Datenstrukturen (03 – Verschiedene Algorithmen für dasselbe Problem) Prof. Dr. Th. Ottmann.
Vorlesung Informatik 2 Algorithmen und Datenstrukturen (02 – Funktionenklassen) Prof. Dr. Th. Ottmann.
Algorithmen und Datenstrukturen
WS Algorithmentheorie 08 – Dynamische Programmierung (2) Matrixkettenprodukt Prof. Dr. Th. Ottmann.
Informatik II, SS 2008 Algorithmen und Datenstrukturen Vorlesung 4 Prof. Dr. Thomas Ottmann Algorithmen & Datenstrukturen, Institut für Informatik Fakultät.
Informatik II, SS 2008 Algorithmen und Datenstrukturen Vorlesung 2 Prof. Dr. Thomas Ottmann Algorithmen & Datenstrukturen, Institut für Informatik Fakultät.
1 Vorlesung Informatik 2 Algorithmen und Datenstrukturen (21 – Kürzeste Wege) T. Lauer.
1 Vorlesung Informatik 2 Algorithmen und Datenstrukturen (03 – Verschiedene Algorithmen für dasselbe Problem) Prof. Dr. Th. Ottmann.
Imperative Programmierung Funktionen und Parameter
PRJ 2007/1 Stefan Dissmann Motivation Problem: gleiche Datenstrukturen werden für verschiedene Objekte gebraucht: z.B. Listen von Studierenden, Kunden,
PKJ 2005/1 Stefan Dissmann Rückblick auf 2005 Was zuletzt in 2005 vorgestellt wurde: Klassen mit Attributen, Methoden und Konstruktoren Referenzen auf.
PKJ 2005/1 Stefan Dissmann Zusammenfassung Vorwoche Programm besteht aus mehreren Bestandteilen: Schlüsselwörter Sonderzeichen Bezeichner Kommentare Texte.
Zusammenfassung Vorwoche
Algorithmische Geometrie
DVG Ablaufsteuerung
DVG Methoden 1 Methoden. 2 int dezi = Integer.parseInt(args[0]); boolean vz = (dezi>=0); dezi = Math.abs(dezi); String Bin = ""; do { } while.
Thema: Fibonacci-Zahlen
Bestimmung des ggT zweier Zahlen
Seite 1 Interface - Konzept Ein Interface führt einen neuen Datentyp ein: interface Frau {... } Das Interface enthält Deklarationen ( keine Definitionen.
PRJ 2007/1 Stefan Dissmann Verkettete datenstruktur: Liste Problem: Liste, die eine beliebige Zahl von Elementen verwaltet Operationen: Erzeugen, Anfügen,
Grundkonzepte Java - Klassendefinition
LS 2 / Informatik Datenstrukturen, Algorithmen und Programmierung 2 (DAP2)
Javakurs FSS 2012 Lehrstuhl Stuckenschmidt
Black Box Algorithmen Hartmut Klauck Universität Frankfurt SS
Polynome und schnelle Fourier-Transformation
Algorithmen und Datenstrukturen Übungsmodul 10
Algorithmen und Datenstrukturen SS 2005
2.4 Rekursion Klassifikation und Beispiele
CuP - Java Neunte Vorlesung Entspricht Kapitel 4.2 und 5 des Skriptums
CuP - Java Vierte Vorlesung Entspricht ungefähr Kapitel 2.1 des Skriptums Montag, 14. Oktober 2002.
CuP - Java Sechste Vorlesung Entspricht ungefähr Kapitel 3. 1 – 3
Programmierung von Agenten in Java: Implementierung einer Supply-Chain
Komplexität von Algorithmen
Programmiervorkurs WS 2014/15 Methoden
Programmiervorkurs WS 2014/15 Schleifen
Algorithmen und Datenstrukturen 1 SS 2002
Java Syntaxdiagramme Buchstabe A B Z a z ... Ziffer
© 2004 Pohlig Informatik Kurse © 2004 Pohlig Informatik Kurse Der Tramp tanzt die Rekursion zünderUntersuchen(…) Basisfall Rückmeldung:
Java-Kurs - 4. Übung Hausaufgabe Weitere Kontrollstrukturen
Wann ist eine Funktion (über den natürlichen Zahlen) berechenbar?
Java-Kurs - 4. Übung Hausaufgabe Weitere Kontrollstrukturen
Schleifen mit der Turtle
 Präsentation transkript:

Vorlesung Informatik 2 Algorithmen und Datenstrukturen (02 – Funktionenklassen) Tobias Lauer

Beschreibung und Analyse von Algorithmen Mathematisches Instrumentarium zur Messung der Komplexität (des Zeit- und Platzbedarfs von Algorithmen): Groß-O-Kalkül (Landausche Symbole)

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

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 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 Groß-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 Groß-Omega von

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

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 Groß-Theta von

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

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.

Beispiele zur O-Notationen f(n) = 2n2 + 3n + 1 = O(n2) f(n) = n log n ist nicht in O(n)

Eigenschaften von Groß-O Transitivität: Ist f(n) = O(g(n)) und g(n) = O(h(n)), dann ist f(n) = O(h(n)) Additivität: Ist f(n) = O(h(n)) und g(n) = O(h(n)), dann ist f(n) + g(n) = O(h(n)) Für konstantes a ist: a nk = O(nk) nk = O(nk+j), für jedes positive j. f(n) = aknk + ak-1nk-1 + … + a1n1 + a0 = O(nk) Ist f(n) = c g(n) für konstantes c, so ist f(n) = O(g(n)) Für beliebige positive Zahlen a, b ≠ 1 ist f(n) = logan = O(logbn) Für beliebige positive a ≠ 1 ist logan = O(log2n)

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.

Beispiele zur Laufzeitabschätzung(1) Algorithmus prefixAverages1(X) Eingabe: Ein Array X von n Zahlen Ausgabe: Ein Array A von Zahlen, so dass gilt: A[i] ist das arithmetische Mittel der Zahlen X[0], …, X[i] Methode: for i = 0 to n-1 do a = 0; for j = 0 to i do a = a + X[j] A[i] = a/(i + 1) return array A

Beispiele zur Laufzeitabschätzung(2) Algorithmus prefixAverages2(X) Eingabe: Ein Array X von n Zahlen Ausgabe: Ein Array A von Zahlen, so dass gilt: A[i] ist das arithmetische Mittel der Zahlen X[0], …, X[i] Methode: s = 0; for i = 0 to n-1 do s = s + X[i]; A[i] = s/(i + 1) return array A

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 p 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; } }