algorithmen und datenstrukturen · 1 einfuhrung¨ 1.1 inhalt•wichtige datentypen und ihre...

Informatik II

Algorithmen und

Datenstrukturen

Vorlaufige Version 1 c© 2002 Peter Thiemann

1 Einfuhrung

1.1 Inhalt

• Wichtige Datentypen und ihre Implementierung (Datenstrukturen)

• Operationen auf Datenstrukturen (Algorithmen)

• Komplexitatsanalyse

– Laufzeitanalyse der Operationen

– Speicherverbrauchsanalyse

• Techniken des Algorithmenentwurfs

• Informell: Korrektheit der Algorithmen


1.2 Ziele

• Reproduktion

• Anwendung

• Implementierung

• Auswahlkriterien

• Komplexitatsanalyse einfacher Algorithmen

• Entwurfsideen fur Algorithmen


1.3 Hilfsmittel

• elementare Mathematik

(Folgen, Reihen, Grenzwerte, Abschatzungen, Kombinatorik)

• algorithmische Notation

z.B. Programmiersprache


1.4 Literatur

• T. Ottmann und P. Widmayer, Algorithmen und Datenstrukturen, 4. Auflage,

Spektrum Verlag, 2001.


2 Grundlagen der Komplexitatsanalyse

Referenzmaschine fur Komplexitatsanalyse: Turingmaschine

Definition 1 Sei M Turingmaschine fur einen Algorithmus A(x)

1. Laufzeit von A bei Eingabe von x

T (x) = ] Schritte, die M zur Berechnung von A(x)benotigt

2. Speicherplatzbedarf von A bei Eingabe von x

S(x) = ] Bandplatze, die M zur Berechnung von A(x)benotigt

Weitere Moglichkeiten fur Referenzmaschinen

1. RAM (random access machine)

2. RM (register machine)


Beispiel: tm-find0

Turingmaschine uber Alphabet 0, 1, die feststellt, ob die Eingabe 0 enthalt.

B

q0

1 1 0 1 1 1

N,0,qfq0 R,B,q0 N,B,qf

0 1

Startzustand q0; Endzustand qf ; akzeptiert, falls Kopf auf nicht-leerem Platz

x 0 1 110 110111

T(x) 1 2 3 3

S(x) 1 1 3 6


Probleme mit der Definition

1. Komplexitat hangt von konkreter Eingabe ab

2. Exakte Schrittzahl selten von Interesse

3. Algorithmen werden nicht in Form von Turingmaschinen aufgeschrieben


2.1 Abstraktion von der Eingabe

• Anstatt konkreter Eingabe x betrachte alle Eingaben der Große n = |x|

• Bestimme Anzahl der Schritte/Platze in Abhangigkeit von n

⇒ neues Problem: Eingaben gleicher Große konnen unterschiedlich viele

Schritte/Platze verbrauchen

• im Beispiel tm-find0

– Eingabe 00000000 braucht einen Schritt

– Eingabe 11101111 braucht vier Schritte

– Eingabe 11111111 braucht neun Schritte


Arten von Komplexitat

Losung: extrahiere einen Wert aus allen Werten T (x) mit |x| = n

• Tmin(n) = minT (x) | |x| = nbest-case Komplexitat

• Tmax(n) = maxT (x) | |x| = nworst-case Komplexitat

• T (n) =∑|x|=n T (x) · qn(x)

qn(x) ist Wahrscheinlichkeit, dass x als Eingabe der Große n auftritt

average-case Komplexitat


Bewertung

• best-case Komplexitat

leicht zu bestimmen, meist unwichtig

• worst-case Komplexitat

oft zu pessimistisch

• average-case Komplexitat

– praktisch relevant

– schwierig zu bestimmen

– Wahrscheinlichkeitsverteilung meist unbekannt

in Beweisen wird oft Gleichverteilung angenommen

d.h. qn(x) = m−1 wobei m = |x | |x| = n|


Beispiel: Laufzeitanalyse von tm-find0

• best-case

Tmin(n) = 1

falls x = 0 . . . or x = ε

• worst-case

Tmax(n) = n + 1

falls x = 1 . . . 1

• average-case

Annahme: Gleichverteilung, d.h. qn(x) = 2−n

T (n) = 1 · 0.5 + 2 · (0.5)2 + . . . + n · (0.5)n + (n + 1) · (0.5)n

= (∑n

k=1 k · 2−k) + (n + 1) · 2−n(1)


Nebenrechnung

∑nk=1 k · 2−k = 1 · 2−1 + 2 · 2−2 + 3 · 2−3 + . . .+ n · 2−n

= 2−1 + 2−2 + 2−3 + . . .+ 2−n

+ 2−2 + 2−3 + . . .+ 2−n

+ 2−3 + . . .+ 2−n

...

+ 2−n

(2)

Jede Zeile von (2) ist (Endstuck einer) geometrischen Folge

n∑k=0

qk =qn+1 − 1

q − 1(3)

Einsetzen von q = 1/2 in (3) ergibt

n∑k=0

(1/2)k =(1/2)n+1 − 1

1/2− 1= −2(1/2)n+1 + 2 = 2− 2−n (4)


In Zeile j ∈ 1, . . . , n von (2) steht gerade

2−j + 2−(j+1) + . . . + 2−n =∑n

k=0(1/2)k −∑j−1

k=0(1/2)k

(4)= 2− 2−n − (2− 2−(j−1))

= −2−n + 2−(j−1)

(5)

Also ergibt die Summe aller Zeilen in (2):∑nj=1−2−n + 2−(j−1) = −n · 2−n +

∑nj=1 2−(j−1)

= −n · 2−n +∑n−1

j=0 2−j

(4)= −n · 2−n + 2− 2−(n−1)

(6)

Einsetzen von (6) in (1) ergibt insgesamt

T (n) = −n · 2−n + 2− 2−(n−1) + (n + 1) · 2−n

= 2 + 2−n − 2−(n−1)

= 2 + 2−n − 2 · 2−n

= 2− 2−n

(7)


2.2 Komplexitat eines Problems

Unterschied: Komplexitat eines Problems ↔ Komplexitat eines Algorithmus

• Komplexitat eines Problems ist die minimale Laufzeit (Speicherplatzbedarf) eines

Algorithmus, der das Problem lost

Theorie: fur manche Probleme gibt es untere Schranken, d.h. kein Algorithmus

kann schneller laufen, als die untere Schranke angibt

oft schwer zu bestimmen

• Komplexitat eines konkreten Algorithmus liefert obere Schranke fur ein Problem

• Falls die Komplexitat eines Algorithmus der unteren Schranke eines Problems

entspricht, so liegt eine genaue Schranke vor.


2.3 Wachstumsklassen von Funktionen

• Genaue Zahl von Schritten selten interessant und/oder technisch aufwandig zu

ermitteln

• Variiert zwischen Implementierungen

• Verhalten wichtiger fur große Eingaben

asymptotisches Verhalten

• Unabhangigkeit von konstanten Faktoren

Anderung bei Technologiewechsel

⇒ Wachstumsverhalten von Funktionen ist interessanter


Definition: Landausche O-Notation

Seien f, g : N → R+ Funktionen

• f ∈ O(g) “f wachst nicht schneller als g”, falls

(∃c ∈ R+) (∃n0 ∈ N) (∀n ∈ N) n > n0 ⇒ f(n) ≤ c · g(n)

• f ∈ Ω(g) “f wachst mindestens so schnell wie g”, falls g ∈ O(f)

• f ∈ Θ(g) “f genauso schnell wie g”, falls f ∈ O(g) und g ∈ O(f)

• f ∈ o(g) “f wachst langsamer als g”, falls

limn→∞

f(n)g(n)

= 0

• f ∈ ω(g) “f wachst schneller als g”, falls g ∈ o(f)


Schreibweise

• Schreibe O(n log n) anstelle von

– O(λn.n log n) oder

– O(g) mit g(n) = n log n

• Oft: f = O(g) anstatt f ∈ O(g)Vorsicht, da Gesetze von = nicht gelten!


Beispiele

Sei f1(n) =√

n; f2(n) = n; f3(n) = nk fur k ≥ 1; f4(n) = 2n

• f1 ∈ O(f2), denn fur alle n > n0 = 1 gilt:√

n ≤ n (mit c = 1)

• f2 ∈ O(f3), denn fur alle n > n0 = 1 gilt: n ≤ nk (mit c = 1; fur alle k ≥ 1)

• f3 ∈ O(f4), denn es gilt sogar f3 ∈ o(f4):

limn→∞

nk

2n= lim

n→∞

k · nk−1

ln 2 · 2n= . . . = lim

n→∞

k!(ln 2)k · 2n

= 0

nach l´Hospital (k-fach angewendet)

Zur Erinnerung: Regel von l´Hospital

limn→∞

f ′(n)g′(n)

= c ⇒ limn→∞

f(n)g(n)

= c

falls limn→∞ f(n) = limn→∞ g(n) ∈ 0,±∞


Visualisierung des Großenwachstums

0

5

10

15

20

0 5 10 15 20

log(x)sqrt(x)

xx*x

x*x*xx*x*x*xexp(x)


Wachstumshierarchie

O(1): konstante Funktionen

O(log n): Logarithmische Funktionen

O(log2 n): Quadratisch logarithmische Funktionen

O(n): Lineare Funktionen

O(n log n): — keine spezielle Bezeichnung —

O(n2): quadratische Funktionen

O(n3): kubische Funktionen

O(nk): polynomielle Funktionen (fur festes k ≥ 1)

genauer: f heißt polynomiell beschrankt, wenn es ein Polynom p mit f = O(p) gibt

O(2n): exponentielle Funktionen

genauer: f wachst exponentiell, wenn es ein ε > 0 mit f = Θ(2nε

) gibt


Skalierbarkeit

Maximale Eingabelange bei gegebener Rechenzeit

Annahme: Rechenschritt 0.001 Sekunden.

Laufzeit T(n) 1 Sekunde 1 Minute 1 Stunde

n 1000 60000 3600000

n log n 140 4895 204094

n2 31 244 1897

n3 10 39 153

2n 9 15 21


Maximale Eingabelange in Abhangigkeit von Technologie

• Algorithmus mit Laufzeit T (n)

• p max. Eingabelange mit alter Technologie

• pneu max. Eingabelange mit neuer Technologie

• neue Technologie: 10-mal so schnell

• 10 · T (p) = T (pneu)

T (n) pneu Begrundung

n 10p

n log n (fast 10)p log 10p = log p + log 10 ≈ log p

n2 3.16p 3.162 ≈ 10

n3 2.15p 2.153 ≈ 10

2n p + 3.3 23.3 ≈ 10


Beispiel: Exponentieller Algorithmus

SAT (Erfullbarkeit einer Formel der Aussagenlogik)

Frage: Gegeben eine logische Formel mit n Variablen. Gibt es eine Belegung der

Variablen, so dass die Formel wahr (erfullt) ist?

Alternativ: Gegeben ein kombinatorischer Schaltkreis mit n Eingangen. Gibt es

eine Belegung der Eingange, so dass der Ausgang 1 ist?

Naive Losung: Durchprobieren aller 2n moglichen Belegungen.

⇒ exponentielle Laufzeit

Anmerkung: Es ist nicht bekannt, ob dieser Algorithmus der bestmogliche ist.


Weitere Eigenschaften

• Falls p1 und p2 Polynome vom Grad d1 bzw. d2 mit positivem Leitkoeffizienten

sind, so gilt

p1 ∈ Θ(p2) ⇔ d1 = d2

p1 ∈ o(p2) ⇔ d1 < d2

p1 ∈ ω(p2) ⇔ d1 > d2

• Fur alle k > 0 und ε > 0 gilt

logk n ∈ o(nε)

dabei ist logk n = (log n)k

• 2n/2 ∈ o(2n)


Rechenregeln fur O

• f ∈ O(f)

• O(f) = O(O(f))

• O(k · f) = O(f) fur Konstante k ≥ 0

• O(k + f) = O(f) fur Konstante k ≥ 0

• O(f) ·O(g) = O(f · g) Multiplikationsregel

• O(f) + O(g) = O(max(f, g)) Additionsregel


Beweis fur Additions- und Multiplikationsregel

Sei F ∈ O(f) und G ∈ O(g), d.h. es gibt cF , cG ∈ R+ sowie nF , nG ∈ N, sodass

(∀n > nF ) F (n) ≤ cF f(n) und (∀n > nG) G(n) ≤ cGg(n) ist.

Sei nun n0 = max(nF , nG).

Offenbar gilt fur c1 = cF · cG, dass

(∀n > n0) F (n) ·G(n) ≤ cF f(n) · cGg(n) = c(f · g)(n).Es gilt also die Multiplikationsregel: F ·G ∈ O(f · g).

Weiter gilt fur c2 = cF + cG, dass

(∀n > n0) F (n) + G(n) ≤ cF f(n) + cGg(n) ≤ c2(max(f, g))(n).Es gilt also die Additionsregel: F + G ∈ O(max(f, g)).


Die Wachstumsordnung auf Funktionen

Definition 2 Eine Relation R ⊆ M ×M , wobei M Menge, heißt

• reflexiv, falls (∀m ∈ M) m R m;

• transitiv, falls (∀m1,m2,m3 ∈ M) m1 R m2 ∧m2 R m3 ⇒ m1 R m3;

• symmetrisch, falls (∀m1,m2 ∈ M) m1 R m2 ⇔ m2 R m1;

• Vorordnung, falls R reflexiv und transitiv;

• Aquivalenzrelation, falls R reflexiv, transitiv und symmetrisch.


Fur M = f | r : N → R+ definiere

f g ⇔ f ∈ O(g)

f ≺ g ⇔ f ∈ o(g)

Es gilt:

• ≺ ist transitive Relation

• ist Vorordnung

• f ≺ g ⇒ f g

• Die Relation ≈, definiert durch f ≈ g, falls f g ∧ g f , ist eine

Aquivalenzrelation

• f ≈ g ⇔ f ∈ Θ(g)

Bemerkung: Die Relationen ≺,,≈ auf Funktionen haben ahnliche Eigenschaften wie

<,≤,= auf Zahlen.

Unterschied: Aus f ≈ g folgt nicht f = g!


2.4 Kostenmaße

• Programmiersprache statt Turingmaschine

• Einheitskostenmaß

– Konkrete Maschine hat feste Wortbreite (z.B. 32 Bit);

jedes Datenelement belegt gleichen Speicherplatz unabhangig von der Große

– Turingmaschinen fur Grundrechenarten, Vergleiche, Kopieren von 32 Bit Zahlen

benotigen 32 · c + d Schritte

⇒ eine Konstante unabhangig von der Große der Zahl

⇒ Aufwand fur diese Operationen ist O(1)

• logarithmisches Kostenmaß

– Jedes Datenelement belegt Platz in Abhangigkeit von seiner Große

– Platzbedarf fur Langzahl n in Dualdarstellung: dlog2 n + 1e– Grundrechenarten, Vergleiche, Kopieren benotigen O(dlog2 n + 1e) Schritte


2.5 Kosten fur Programmteile

Zuweisung: T (x := E) = |E|+ 1 ∈ O(1)

(E Ausdruck, ohne Funktionsaufrufe; Einheitskostenmaß)

Sequenz: T (S1; . . . ;Sn) = T (S1) + . . . + T (Sn)

Konditional: T (if E S1 S2) = T (E) + max(T (S1), T (S2))

Schleife: T (while E do S) =∑n

i=1 Ti(E) + Ti(S)

Rekursion: T selbst rekursiv definiert

Bemerkung: oft werden nur “wichtige Operationen” gezahlt: Vergleiche,

Datenbewegungen, usw


2.6 Beispiele

2.6.1 Algorithmus Bubble-Sort

Sortiert die Zahlen im Array a[1..n] durch wiederholtes Vertauschen.

repeat

for (i = 1; i < n; i++)

if (a[i] > a[i+1])

swap(a, i, i+1)

until (keine Vertauschungen mehr notwendig)

Abschatzen der Anzahl von Vergleichen:

Worst Case: Innere Schleife: n− 1 Vergleiche, maximal n Durchlaufe (Minimum an

a[n]) der außeren Schleife ⇒ O(n2)

Best Case: Array ist bereits sortiert: Ende nach einem Durchlauf ⇒ O(n)

Average Case: auch O(n2) viele Vergleiche ausgefuhrt.


2.6.2 Das Maxsummenproblem

Problem MaxSum: Betrachte ein Array a[1..n] von ganzen Zahlen. Berechne

maxf(i, j) | 1 ≤ i ≤ j ≤ n, wobei f(i, j) = ai + . . . + aj . Rechenschritte sind

arithmetische Operationen und Vergleiche.

Naiver Algorithmus

Berechne alle Werte von f(i, j) und bestimme dabei das Maximum.

m := f (1,1)

for (i = 1; i <= n; i++)

for (j = i; j <= n; j++)

if (f (i,j) > m)

m := f (i,j)

Die Berechung von f(i, j) benotigt j − i Additionen.


Analyse Naiver Algorithmus Es gibt j Paare der Form (·, j)

# Vergleiche: V1(n) =∑n

j=1 j ∈ O(n2)

# Additionen:

A1(n) =n∑

i=1

n∑j=i

(j − i)

=n∑

i=1

n−i∑k=1

k

∈ O(n3)

# Rechenschritte: T1(n) = V1(n) + A1(n) ∈ O(n2) + O(n3) = O(n3).

Tatsachlich auch Ω(n3).


2.6.3 Der etwas bessere Algorithmus

Verwende f(i, j + 1) = f(i, j) + aj+1

m := f (1,1)

for (i = 1; i <= n; i++)

fij := 0

for (j = i; j <= n; j++)

fij := fij + a[j]

if (fij > m)

m := fij

Damit braucht man fur alle f(i, ·)-Werte genau (n− i + 1) Additionen.

# Vergleiche: V2(n) = V1(n) ∈ O(n2).

# Additionen: A2(n) =∑n

i=1(n− i + 1) = n +∑n−1

k=1 k ∈ O(n2).

# Rechenschritte: T2(n) = V2(n) + A2(n) ∈ O(n2).


2.6.4 Divide-And-Conquer Algorithmusa

Zur Losung von MaxSum auf a[1..n] unterteile die Menge der Index-Paare (i, j) in

drei Klassen:

1. 1 ≤ i, j ≤ n/2 MaxSum auf a[1..n/2]

2. 1 ≤ i ≤ n/2 < j ≤ n neues Problem auf a[1..n]!

3. n/2 < i ≤ j ≤ n MaxSum auf a[n/2+1..n]

• Die Probleme 1 und 3 sind halb so groß wie das ursprungliche Problem und werden

rekursiv gelost.

• Fur Problem 2 setze

– g(i) = ai + . . . + an/2 fur 1 ≤ i ≤ n/2

– h(j) = an/2+1 + . . . + aj fur n/2 < j ≤ n

⇒ f(i, j) = g(i) + h(j)

Es gilt: f(i, j) maximal ⇔ g(i) und h(j) maximal

a(lat. divide et impera) teile und herrsche


• Berechne nacheinander (in n/2− 1 Additionen)

g(n/2) = an/2

g(n/2− 1) = an/2−1 + an/2

...

g(1) = a1 + . . . + an/2

und daraus den maximalen Wert von g in (n/2− 1) Vergleichen.

• Berechne den maximalen Wert von h analog.

• Damit ergeben sich fur das zweite Problem insgesamt n− 1 Additionen und n− 2Vergleiche, also 2n− 3 Operationen, obwohl die Klasse n2/4 Paare (i, j) enthalt.

• Gesamtergebnis aus Losungen fur 1, 2 und 3 durch 2 Vergleiche.


Rekursionsgleichung

T3(1) = 0

T3(n) = 2T3(n/2) + 2 · n− 3 + 2

Losungsansatz: Angenommen n = 2k

T3(2k) = 2T3(2k−1) + 2k+1 − 1

= 4T3(2k−2) + 2k+1 − 2 + 2k+1 − 1

= 8T3(2k−3) + 2k+1 − 4 + 2k+1 − 2 + 2k+1 − 1

= . . .

= 2k · T3(2k−k) + k · 2k+1 −∑k

i=1 2i−1

= 0 + 2k · 2k − 2k + 1

= (2k − 1)2k + 1

Aus n = 2k ergibt sich k = log2 n und somit

= (log2 n− 1)n + 1

∈ O(n log n)


2.6.5 Scanline Algorithmus

• MaxSum lasst sich mit einem Durchlauf durch a[1..n] losen

Gesucht: maxsumk = max∑j

l=i al | 1 ≤ i ≤ j ≤ kHilfsgroße: maxtailk = max

∑kl=i al | 1 ≤ i ≤ k

• Fur k = 1 setze maxsum1 = a1 und maxtail1 = a1.

• Fur k = 1, . . . , n− 1 setze

maxtailk+1 = max∑k+1

l=i al | 1 ≤ i ≤ k + 1= max(ak+1 +

∑kl=i al | 1 ≤ i ≤ k ∪ ak+1)

= max(ak+1 + maxtailk, ak+1)

maxsumk+1 = max∑j

l=i al | 1 ≤ i ≤ j ≤ k + 1= max(

∑jl=i al | 1 ≤ i ≤ j ≤ k ∪

∑k+1l=i al | 1 ≤ i ≤ k + 1)

= max(maxsumk,maxtailk+1)

⇒ T4(n) = (n− 1) · 3 = 3n− 3 Operationen


2.6.6 Zusammenstellung der Ergebnisse

Naiv: T1(n) ∈ O(n3)Besser: T2(n) ∈ O(n2)Divide-and-Conquer: T3(n) ∈ O(n log n)Scanline: T4(n) ∈ O(n)

Bemerkung: Es ist moglich, den Scanline Algorithmus aus dem naiven Algorithmus

herzuleiten!


2.7 Mastertheorem

Gegeben eine Rekursionsgleichung fur T : N → R.

T (n) =

c falls n ≤ d

aT (n/b) + f(n) falls n > d.

Dabei sind c ≥ 1 und d ≥ 1 naturliche Zahlen, a ≥ 1 und b > 1 reelle Konstanten und

f eine reelle Funktion mit f(n) ≥ 0 fur n ≥ d. Unterscheide drei Falle:

1. (∃ε > 0) f(n) ∈ O(nlogb a−ε) ⇒

T (n) ∈ Θ(nlogb a)

2. (∃k ≥ 0) f(n) ∈ Θ(nlogb a(log n)k) ⇒

T (n) ∈ Θ(nlogb a(log n)k+1)

3. (∃ε > 0) f(n) ∈ Ω(nlogb a+ε) und

(∃δ < 1) (n ≥ d) af(n/b) ≤ δf(n) ⇒

T (n) ∈ Θ(f(n))


Beispiele Mastertheorem

1. T (n) = 4T (n/2) + n; a = 4, b = 2, f(n) = n. Mit nlog2 4 = n2 ist

T (n) ∈ Θ(n2),

da Fall 1 gilt: n = f(n) ∈ O(n2−ε) fur ε = 1.

Genau: T (n) = 2n2 − n

2. T (n) = T (n/2) + 1; a = 1, b = 2, f(n) = 1. Mit nlog2 1 = 1 ist

T (n) ∈ Θ(log n),

da Fall 2 mit k = 0 gilt.

Genau: T (n) = log n + 1

3. T (n) = 2T (n/2) + n log n; a = 2, b = 2, f(n) = n log n. Mit nlog2 2 = n ist

T (n) ∈ Θ(n log2 n),

da Fall 2 mit k = 1 gilt.


4. T (n) = T (n/3) + n log n; a = 1, b = 3, f(n) = n. Mit nlog3 1 = 1 ist

T (n) ∈ Θ(n),

da Fall 3 gilt: f(n) = Ω(n0+ε) fur ε = 1 und fur δ = 1/3 gilt

af(n/b) = (n/3) log(n/3) = (n/3)(log n− log 3) ≤ (n/3) log n = f(n)/3


algorithmen und datenstrukturen · 1 einfuhrung¨ 1.1 inhalt•wichtige datentypen und ihre...

Documents