Di 22.06.2010 - Lehrstuhl für Effiziente Algorithmen

Grundlagen: Algorithmen und Datenstrukturen
Prof. Dr. Hanjo Täubig
Lehrstuhl für Effiziente Algorithmen
(Prof. Dr. Ernst W. Mayr)
Institut für Informatik
Technische Universität München
Sommersemester 2010
H. Täubig (TUM)
GAD
SS’10
1 / 320
Suchstrukturen
Übersicht
1
Suchstrukturen
Allgemeines
Binäre Suchbäume
(a, b)-Bäume
H. Täubig (TUM)
GAD
SS’10
260 / 320
Suchstrukturen
Allgemeines
Vergleich Wörterbuch / Suchstruktur
S: Menge von Elementen
Element e wird identifiziert über eindeutigen Schlüssel key(e)
Operationen:
S.insert(Elem e): S = S ∪ {e}
S.remove(Key k ): S = S \ {e},
wobei e das Element mit key(e) == k ist
S.find(Key k ):
Wörterbuch: gibt das Element e ∈ S mit key(e) == k zurück, falls
es existiert, sonst null
Suchstruktur: gibt das Element e ∈ S mit minimalem Schlüssel
key(e) zurück, für das key(e) ≥ k
H. Täubig (TUM)
GAD
SS’10
261 / 320
Suchstrukturen
Allgemeines
Vergleich Wörterbuch / Suchstruktur
Wörterbuch effizient über Hashing realisierbar
1
3
14
5
5
10
3
19
14
1
19
10
Hashing zerstört die Ordnung auf den Elementen
⇒ keine effiziente locate-Operation
⇒ keine Intervallanfragen
H. Täubig (TUM)
GAD
SS’10
262 / 320
Suchstrukturen
Allgemeines
Suchstruktur
Erster Ansatz:
sortierte Liste
3
19
42
Problem:
insert, remove, locate kosten im worst case Θ(n) Zeit
Einsicht:
wenn locate effizient implementierbar, dann auch die anderen
Operationen
H. Täubig (TUM)
GAD
SS’10
263 / 320
Suchstrukturen
Allgemeines
Suchstruktur
Idee:
füge Navigationsstruktur hinzu, die locate effizient macht
Navigationsstruktur
3
H. Täubig (TUM)
19
GAD
42
SS’10
264 / 320
Suchstrukturen
Binäre Suchbäume
Binärer Suchbaum (ideal)
10
3
19
1
1
5
3
H. Täubig (TUM)
5
14
10
14
GAD
28
19
28
∞
SS’10
265 / 320
Suchstrukturen
Binäre Suchbäume
Binärer Suchbaum
k
Suchbaum-Regel:
Für alle Schlüssel
k1 in T1 und k2 in T2 :
k1 ≤ k < k2
T1
T2
locate-Strategie:
Starte in Wurzel des Suchbaums
Für jeden erreichten Knoten v:
Falls key(v) ≥ kgesucht , gehe zum linken Kind von v,
sonst gehe zum rechten Kind
H. Täubig (TUM)
GAD
SS’10
266 / 320
Suchstrukturen
Binäre Suchbäume
Binärer Suchbaum
Formal:
für einen Baumknoten v sei
key(v) der Schlüssel von v
d(v) der Ausgangsgrad (also die Anzahl der Kinder) von v
Suchbaum-Invariante: k1 ≤ k < k2
(Sortierung der linken und rechten Nachfahren)
Grad-Invariante: d(v) ≤ 2
(alle Baumknoten haben höchstens 2 Kinder)
Schlüssel-Invariante:
(Für jedes Element e in der Liste gibt es genau einen
Baumknoten v mit key(v) == key(e))
H. Täubig (TUM)
GAD
SS’10
267 / 320
Suchstrukturen
Binäre Suchbäume
Binärer Suchbaum / locate
locate(9)
10
3
19
1
1
5
3
H. Täubig (TUM)
5
14
10
14
GAD
28
19
28
∞
SS’10
268 / 320
Suchstrukturen
Binäre Suchbäume
Binärer Suchbaum / insert, remove
Strategie:
insert(e):
I
I
erst locate(key(e)) bis Element e 0 in Liste erreicht
falls key(e 0 ) > key(e), füge e vor e 0 ein und ein neues
Suchbaumblatt für e und e 0 mit key(e), so dass Suchbaum-Regel
erfüllt
remove(k ):
I
I
I
erst locate(k) bis Element e in Liste erreicht
falls key(e) = k , lösche e aus Liste und Vater v von e aus
Suchbaum und
setze in dem Baumknoten w mit key(w) = k den neuen Wert
key(w) = key(v)
H. Täubig (TUM)
GAD
SS’10
269 / 320
Suchstrukturen
Binäre Suchbäume
Binärer Suchbaum / insert, remove
10
1
14
28
1
10
28
14
∞
insert(5)
10
1
14
5
1
H. Täubig (TUM)
5
28
10
GAD
14
28
∞
SS’10
270 / 320
Suchstrukturen
Binäre Suchbäume
Binärer Suchbaum / insert, remove
10
1
14
5
1
5
28
10
14
28
∞
insert(12)
10
1
14
5
1
H. Täubig (TUM)
5
12
10
GAD
12
28
14
28
∞
SS’10
271 / 320
Suchstrukturen
Binäre Suchbäume
Binärer Suchbaum / insert, remove
10
1
14
5
1
5
12
10
12
28
28
14
∞
remove(1)
10
14
1
5
1
H. Täubig (TUM)
5
12
10
GAD
12
28
14
28
∞
SS’10
272 / 320
Suchstrukturen
Binäre Suchbäume
Binärer Suchbaum / insert, remove
10
14
5
1
5
12
10
12
28
28
14
∞
remove(14)
10
14
5
5
H. Täubig (TUM)
12
10
GAD
12
28
14
28
∞
SS’10
273 / 320
Suchstrukturen
Binäre Suchbäume
Binärer Suchbaum / insert, remove
10
14
5
5
12
10
12
28
14
28
∞
remove(14)
10
12
28
5
5
H. Täubig (TUM)
10
GAD
12
28
∞
SS’10
274 / 320
Suchstrukturen
Binäre Suchbäume
Binärer Suchbaum / entartet
Problem:
Baumstruktur kann zur Liste entarten
⇒ locate kann im worst case Zeitaufwand Θ(n) verursachen
Beispiel:
Zahlen werden in sortierter Reihenfolge eingefügt
1
3
5
10
14
19
28
1
H. Täubig (TUM)
3
5
10
14
GAD
19
28
∞
SS’10
275 / 320
Suchstrukturen
(a, b)-Bäume
(a, b)-Baum
Problem:
Baumstruktur kann zur Liste entarten
Lösung: (a, b)-Baum
Idee:
d(v): Ausgangsgrad (also die Anzahl der Kinder) von Knoten v
t(v): Tiefe (in Kanten) von Knoten v
Form-Invariante:
alle Blätter in derselben Tiefe: t(v) = t(w) für Blätter v, w
Grad-Invariante:
Für alle internen Knoten v (außer Wurzel) gilt:
a ≤ d(v) ≤ b
Für Wurzel r:
H. Täubig (TUM)
(wobei a ≥ 2 und b ≥ 2a − 1)
2 ≤ d(r) ≤ b
(sofern #Elemente > 1)
GAD
SS’10
276 / 320
Suchstrukturen
(a, b)-Bäume
(a, b)-Baum
Lemma
Ein (a, b)-Baum für n Elemente hat Tiefe ≤ 1 + bloga
n+1
2 c.
Beweis.
Baum hat n + 1 Blätter
(+1 wegen ∞-Dummy)
Für n = 0 gilt die Ungleichung
(1 Dummy-Blatt, Höhe 1)
sonst hat Wurzel Grad ≥ 2,
die anderen inneren Knoten haben Grad ≥ a
⇒ Bei Tiefe t gibt es ≥ 2a t−1 Blätter
n + 1 ≥ 2a t−1
⇔
t ≤ 1 + bloga
n+1
2 c
H. Täubig (TUM)
GAD
SS’10
277 / 320
Suchstrukturen
(a, b)-Bäume
(a, b)-Baum: Split-Schlüssel
Jeder Knoten v enthält ein sortiertes Array von d(v) − 1
Split-Schlüsseln s1 , . . . , sd(v)−1
s1 s2
T1
...
sd−1
T2
Td
(a, b)-Suchbaum-Regel:
Für alle Schlüssel k in Ti und k 0 in Ti+1 gilt:
k ≤ si < k 0 bzw. si−1 < k ≤ si
H. Täubig (TUM)
GAD
(s0 = −∞, sd = ∞)
SS’10
278 / 320
Suchstrukturen
(a, b)-Bäume
(a, b)-Baum
Beispiel:
10 19
1
1
3
H. Täubig (TUM)
3
5
5
14
10
14
GAD
28
19
28
∞
SS’10
279 / 320
Suchstrukturen
(a, b)-Bäume
(a, b)-Baum
locate(9)
10 19
1
1
3
H. Täubig (TUM)
3
5
5
14
10
14
GAD
28
19
28
∞
SS’10
280 / 320
Suchstrukturen
(a, b)-Bäume
(a, b)-Baum
insert(e)
Abstieg wie bei locate(key(e)) bis Element e 0 in Liste erreicht
falls key(e 0 )>key(e), füge e vor e 0 ein
e’
H. Täubig (TUM)
GAD
∞
SS’10
281 / 320
Suchstrukturen
(a, b)-Bäume
(a, b)-Baum
insert(e)
Abstieg wie bei locate(key(e)) bis Element e 0 in Liste erreicht
falls key(e 0 )>key(e), füge e vor e 0 ein
e
H. Täubig (TUM)
e’
GAD
∞
SS’10
282 / 320
Suchstrukturen
(a, b)-Bäume
(a, b)-Baum
insert(e)
füge key(e) und Handle auf e in Baumknoten v über e ein
falls d(v) ≤ b, dann fertig
v
v
... x z ...
x
H. Täubig (TUM)
... x y z ...
y
z
e
e’
x
GAD
y
z
e
e’
SS’10
283 / 320
Suchstrukturen
(a, b)-Bäume
(a, b)-Baum
insert(e)
füge key(e) und Handle auf e in Baumknoten v über e ein
falls d(v) > b, dann teile v in zwei Knoten auf (Bsp.: a = 2, b = 4)
w
... a u z ...
... a z ...
v
x
x u u’ y
x
u
u’
e
e’
H. Täubig (TUM)
y
x
z
GAD
u’ y
u
u’
e
e’
y
z
SS’10
284 / 320
Suchstrukturen
(a, b)-Bäume
(a, b)-Baum
insert(e)
falls d(w) > b, dann teile w in zwei Knoten auf usw.
bis Grad ≤ b
oder Wurzel aufgeteilt wurde
w
... a u z ...
... a z ...
v
x
x u u’ y
x
u
u’
e
e’
H. Täubig (TUM)
y
x
z
GAD
u’ y
u
u’
e
e’
y
z
SS’10
285 / 320
Suchstrukturen
(a, b)-Bäume
(a, b)-Baum / insert
a = 2, b = 4
insert(8)
10 19
1
1
H. Täubig (TUM)
3
3
5
5
14
10
14
GAD
28
19
28
∞
SS’10
286 / 320
Suchstrukturen
(a, b)-Bäume
(a, b)-Baum / insert
a = 2, b = 4
insert(8)
10 19
1
1
H. Täubig (TUM)
3
3
5
5
14
8
8
10
GAD
14
28
19
28
∞
SS’10
287 / 320
Suchstrukturen
(a, b)-Bäume
(a, b)-Baum / insert
a = 2, b = 4
insert(8)
3
1
1
H. Täubig (TUM)
5
3
5
10 19
8
8
14
10
GAD
14
28
19
28
∞
SS’10
288 / 320
Suchstrukturen
(a, b)-Bäume
(a, b)-Baum / insert
a = 2, b = 4
insert(6)
3
1
1
H. Täubig (TUM)
5
3
5
10 19
8
8
14
10
GAD
14
28
19
28
∞
SS’10
289 / 320
Suchstrukturen
(a, b)-Bäume
(a, b)-Baum / insert
a = 2, b = 4
insert(6)
3
5
1
1
3
H. Täubig (TUM)
5
6
6
10
19
8
14
8
10
GAD
14
28
19
28
∞
SS’10
290 / 320
Suchstrukturen
(a, b)-Bäume
(a, b)-Baum / insert
a = 2, b = 4
insert(7)
3
1
1
5
3
H. Täubig (TUM)
5
6
6
10
19
8
14
8
10
GAD
14
28
19
28
∞
SS’10
291 / 320
Suchstrukturen
(a, b)-Bäume
(a, b)-Baum / insert
a = 2, b = 4
insert(7)
3
5
1
1
3
H. Täubig (TUM)
5
6
6
7
7
10 19
8
14
8
GAD
10
14
28
19
28
SS’10
∞
292 / 320
Suchstrukturen
(a, b)-Bäume
(a, b)-Baum / insert
a = 2, b = 4
insert(7)
3
1
1
5
3
H. Täubig (TUM)
5
6
7
6
10 19
7
8
8
GAD
14
10
28
14
19
28
SS’10
∞
293 / 320
Suchstrukturen
(a, b)-Bäume
(a, b)-Baum / insert
a = 2, b = 4
insert(7)
6
3
10 19
1
1
5
3
H. Täubig (TUM)
5
7
6
7
8
8
GAD
14
10
14
28
19
28
SS’10
∞
294 / 320
Suchstrukturen
(a, b)-Bäume
(a, b)-Baum / insert
Form-Invariante
durch insert erfüllt:
alle Blätter haben dieselbe Tiefe
Grad-Invariante
insert splittet Knoten mit Grad b + 1 in zwei Knoten
mit Grad d(b + 1)/2e und b(b + 1)/2c
wenn b ≥ 2a − 1, dann sind beide Werte ≥ a
wenn Wurzel Grad b + 1 erreicht, wird neue Wurzel
mit Grad 2 erzeugt
H. Täubig (TUM)
GAD
SS’10
295 / 320