1. Übung 28. März 2007

Datenstrukturen und
Algorithmen SS07
Datum: 28.3.2007
Michael Belfrage
[email protected]
belfrage.net/eth
Administratives
• Übungsabgabe in der Übungsstunde
• Testatbedingung:
– Alle bis auf 2 Übungen sinnvoll
bearbeitet abgeben
• Keine Vorbesprechung
• Bei Unklarheiten bitte melden bei
mir oder Michel Gatto ([email protected])
Inhalt der Vorlesung
•
Algorithmen-Entwurf
–
–
–
–
•
Induktion
Divide and Conquer
Backtracking
Dynamische Programmierung
Klassische algorithmische Probleme
– Suchen
– Sortieren
•
Datenstrukturen
– Listen
– Hashverfahren
– Suchbäume
•
Zusammenspiel von Algorithmen und Datenstrukturen
– Geometrieprobleme
– Graphenprobleme
Programm von Heute
• Kurze Einführung
• Challenge der Woche
• Algorithmen-Entwurf Basics
– Definitionen
– Laufzeitanalyse
• Wachstumsordnungen
• Rekursionsgleichungen
• Asymptotische Laufzeit von CodeFragmenten bestimmen
Was ist ein Algorithmus?
Eine Handlungsvorschrift zur Lösung
eines Problems in endlich vielen
Schritten.
Basil-Lemon Pesto
A light and lemony variation on the traditional pesto, this version combines fresh parsley and
basil. Toss with your favorite pasta, or spoon over grilled fish or chicken breasts. To toast the
pine nuts, place them on a baking sheet and bake in a 350flF oven until golden, 8 to 10
minutes.
2 garlic cloves
3 Tbs. toasted pine nuts
1 1/2 cups loosely packed fresh basil leaves
1/2 cup loosely packed fresh flat-leaf parsley leaves
1/4 cup grated Parmigiano-Reggiano cheese
1 tsp. lemon zest
1 Tbs. fresh lemon juice
1 to 1 1/2 cups extra-virgin olive oil
Salt and freshly ground pepper, to taste
In a food processor, combine the garlic, pine nuts, basil, parsley, cheese, lemon zest and lemon
juice. Pulse until ground to a fine paste, about 1 minute. With the machine running, slowly
drizzle in the olive oil until the desired consistency is reached. Season with salt and pepper.
Makes 1 1/4 to 1 3/4 cups.
Adapted from a recipe by Sandra Cook, Chef and Food Stylist.
Wieso „Algorithmus“?
Ist ein Kunstwort aus:
– Muhammed Al Chwarizmi
(persischer Mathematiker ca.*783 – †850)
– arhythmos
(griech. für „Zahl“)
Hat keine Verwandschaft mit:
– algos
(griech. für „Schmerz“)
Algorithmen-Entwurf
• Was sind meistens Eigenschaften
von guten Algorithmen?
– Effizienz:
• Wenig Speicher brauchen
• Kurze Laufzeit benötigen
– Stabilität
– Korrektheit
– Einfach verständlich
Algorithmen-Entwurf
•• Wie
Wie können
können wir
wir diese
diese Kriterien
Kriterien
erreichen?
erreichen?
–– z.B.
z.B. durch
durch geeignete
geeignete Wahl
Wahl von
von Datenstruktur
Datenstruktur
–– Kriterien
Kriterien die
die weniger
weniger wichtig
wichtig sind
sind ausnützen
ausnützen
•• Überprüfung
Überprüfung der
der Effizienz:
Effizienz:
–– Laufzeitabschätzung:
Laufzeitabschätzung:
••
••
••
worst
worst case:
case: O(·)
average
average case:
case: E[T ime(n)]
best
best case:
case: Ω(·)
–– Speicherplatzabschätzung
Speicherplatzabschätzung
The Challenge
• Ablauf:
– Alle Zahlen von 1 bis 40 werden zufällig
durchmischt
– Eine der Zahlen wird entfernt
– Die restlichen werden mit 4 Sekunden
Verzögerung nacheinander gezeigt
– Finde einen effizienten Algorithmus für
dein eigenes Gehirn, um die entfernte
Zahl zu bestimmen.
Definitionen
Für eine Funktion g : N → R+ gilt:
O(g(n)) := {f : N → R+ : c ∈ R+ , n0 ∈ N : ∀n ≥ n0 : f (n) ≤ c · g(n)}.
- 28n2 = O(n2 )
- 3n3 − 10n2 + 32 = O(n3 )
-
n
2
2
i
=
0.5n(n
+
1)
=
0.5n
+
0.5n
=
O(n
)
i=0
ln2
ln 2
- 2log3 (n) = 2log2 (n)· ln3 = O(n ln 3 )
- log(n!) ≤ log(nn ) = O(n log n)
Definitionen
Für eine Funktion g : N → R+ gilt:
O(g(n)) := {f : N → R+ : c ∈ R+ , n0 ∈ N : ∀n ≥ n0 : f (n) ≤ c · g(n)}.
z.B. g(n) = n2 und f (n) = 1000n
f (n) ∈ O(g(n))
c=1
n0
n
Definitionen
Für eine Funktion g : N → R+ gilt:
O(g(n)) := {f : N → R+ : c ∈ R+ , n0 ∈ N : ∀n ≥ n0 : f (n) ≤ c · g(n)}.
Für eine Funktion g : N → R+ gilt:
Ω(g(n)) := {f : N → R+ : c ∈ R+ , n0 ∈ N : ∀n ≥ n0 : f (n) ≥ c · g(n)}.
g(n) = 1000n und f (n) = n2
f (n) ∈ Ω(g(n))
c=1
n0
n
Definitionen
Für eine Funktion g : N → R+ gilt:
O(g(n)) := {f : N → R+ : c ∈ R+ , n0 ∈ N : ∀n ≥ n0 : f (n) ≤ c · g(n)}.
Ω(g(n)) := {f : N → R+ : c ∈ R+ , n0 ∈ N : ∀n ≥ n0 : f (n) ≥ c · g(n)}.
Θ(g(n)) := O(g(n)) ∩ Ω(g(n))
Notation
f ∈ O(g)
f ∈ Ω(g)
f ∈ Θ(g)
Anschauliche Bedeutung
f wächst höchstens so schnell wie g
f wächst mindestens so schnell wie g
f wächst genauso schnell wie g
Notation
Definition
f ∈ O(g)
asympt. obere Schranke
f ∈ Ω(g)
asympt. untere Schranke
mathematische
Definition
f (n) <∞
lim sup n→∞ g(n) f (n) >0
lim inf n→∞ g(n) Wachstumsordnungen
Jeweils das kleinste n, sodass die Funktion f(n) mind. die
Zeit t benötigt. [f(n) in ms]
1 Sekunde
1 Minute
1 Stunde
1 Tag
1 Monat
1 Jahr
1 Jahrhundert
21000 ≈ 1031
260‘000
23‘600‘000
≤∞
≤∞
≤∞
≤∞
1e6
3.6e12
1.3e13
7.5e15
6.7e18
1e21
1e25
n
1‘000
6‘000
3.6e6
8.64e7
2.6e9
3.15e10
3.15e12
n log n
141
4‘896
204‘094
3.94e6
9.76e7
1e9
8.7e10
n2
32
245
1‘898
9‘295
50‘911
177‘583
1‘775‘837
n3
10
40
154
443
1‘374
3‘160
14‘665
2n
10
16
22
27
32
35
42
n!
7
9
10
12
13
14
16
log n
√
n
Wachstumsordnungen
Beispiel (Aufgabe 1.3):
Ordne die Funktionen nach aufsteigender Komplexität.
7·
n
n2
7 —7n
i=0 (ni)
2n
n
n3
log n
n2 log n
i=0 (n · i)
√
n
n2
log n
2
37 ·
n3
√
n
Lösung:
n
i=0 (n · i),
n2
n2
,
logn
7 —7n,
2
n logn, 37 ·
n3
n3
√
,
,
n logn
7·
n
√
n
i=0 (ni), 2
, 2n
Rekursionsgleichungen
Beispiel (Aufgabe 1.4a):
Finde eine geschlossene Formel für folgende Rekursionsgleichung und beweise diese
per Induktion. Nehme an n sei eine Potenz von 3.
3T ( n3 ) + 3n + 6
T (n) :=
3
n>1
n=1
Lösung:
Mit Teleskopieren folgt T (n) = 6n + 3n log3 (n) − 3
Induktion bestätigt dies.
- Induktionsverankerung: T (1) = ... = 3
- Induktionsschritt: T (3n) = ... = 6(3n) + 3(3n) log3 (3n)—3
Asymptotische Laufzeit von
Code-Fragmenten bestimmen
Beispiel (Aufgabe 1.5a):
from i := 1 until i > n loop
if i > n-1 then
from j := 1 until j > n loop
if i = j then
from k := i until k > n loop
s:= s + k
k:= k + 1
end
end
Lösung:
j := j + 1
end
end
i:= i + 1
end
Θ(n)
Asymptotische Laufzeit von
Code-Fragmenten bestimmen
Beispiel (Aufgabe 1.5b):
from i := 1 until i > n loop
from j := i until j < 1 loop
s := 3 + i
t := 2 * s
j := j // 2
Lösung:
end
i:= i + 1
end
Θ(n logn)
Asymptotische Laufzeit von
Code-Fragmenten bestimmen
Beispiel (Aufgabe 1.5c):
from i := n until i < 1 loop
from j := i until j < 1 loop
s := 3 * s
j := j - 1
end
Lösung:
i:= i // 2
end
Θ(n)
Ende der Stunde.
Questions?