Algorithms & Data Structures 2

Transkript

1 Algorithms & Data Structures 2 Complexity WS2017 B. Anzengruber-Tanase (Institute for Pervasive Computing, JKU Linz) (Institute for Pervasive Computing, JKU Linz)

2 KLASSISCHER (DETERMINISTISCHER) ALGORITHMUSBEGRIFF Allgemeingültige, detaillierte, eindeutige und formalisiert ("rein mechanisch") ausführbare Vorschrift zum schrittweisen Lösen einer lösbaren Aufgabenklasse d.h. aller durch konkrete Parameterwerte charakterisierten Aufgaben eines bestimmten Typs, z.b. Lösen der quadratischen Gleichung x² + px + q = 0 (p, q - Parameter) unter Zugrundelegung eines bestimmten Prozessortyps Mensch, v. Neumann-Rechner, RAM, Turingmaschine,...; sequentiell, sequentiell-parallel, parallel mit endlichem Aufwand (Ressourcen, Zeit) niedergeschrieben als endlicher Text in einer vereinbarten Notierungsform Durch Einbringen nichtdeterministischer, stochastischer, evolutionärer, genetischer,... Elemente gelangt man zu Algorithmen, die zum Lösen bestimmter Aufgabenklassen wesentlich leistungsfähiger sind als klassische Algorithmen: stochastische (probabilistische), genetische,... Algorithmen. Algorithms & Datastructures 2 // 2017W // 2

3 DETERMINISMUS deterministischer Algorithmus zu jedem Zeitpunkt der Verarbeitung besteht höchstens eine Möglichkeit der Fortsetzung Beispiel: Durchwandern eines Irrgartens "immer an der Wand lang" nichtdeterministischer Algorithmus es gibt Zeitpunkte der Verarbeitung, bei denen zwei oder mehr Möglichkeiten der Fortsetzung beliebig ausgewählt werden können Beispiel: zufälliges Suchen im Irrgarten Algorithms & Datastructures 2 // 2017W // 3

4 FORMALE EIGENSCHAFTEN EINES ALGORITHMUS Korrektheit Gestellte Aufgabe richtig gelöst? (Dijkstra) Robustheit Werden Sonderfälle sicher abgehandelt? Allgemeingültigkeit Arbeitet er für beliebige Eingaben? Verständlichkeit Ist er verständlich aufgeschrieben? Effizienz Laufzeit? Speicherplatzbedarf? Messung (nach Implementation) Analyse für idealisierten Modellrechner / Referenzmaschine Interesse: Wachstum der Effizienz Algorithms & Datastructures 2 // 2017W // 4

5 KOMPLEXITÄT Speicherplatzkomplexität Wird (primärer, sekundärer) Speicherplatz effizient genutzt? Laufzeitkomplexität Steht die Laufzeit im akzeptablen/vernünftigen/optimalen Verhältnis zur Aufgabe? Worst-case Analyse Best-case Analyse Average-case Analyse (schwierig Verteilungsannahmen!) => Interesse an oberen und unteren Schranken => Interesse an Größenordnung (konstante Faktoren nicht vordergründig) Algorithms & Datastructures 2 // 2017W // 5

6 CASES Ausgangspunkt: Sei P das betrachtete Problem x... Eingabe, x =n Länge von x T P (x)... Laufzeit von P auf x T P (n)... Laufzeit von P bei Problemgröße n best case: oft leicht zu bestimmen, nicht repräsentativ worst case: konservativ, meist leicht zu bestimmen T P (n) = sup{ T P (x) x = n und x ist Eingabe für P } amortisierter worst case: durchschnittlicher Aufwand für eine schlechtest mögliche Folge von Operationen. average case: oft nicht leicht zu handhaben, aber praxisrelevant. Definition einer Wahrscheinlichkeitsverteilung q n für mögliche x T P,qn (n) = x = n und x ist Eingabe für P T P,qn (x) q n (x) Mittelwert worüber? Inputs gleich verteilt? Algorithms & Datastructures 2 // 2017W // 6

7 FUNKTIONENKLASSEN Groß-O-Notation O-, - und - Notation obere, untere bzw. genaue Schranken Idee beim Aufwand kommt es auf Summanden und konstante Faktoren letztlich nicht an Gründe Interesse am asymptotischen Verhalten für große Eingaben genaue Analyse oft technisch sehr aufwendig / unmöglich lineare Beschleunigungen sind leicht möglich (Tausch von Hard- und Software) Ziel Einteilung der Komplexitätsmessungen nach Funktionenklassen, z.b. O(f) Menge von Funktionen, die in der Größenordnung von f sind Algorithms & Datastructures 2 // 2017W // 7

8 ERMITTLUNG DES LEISTUNGSVERHALTENS Messung einer konkreten Implementierung auf realer Zielmaschine: Laufzeitmessung für repräsentative Eingaben Berechnung/Analyse des Laufzeit- Speicherplatzverbrauches für idealisierte Zielmaschine: Turingmaschine (TM) Random Access Maschine (RAM) Ermittlung/Analyse teurer Elementaroperationen: Anzahl der Vergleiche / Vertauschungen beim Sortieren Anzahl der Multiplikationen / Divisionen beim numerischen Rechnen Algorithms & Datastructures 2 // 2017W // 8

9 MESSUNG Experimentelle Bestimmung der Laufzeit Mögliche Ergebnisse: Programm, das den Algorithmus implementiert exekutiere das Programm mit unterschiedlichen Eingabedaten (n) verwende eine Methode zur Messung der Laufzeit t(ms) n Algorithms & Datastructures 2 // 2017W // 9

10 MESSUNG Vergleich von Geschwindigkeit eines Algorithmus erfordert Mittelwertbildung Arithmetisches Mittel Geometrisches Mittel Harmonisches Mittel K AM = x i / K i=1 K GM = P x 1/K i i=1 K HM = K / ( ( 1 / x i ) ) i=1 Algorithms & Datastructures 2 // 2017W // 10

11 BEISPIEL :: VERGLEICHSMESSUNG VON SORTIERALGORITHMEN Man betrachte 2 Sortieralgorithmen (A und B), implementiert für Maschine Y Frage: Welcher Algorithmus ist schneller? Definition: Sortiergeschwindigkeit = Problemgröße / gemessene Laufzeit Ergebnisse für Problemgröße n = 300 bei unterschiedlicher Struktur der Eingabedaten (Test 1 und Test 2) Geschwindigkeit Algorithmus A Geschwindigkeit Algorithmus B Test 1 5 (Laufzeit 60) 6 (Laufzeit 50) Test (Laufzeit 2) 60 (Laufzeit 5) Algorithmus B bei Test 1 schneller, Algorithmus A bei Test 2 schneller Frage: Welcher Algorithmus ist im Mittel schneller? Algorithms & Datastructures 2 // 2017W // 11

12 BEISPIEL :: VERGLEICH VON SORTIERALGORITHMEN Geschwindigkeit Algorithmus A Geschwindigkeit Algorithmus B Test 1 5 (Laufzeit 60) 6 (Laufzeit 50) Test (Laufzeit 2) 60 (Laufzeit 5) Arithmetisches Mittel: Geschwindigkeit Algorithmus A = (150+5)/2 = 77.5 A schneller Geschwindigkeit Algorithmus B = (60+6)/2 = 33 Geometrisches Mittel: Geschwindigkeit Algorithmus A = (150 * 5) = A schneller Geschwindigkeit Algorithmus B = (60 * 6) = Harmonisches Mittel: Geschwindigkeit Algorithmus A = 2/(1/5 + 1/150) = 9.6 Geschwindigkeit Algorithmus B = 2/(1/6 + 1/60) = B schneller (Überlege zur Probe: Algorithmus A: 600 Elemente in 62 sec, Algorithmus B: 600 Elemente in 55 sec!) Algorithms & Datastructures 2 // 2017W // 12

13 BEISPIEL :: VERGLEICH VON SORTIERALGORITHMEN Geschwindigkeit Algorithmus A Geschwindigkeit Algorithmus B Test 1 5 (Laufzeit 60) 6 (Laufzeit 50) Test (Laufzeit 2) 60 (Laufzeit 5) Arithmetisches Mittel (der Geschwindigkeit): Geschwindigkeit Algorithmus A = (150+5)/2 = 77.5 A schneller Geschwindigkeit Algorithmus B = (60+6)/2 = 33 Geometrisches Mittel (der Geschwindigkeit): Geschwindigkeit Algorithmus A = (150 * 5) = A schneller Geschwindigkeit Algorithmus B = (60 * 6) = Harmonisches Mittel (der Geschwindigkeit): Geschwindigkeit Algorithmus A = 2/(1/5 + 1/150) = 9.6 Geschwindigkeit Algorithmus B = 2/(1/6 + 1/60) = B schneller (Überlege zur Probe: Algorithmus A: 600 Elemente in 62 sec, Algorithmus B: 600 Elemente in 55 sec!) Algorithms & Datastructures 2 // 2017W // 13

14 BEISPIEL :: VERGLEICH VON SORTIERALGORITHMEN Geschwindigkeit Algorithmus A Geschwindigkeit Algorithmus B Test 1 5 (Laufzeit 60) 6 (Laufzeit 50) Test (Laufzeit 2) 60 (Laufzeit 5) Arithmetisches Mittel (der Laufzeit): Geschwindigkeit Algorithmus A = (60+2)/2 = 31 Geschwindigkeit Algorithmus B = (50+5)/2 = 27.5 B schneller Geometrisches Mittel (der Laufzeit): Geschwindigkeit Algorithmus A = (60 2) = A schneller Geschwindigkeit Algorithmus B = (50 5) = Harmonisches Mittel (der Laufzeit): Geschwindigkeit Algorithmus A = 2/(1/60 + 1/2) = 9.23 Geschwindigkeit Algorithmus B = 2/(1/50 + 1/5) = 9.09 B schneller (Überlege zur Probe: Algorithmus A: 600 Elemente in 62 sec, Algorithmus B: 600 Elemente in 55 sec!) Verwende bei Raten (z.b. Geschwindigkeit, Operationen/Sekunde, km/h,...) immer Harmonisches Mittel!! Algorithms & Datastructures 2 // 2017W // 14

15 KRITIK AN EXPERIMENTELLER MESSUNG zusätzlicher Aufwand durch Implementierung und Test des Programmes Experimente sind hinsichtlich der durchführbaren Kombinationen der Eingabegrößen beschränkt, die gewählten Kombinationen sind u.u. nicht typisch für das Verhalten des Algorithmus für den Vergleich von Algorithmen muss eine identische HW/SW Plattform verwendet werden Anforderungen an eine allgemeine Methode zur Laufzeitanalyse soll auf abstrakter Beschreibung des Algorithmus aufbauen (statt auf einer konkreten Implementierung) soll alle möglichen Eingabekombinationen berücksichtigen soll eine HW/SW-unabhängige Bewertung eines Algorithmus erlauben bezogen auf einen Idealisierten Modellrechner Algorithms & Datastructures 2 // 2017W // 15

16 IDEALISIERTER MODELLRECHNER: RAM MODELL Algorithms & Datastructures 2 // 2017W // 16

17 IDEALISIERTER MODELLRECHNER :: RAM MODELL Annahmen: Register, halten unbeschränkt große (evtl. reelle) Zahlen abzählbar unendliche Menge einzeln addressierbarer Speicherzellen direkt oder indirekt addressierbar Befehlssatz ähnlich Assembler (Laden, Speichern, arithmetische Verknüpfung von Registerinhalten, bedingte/unbedingte Sprünge), Speicherplatz Zahl der benötigten RAM-Zellen Laufzeit Zahl der ausgeführten RAM-Befehle Problem: uneingeschränkte Größe der Datenelemente: Einheitskostenmaß: jedes Datenelement belegt nur beschränkten Speicher Größe des Inputs bestimmt durch Anzahl benötigter Datenelemente z.b. Größe eines Sortierproblems gemessen in der Anzahl zu sortierender Zahlen Logarithmisches Kostenmaß: einzelnes DE kann beliebig groß sein Größe des Inputs bestimmt durch Summe der Größe der Elemente Für n > 0 ist die Anzahl der benötigten Darstellungs-Bits log 2 (n+1) Algorithms & Datastructures 2 // 2017W // 17

18 IDEALISIERTER MODELLRECHNER :: PRAM MODELL (PARALLELE BERECHNUNG) Algorithms & Datastructures 2 // 2017W // 18

19 LAUFZEITANALYSE :: LANDAU SCHE O-NOTATION f = O(g) (in Worten: f wächst nicht schneller als g), wenn f = (g) (in Worten: f wächst mindestens so schnell wie g), wenn c +, n o 0, n n 0 : f(n) c g(n) c +, n o 0, n n 0 : f(n) c g(n) f = (g) (in Worten: f und g sind von der gleichen Wachstumsordnung), wenn f = o(g) (in Worten: f wächst langsamer als g), wenn f = w(g) (in Worten: f wächst schneller als g), wenn In Ottmann/Widmayer O(g) = { f a > 0, b > 0, n f(n) a g(n) + b } und (g) = { g c > 0, viele n: f(n) c g(n) } f = O(g) und g = O(f) f(n) / g(n) eine Nullfolge ist g = o(f) Algorithms & Datastructures 2 // 2017W // 19

20 LAUFZEITANALYSE :: LANDAU SCHE O-NOTATION Beispiel 3n 4 + 5n log n O(n 4 ), denn 3n 4 + 5n log n < 3n 4 + 5n 4 + 7n 4 = 15 n 4 für n >= 1. Wähle also c = 15, n 0 = 1. c +, n o 0, n n 0 : f(n) c g(n) In O(n 4 ) steht n 4 für die Funktion, die n auf n 4 abbildet. Häufig schreibt man auch h = O(n 4 ) statt h O(n 4 ) Üblicherweise verwendete Funktionen zum Messen des Wachstums: 1) logarithmische: log n 2) linear: n 3) n log n: n log n 4) quadratisch, kubisch, n 2, n 3,... 5) exponentiell: 2 n, 3 n,... Unterschied zwischen (4) und (5): handhabbar (tractable) - nicht handhabbar Algorithms & Datastructures 2 // 2017W // 20

21 (LAUFZEIT-) KOMPLEXITÄTSKLASSEN Drei zentrale Zeitkomplexitätsklassen werden unterschieden: Algorithmus A heißt: linear-zeitbeschränkt f A O ( n ) polynomial-zeitbeschränkt exponentiell-zeitbeschränkt k N, so daß f A O ( n k ). k N, so daß f A O ( k n ). Komplexitätsklassen P und NP P: Die Menge aller Sprachen (Probleme), die ein deterministischer Automat in Polynomialzeit (O(P(n)) akzeptiert NP: Die Menge aller Sprachen (Probleme), die ein nicht-deterministischer Automat in Polynomialzeit akzeptiert Algorithms & Datastructures 2 // 2017W // 21

22 BERECHNUNG DER (WORST-CASE) ZEITKOMPLEXITÄT Elementare Operationen (Zuweisung, Ein-/ Ausgabe): O ( l ) Summenregel: T 1 ( n ) und T 2 ( n ) seien die Laufzeiten zweier Programmfragmente P1 und P2 ; es gelte: T 1 ( n ) O (f ( n ) ) und T 2 ( n ) O ( g ( n ) ). Für die Hintereinanderausführung von P 1 und P 2 ist dann T 1 ( n ) + T 2 ( n ) O ( max ( f ( n ), g ( n ) ) ) Produktregel: z. B. für geschachtelte Schleifenausführung von P 1 und P 2 T 1 ( n ) * T 2 ( n ) O ( f ( n ) * g ( n ) ) Algorithms & Datastructures 2 // 2017W // 22

23 BERECHNUNG DER (WORST-CASE) ZEITKOMPLEXITÄT Fallunterscheidung: Kosten der Bedingungsanweisung ( O ( l ) ) + Kosten der längsten Alternative Schleife: Produkt aus Anzahl der Schleifendurchläufe mit Kosten der teuersten Schleifenausführung Rekursive Prozeduraufrufe: Produkt aus Anzahl der rekursiven Aufrufe mit Kosten der teuersten Prozedurausführung Algorithms & Datastructures 2 // 2017W // 23

24 BEISPIEL SORTIEREN Definition Sortieren Eingabe: Ausgabe: Reihe von Zahlen a 1, a 2,..., a n Permutation der Eingabe-Zahlenreihe a 1,...,a n, sodass gilt: a 1... a n Mögliche Lösungsalgorithmen: Insertion Sort Merge Sort Algorithms & Datastructures 2 // 2017W // 24

25 ALGORITHMUS :: INSERTION SORT Prinzip: für i=2,...,n, generiere sort. Liste a 1,..., a i durch Einfügen von a i in sortierte Liste a 1,..., a i-1 Eingabe: Pseudocode Algorithm InsertionSort: Input: Array A[1...n] Output: sortiertes Array A for i 2 to n do while A[i] < A[i-1] swap A[i] with A[i-1] decrement i Algorithms & Datastructures 2 // 2017W // 25

26 LAUFZEITANALYSE :: INSERTION SORT Laufzeit ist lineare Funktion der Anzahl der Vergleichsoperationen worst case Eingabedaten sind in umgekehrter Reihenfolge sortiert n-1 Anzahl der Vergleichsoperationen i = n (n-1) / 2 Komplexität (n 2 ) i=1 best case Eingabedaten sind bereits sortiert n-1 Anzahl der Vergleichsoperationen 1 = n-1 Komplexität (n) i=1 average case n-1 Erwartete Anzahl von V.op. (i+1)/2 = n (n+1) / 4 Komplexität (n 2 ) i=1 Algorithms & Datastructures 2 // 2017W // 26

27 ALGORITHMUS :: MERGE SORT Prinzip: Divide and Conquer Divide: Teile Array in 2 Hälften Conquer: sortiere jede Hälfte Combine: vereinige sortierte Listen in einzige sortierte Liste Pseudocode Algorithm MergeSort (A,p,q), sort A[p...q] n q - p + 1, m p + n/2 if n=1 return MergeSort(A,p,m-1) MergeSort(A,m,q) i p, j m, t 1 while (i m-1) and (j q) if j=q+1 or (i m-1 and j q and A[i] < A[j] ) B[t] A[i], i i+1, t t+1 else B[t] A[j], j j+1, t t+1 for t 1 to n A[p + t - 1] B[t] Algorithms & Datastructures 2 // 2017W // 27

28 ALGORITHMUS :: MERGE SORT Eingabe: Rekursive Struktur: Algorithms & Datastructures 2 // 2017W // 28

29 LAUFZEITANALYSE :: MERGE SORT Laufzeit ist lineare Funktion der Anzahl der Zuweisungsoperationen der Arrays A und B Im Merge-Teil sind das 2n Operationen Daher gilt für die Laufzeit T(n) = (n) + T( n/2 ) + T( n/2 ) Durch Anwendung der Master-Methode erhält man T(n) = ( n ln n ) Algorithms & Datastructures 2 // 2017W // 29

30 LAUFZEITANALYSE :: REKURRENZBEZIEHUNGEN Funktion f(n) ist definiert durch Basisfall, z.b.: f(1) = 2 Rekursiver Fall, z.b.: f(n) = f(n-1) + N Standardmethode zur Lösung von Rekurrenzen: Entfaltung wiederholte Substitutionen der rekursiven Regel, bis Basisfall erreicht ist f(n) f(n) = f(n-1) + N = f(n-2) + (N-1) + N = f(n-3) + (N-2) + (N-1) + N... = f(n-i) + (N-i+1) (N-1) + N Basisfall erreicht bei i = N-1: f(n) = (N-2) + (N-1) + N = N ( N+1)/2 + 1 = O(N 2 ) Algorithms & Datastructures 2 // 2017W // 30

31 LAUFZEITANALYSE :: TÜRME VON HANOI Ziel: Schichte alle Scheiben von Stange A auf Stange C Regel: in einem Schritt darf nur eine Scheibe bewegt werden es darf nie eine größere Scheibe auf einer kleineren zu liegen kommen Rekursive Lösung: Schichte N-1 Scheiben von A auf B um Bewege größte Scheibe von A nach C Schichte N-1 Scheiben von B auf C um Gesamtzahl der Züge : T(N) = T(N-1) T(N-1) Algorithms & Datastructures 2 // 2017W // 31

32 LAUFZEITANALYSE :: TÜRMEN VON HANOI Rekurrenzbeziehung T(N) = 2 T(N-1) + 1 T(1) = 1 Lösung durch Entfaltung T(N) = 2 ( 2 T(N-2) + 1) + 1 = = 4 T(N-2) = = 4 ( 2 T(N-3) + 1) = = 8 T(N-3) =... = 2 i T(N-i) + 2 i i Expansion bricht bei i = N-1 ab T(N) = 2 N N N Geometrische Summe, daher T(N) = 2 N - 1 = O(2 N ) Algorithms & Datastructures 2 // 2017W // 32

33 LAUFZEITANALYSE :: REKURRENZ T(N) = 2 T(N/2) + N für N 2 T(1) = 1 T(N) = 2 ( 2T(N/4) + N/2 ) + N = 4 T(N/4) + 2N = 4 ( 2 T(N/8) + N/4 ) +2N = 8 T(N/8) + 3N... = 2 i T(N/2 i ) + in T(1) = 1 Expansion bricht bei i = ld N ab, sodass T(N) = N + N ld N Algorithms & Datastructures 2 // 2017W // 33

34 LÖSEN DER REKURRENZ DURCH RATEN UND BEWEISEN Beispiel T(N) = 2 T(N/2) + N für N 2 T(1) = 1 Annahme ( wild guess ) T(N) = N + N ld N Beweis durch Induktion Basis: T(1) = ld 1 = 1 Induktionsschritt: T(N) = 2 T(N/2) + N = 2 ( N/2 + N/2 ld (N/2)) + N = N + N ( ld N - 1 ) + N = N + N ld N Algorithms & Datastructures 2 // 2017W // 34

35 WEITERES BEISPIEL T(N) = 2 T( N ) + 1 = 2 T(N1/2) + 1 T(2) = 0 T(N) = 2 T(N1/2) + 1 = 2 ( 2 T(N1/4) + 1) + 1 = 4 T(N1/4) = 8 T(N1/8) i T(N1/2 i ) i-1 Expansion bricht bei N1/2i = 2 ab, also bei i = loglog N, daher T(N) = loglogn-1 = logn Algorithms & Datastructures 2 // 2017W // 35

36 LAUFZEITANALYSE :: LÖSEN DER REKURRENZ DURCH INDUKTION Zu zeigen Eigenschaft P gilt für alle ganzzahligen Werte n n 0 Basis: Zeige, daß P für n 0 gilt Induktionsschritt: Zeige wenn P gilt für alle k mit n 0 k n-1 dann gilt P auch für n Beispiel n-1 S(n) = i = n (n-1)/2 für n 2 i=1 Basis: S(2) = 2 (2-1)/2 = 1 Induktionsschritt: Annahme: S(k) = k(k+1)/2 für 2 k n-1 n-1 n-2 S(N) = i = i + n-1 = S(n-1) + n-1 i=1 i=1 = (n-1)(n-1-1)/2 + n-1 = (n 2-3n+2n+2-2)/2 = n (n-1)/2 Algorithms & Datastructures 2 // 2017W // 36

37 LAUFZEITANALYSE :: MASTER THEOREM Kochrezept für Rekurrenzgleichungen der Form: T(n) = a T(n/b) + f(n) mit a 1, b>1 und f(n) asymptotisch positiv und n/b entweder n/b oder n/b Falls f(n) = O ( n log b a-e ) für eine Konstante e > 0, dann T(n) = ( n log b a ) Falls k 0 sodaß f(n) = ( n log b a log k n), dann T(n) = ( n log b a log k+1 n) Falls e > 0 und c<1 sodaß f(n) = ( n log b a+e ) und a f(n/b) c f(n) für n hinreichend groß, dann T(n) = ( f(n) ) Algorithms & Datastructures 2 // 2017W // 37

38 BEISPIEL :: MASTER THEOREM Beispiel T(N) = 2 T(N/2) + N für N 2 T(1) = 1 Lösung a = 2 b = 2 f(n) = N N log b a = N log 2 2 = N 1 = N f(n) vergleichen mit N log b a ergibt Fall 2: f(n) = Θ(N log b a ) = Θ(N) => N und N sind von der gleichen Rangordnung T(N) = Θ(N log b a log N) = Θ(N log N) Algorithms & Datastructures 2 // 2017W // 38

39 ANHANG :: ANALYSE VON ALGORITHMEN Mathematische Grundlagen Logarithmen log b (xy) = log b x + log b y log b (x/y) = log b x log b y log b x a = alog b x log b a = log a x / log a b Exponenten a (b+c) = a b a c a (b-c) = a b /a c a bc = (a b ) c b = a log a b b c = a c*log a b Floor, Ceiling x = grösste ganze Zahl x x = kleinste ganze Zahl x Algorithms & Datastructures 2 // 2017W // 42

40 ANHANG :: ANALYSE VON ALGORITHMEN Mathematische Grundlagen Summen t f(i) = f(s) + f(s+1) + f(s+2) f(t) i=s wobei f eine Funktion ist, s der Startindex, und t der Endindex Geometrische Reihe f(i) = a i n a i = 1 + a + a a n = i=0 1 - a n a geometrische Reihe zeigt exponentielles Wachstum Algorithms & Datastructures 2 // 2017W // 43

41 ANHANG :: BEISPIEL ZUR ASYMPTOTISCHEN ANALYSE Algorithmus zur Bestimmung von Prefix-Mittelwerten Algorithm prefixaverages1(x): Input: Array X, enthält n Zahlen. Output: Array A, enthält n Elemente und in Element A[i] den Mittelwert der Elemente X[0],...,X[i]. 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 Analyse... Algorithms & Datastructures 2 // 2017W // 44

42 ANHANG :: BEISPIEL ZUR ASYMPTOTISCHEN ANALYSE verbesserter Algorithmus Algorithm prefixaverages2(x): Input: Array X, enthält n Zahlen. Output: Array A, enthält n Elemente und in Element A[i] den Mittelwert der Elemente X[0],...,X[i] s 0 for i 0 to n-1 do s s + X[j] A[i] s/(i+1) return array A Analyse... Algorithms & Datastructures 2 // 2017W // 45

43 Algorithms & Data Structures 2 Complexity WS2017 B. Anzengruber-Tanase (Institute for Pervasive Computing, JKU Linz) (Institute for Pervasive Computing, JKU Linz)