Dokumentieren 16037863

Übung Algorithmen I
10.5.17
Sascha Witt
[email protected]
(Mit Folien von Lukas Barth, Julian Arz, Timo Bingmann,
Sebastian Schlag und Christoph Striecks)
Roadmap
I Listen
I
Skip List
I
Hotlist
I Amortisierte Analyse
Verkettete Listen
⊥
I Gut: Einfügen
I Schlecht: Suchen
Listen - Mit Überholspur
head
1
2
3
4
5
6
7
8
9
10
head
Listen - Mit Überholspur
head
1
2
3
4
5
6
7
Skip Lists
I Mehrere Levels von verketteten Listen
I Unterstes Level: Normale Liste
I Höhere Level: Elemente überspringen
I Elemente haben eine Höhe
I Sinnvoll vor allem für sortierte Listen
8
9
10
head
Skip Lists
head
1
2
3
4
5
6
I Optimale Höhe der Elemente?
7
8
9
10
head
Skip Lists
head
1
2
3
4
5
6
7
8
9
I Optimale Höhe der Elemente?
I height(k)
= max{h | ∃a ∈ Z : a · 2h = k}
I Bei jedem Schritt wird der Suchraum halbiert
10
head
Skip Lists
head
1
2
3
I height(k)
4
5
6
7
8
9
10
11
= max{h | ∃a ∈ Z : a · 2h = k}
12
I Bei jedem Schritt wird der Suchraum halbiert
13
14
15
16
Skip Lists
head
1
2
3
I height(k)
4
5
6
7
8
9
10
11
= max{h | ∃a ∈ Z : a · 2h = k}
12
I Bei jedem Schritt wird der Suchraum halbiert
Laufzeiten?
13
14
15
16
Skip Lists
head
1
2
3
I height(k)
4
5
6
7
8
9
10
11
= max{h | ∃a ∈ Z : a · 2h = k}
12
I Bei jedem Schritt wird der Suchraum halbiert
Laufzeiten?
I Suche: O(log n)
I Iterieren: O(n)
I Einfügen, Löschen...?
13
14
15
16
Skip Lists
Dynamische Datenstruktur?
I Randomisiert!
I Höhe
I
p=
h
1
2?
mit Wahrscheinlichkeit
ph
Skip Lists
Dynamische Datenstruktur?
I Randomisiert!
I Höhe
I
p=
h
mit Wahrscheinlichkeit
ph
1
2?
I Bei linearen Operationen: aufräumen
Skip Lists
Dynamische Datenstruktur?
I Randomisiert!
I Höhe
I
p=
h
mit Wahrscheinlichkeit
ph
1
2?
I Bei linearen Operationen: aufräumen
Wie lange dauert das Aufräumen..?
I Primitive Listen-Operationen: O(1)
Skip Lists
Dynamische Datenstruktur?
I Randomisiert!
I Höhe
I
p=
h
mit Wahrscheinlichkeit
ph
1
2?
I Bei linearen Operationen: aufräumen
Wie lange dauert das Aufräumen..?
I Primitive Listen-Operationen: O(1)
I Jedes Element muss in max. log n Listen eingefügt (oder
entfernt) werden
Skip Lists
Dynamische Datenstruktur?
I Randomisiert!
I Höhe
I
p=
h
mit Wahrscheinlichkeit
ph
1
2?
I Bei linearen Operationen: aufräumen
Wie lange dauert das Aufräumen..?
I Primitive Listen-Operationen: O(1)
I Jedes Element muss in max. log n Listen eingefügt (oder
entfernt) werden
I
→ O(n log n)
Skip Lists - Performance
Erwartete
Komplexität
I Speicherplatz: O(n)
Skip Lists - Performance
Erwartete
Komplexität
I Speicherplatz: O(n)
I Suchen: O(log n)
Skip Lists - Performance
Erwartete
Komplexität
I Speicherplatz: O(n)
I Suchen: O(log n)
I Einfügen, Löschen: O(log n)
Skip Lists - Performance
Erwartete
Komplexität
I Speicherplatz: O(n)
I Suchen: O(log n)
I Einfügen, Löschen: O(log n)
Achtung! Kein Worst-Case!
Amortisierte Analyse
Die Idee
I Viele schnelle Operationen, wenig langsame
I Umverteilen der Laufzeit
Amortisierte Analyse
Die Idee
I Viele schnelle Operationen, wenig langsame
I Umverteilen der Laufzeit
Amortisierte Analyse
Die Idee
I Viele schnelle Operationen, wenig langsame
I Umverteilen der Laufzeit
Amortisierte Analyse
Die Idee
I Viele schnelle Operationen, wenig langsame
I Umverteilen der Laufzeit
Amortisierte Analyse
Die Idee
I Viele schnelle Operationen, wenig langsame
I Umverteilen der Laufzeit
Amortisierte Analyse - Beispiel
Das Ziel
I Skip List mit Worst-Case-Garantien
Amortisierte Analyse - Beispiel
Das Ziel
I Skip List mit Worst-Case-Garantien
I Annahme: Bei
n
Elementen nur log n Anfragen
Amortisierte Analyse - Beispiel
Das Ziel
I Skip List mit Worst-Case-Garantien
I Annahme: Bei
n
Elementen nur log n Anfragen
I Wir wollen: Einfügen, Anfrage in O log
2
n
(amortisiert!)
Amortisierte Analyse - Beispiel
Das Ziel
I Skip List mit Worst-Case-Garantien
I Annahme: Bei
n
Elementen nur log n Anfragen
I Wir wollen: Einfügen, Anfrage in O log
Zur Erinnerung...
I Einfügen: O(log n)
I Suchen in optimaler Skip List: O(log n)
I Aufräumen: O(n log n)
2
n
(amortisiert!)
Amortisierte Analyse - Beispiel
Idee
I Beim Einfügen keine Mühe geben
I Vor jeder Anfrage aufräumen
Amortisierte Analyse - Beispiel
Idee
I Beim Einfügen keine Mühe geben
I Vor jeder Anfrage aufräumen
I Komplexität insgesamt:
n · c1 · log n + log n · c2 · n log n
Amortisierte Analyse - Beispiel
Idee
I Beim Einfügen keine Mühe geben
I Vor jeder Anfrage aufräumen
I Komplexität insgesamt:
n · c1 + log n · c2 · n log n
Amortisierte Analyse - Erinnerung
Achtung, verkürzt!
I
I
AOp :
TOp :
Op ∈ O
tatsächliche Kosten von Operation Op ∈ O
amortisierte Kosten von Operation
I Berechnung:
Op1
Op2
Op3
Opn
s0 −→
s1 −→
s2 −→
· · · −→
sn
Die angenommenen amortisierten Kosten sind korrekt, wenn
X
1≤i≤n
|
TOpi
{z
}
tatsächliche Gesamtkosten
für eine Konstante
c
≤c·
X
1≤i≤n
|
AOpi
{z
}
amortisierte Gesamtkosten
Amortisierte Analyse - Beispiel
X
1≤i≤n
TOpi =n · c1 + log n · c2 · n · log n
Amortisierte Analyse - Beispiel
X
1≤i≤n
TOpi =n · c1 + log n · c2 · n · log n
≤c1 · n · log2 n + c2 · n · log2 n
Amortisierte Analyse - Beispiel
X
1≤i≤n
TOpi =n · c1 + log n · c2 · n · log n
≤c1 · n · log2 n + c2 · n · log2 n
=(c1 + c2 ) · n · log2 n
Amortisierte Analyse - Beispiel
X
1≤i≤n
TOpi =n · c1 + log n · c2 · n · log n
≤c1 · n · log2 n + c2 · n · log2 n
=(c1 + c2 ) · n · log2 n
X
1≤i≤n
AOpi
=
n · log2 n + log n · log2 n
Amortisierte Analyse - Beispiel
X
1≤i≤n
TOpi =n · c1 + log n · c2 · n · log n
≤c1 · n · log2 n + c2 · n · log2 n
=(c1 + c2 ) · n · log2 n
!
c3 ·
X
1≤i≤n
AOpi
= c3 · n · log2 n + log n · log2 n
Amortisierte Analyse - Beispiel
X
1≤i≤n
TOpi =n · c1 + log n · c2 · n · log n
≤c1 · n · log2 n + c2 · n · log2 n
=(c1 + c2 ) · n · log2 n
!
c3 ·
X
1≤i≤n
AOpi
= c3 · n · log2 n + log n · log2 n
≥ c3 · n · log2 n
Hotlist
Operationen
I
I
I
insert (Key k , Data d)
lookup (Key k ) : Data
delete (Key k )
Ziel: jede Operation in amortisiert O(
√
n) Zeit
Hotlist
n
I (Unsortierte) Liste der Gröÿe
I Sortiertes Array der Gröÿe
n
√
n
√
n
Hotlist - Operationen
Lookup
lookup (Key k ) : Data
n
Vorgehen:
I durchsuche geordnetes Array
mit binärer Suche
I durchsuche Hotlist komplett
Laufzeit:
O log n
+
√ √ n =O n
√
n
Hotlist - Operationen
insert
insert (Key k , Data d)
Fall A: in Hotlist ist Platz
→
nächste freie Position in
Hotlist
Laufzeit: O(1)
n
√
n
Hotlist - Operationen
insert
insert (Key k , Data d)
n
√
n
Fall B: in Hotlist ist kein Platz
I sortiere Hotlist
I merge: führe sortierte Listen
zusammen
I
k
erstes Element in neuer Hotlist
n+
√
n
Hotlist - Operationen
insert
insert (Key k , Data d)
n
√
n
Fall B: in Hotlist ist kein Platz
I sortiere Hotlist
I merge: führe sortierte Listen
zusammen
I
k
erstes Element in neuer Hotlist
n+
Laufzeit:
O
√
√
√ n log( n) + n + n = O(n)
√
n
Hotlist - Amortisierung
Amortisierung von insert
I nach Zusammenführung:
Hotlist frei
I
√
n insert -Operationen
√
n−1
Positionen in der
bis zur nächsten
Zusammenführung
I Zusammenführung hat Aufwand
cn
Also:
I spare bei jeder einfachen
√
insert -Operation c n an
I bezahle bei der letzten Operation
cn
Hotlist - Operationen
delete
delete (Key k ):
Wenn bisher weniger als O
Löschoperationen:
√ n
n
√
n
Hotlist - Operationen
delete
delete (Key k ):
Wenn bisher weniger als O
√ n
Löschoperationen:
n
jedes Element bekommt valid-Bit
I
lookup : suche k
I setze valid-Bit auf 0
Laufzeit:
O
√ √
n + log n = O n
√
n
Hotlist - Operationen
delete
delete (Key k ): √ bei mehr als O
n
Lösch-Operationen zwischen zwei
n
Zusammenführungen
Vorgehen ähnlich zu
insert
I Reorganisation nach O
√
√ n
Lösch-Operationen
Laufzeit: Analyse wie bei
insert
n
Hotlist - Operationen
delete
I
Warum überhaupt löschen?
Hotlist - Operationen
delete
I
Warum überhaupt löschen?
I
n
I
I
ist hier: Maximale Anzahl von Elementen in der Hotlist
→
→
I
nicht Anzahl Operationen
I
nicht Anzahl gesehene Elemente
Ohne Löschen: Datenstruktur wächst unbegrenzt!
Laufzeiten gingen kaputt
Hotlist - Zusammenfassung
insert (Key k ): Aufwand amortisiert in O
lookup (Key k ): Aufwand in O
√ n
√ n
delete (Key k ): Aufwand amortisiert in O
√ n
Zusammenfassung
Skip List
I Randomisierte Datenstruktur
I
Erwarteter
Aufwand O(log n)
I Aggregat-Methode
Hotlist
I Mischung aus Array und Liste
I Einfügen, Löschen und Suchen (amortisiert) in O
I Token-Methode
√ n
Verkettete Listen
⊥
Verkettete Listen
⊥
I Einzelner Speicherblock?
I
Allokation dauert
I
Liste über ganzen Speicher verstreut?
Verkettete Listen - Drei Arrays
⊥
key
next
prev
⊥
Verkettete Listen - Ein Array
⊥
⊥
Zusammenfassung
Listen
I Array-Speicherung
Skip List
I Randomisierte Datenstruktur
I
Erwarteter
Aufwand O(log n)
I Aggregat-Methode
Hotlist
I Mischung aus Array und Liste
I Einfügen, Löschen und Suchen (amortisiert) in O
I Token-Methode
√ n
Variablenwechsel
√
T (n) = T ( n) + 1
für
n = 22 ,
i
T (4) = 1
Variablenwechsel
Wie löst man Rekurrenzen der Form
√
T (n) = T ( n) + 1?
Variablenwechsel
Wie löst man Rekurrenzen der Form
√
T (n) = T ( n) + 1?
I Setze
m = log n,
also
n = 2m .
I Dann:
m
T (2m ) = T (2 2 ) + 1
Variablenwechsel
m
T (2m ) = T (2 2 ) + 1
Variablenwechsel
m
T (2m ) = T (2 2 ) + 1
I Trick: setze
S(m) := T (2m )
I liefert:
S(m) = S
m
2
+1
Variablenwechsel
m
T (2m ) = T (2 2 ) + 1
I Trick: setze
S(m) := T (2m )
I liefert:
S(m) = S
I
S(m) ∈ O(?)
m
2
+1
Variablenwechsel
m
T (2m ) = T (2 2 ) + 1
I Trick: setze
S(m) := T (2m )
I liefert:
S(m) = S
I
S(m) ∈ O( log m)
m
2
+1
Variablenwechsel
√
T (n) = T ( n) + 1
m = log n
S(m) = S( m2 ) + 1
I
I
S(m) ∈ O(log m)
2i
liefert für n = 2 :
T (n) = T (2m )
= S(m)
∈ O(log m)
= O(log log n) .
Zusammenfassung
Listen
I Array-Speicherung
Skip List
I Randomisierte Datenstruktur
I
Erwarteter
Aufwand O(log n)
I Aggregat-Methode
Hotlist
I Mischung aus Array und Liste
I Einfügen, Löschen und Suchen (amortisiert) in O
I Token-Methode
√ n