Binomiale Heaps

Binomiale Heaps
17.01.2003
Christian John / Tobias Berger
Nr.1
Binomiale Heaps
Gliederung:
1. Binomialer Baum
2. Binomialer Heap
3. Operationen auf Binomialen Heaps
3.1 - make-heap
3.2 - minimum(h)
3.3 - link(y,z)
3.4 - merge(h1,h2)
17.01.2003
Christian John / Tobias Berger
Nr.2
Binomiale Heaps
1. Binomialer Baum = Basisstruktur für Binomiale Heaps
Definition:
Für ein k>=0 definieren wir die Struktur des Binomialen Baumes:
B0
ist ein Baum mit nur einem Knoten
entsteht aus zwei Bäumen Bk , indem man die
k ? 1 Wurzel des einen Baumes zum Sohn des anderen
macht
B
17.01.2003
Christian John / Tobias Berger
Nr.3
Binomiale Heaps
B0
Bk
Bk
Bk ? 1
17.01.2003
Christian John / Tobias Berger
Nr.4
Binomiale Heaps
Verschmelzung Binomialer Bäume:
Die Verschmelzung Binomialer Bäume erfolgt gleich der Addition
von Binärzahlen, wobei die Anzahl der Knoten der Bäume in
Binärzahlen dargestellt wird:
+
B1
0I0
17.01.2003
=
B2
B1
+
0I0
Christian John / Tobias Berger
=
I00
Nr.5
Binomiale Heaps
Eigenschaften für Binomiale Bäume:
Bk besteht exakt aus 2k Knoten
• Bk hat die Höhe k
•
• es ergeben sich genau
?k ?
?? ??
?i ?
Knoten in der Tiefe i mit i=0,1,2,...,k
• die Wurzel besitzt Ausgangsgrad k und die Teilbäume von links
nach rechts sind Bk ?1 ,...., B0
Alle Knoten haben einen kleineren Grad als die Wurzel.
17.01.2003
Christian John / Tobias Berger
Nr.6
Binomiale Heaps
Beweise der Eigenschaften für Binomiale Bäume:
•
•
Bk besteht aus zwei Bäumen Bk ?1 , also Bk = 2 Bk ?1 = 2k
da bei der Konstruktion von Bk ein Baum Bk ? 1 Unterbaum der
Wurzel des anderen Bk ?1 wird, erhöht sich die Höhe von Bk
gegenüber der von Bk ? 1 um genau 1
17.01.2003
Christian John / Tobias Berger
Nr.7
Binomiale Heaps
Beweise der Eigenschaften für Binomiale Bäume:
• Aufgrund der Konstruktion von
Bk ergibt sich die Anzahl der
Knoten auf Höhe i als Summe der Anzahl der Knoten auf Höhe i
in
Bk ? 1 plus Anzahl der Knoten auf Höhe i -1 in Bk ?1
Also:
17.01.2003
? k ? 1?
??
??
? i ?
+
? k ? 1?
??
??
? i ? 1?
=
?k ?
?? ??
?i ?
Christian John / Tobias Berger
Nr.8
Binomiale Heaps
Beweise der Eigenschaften für Binomiale Bäume:
Bk verändert nur den Ausgangsgrad der
Wurzel des rechten Teilbaumes Bk ? 1 . Dieser Grad war vor
• die Konstruktion von
der Konstruktion k - 1 und ist nun k, da links ein
Teilbaum hinzugekommen ist. Dieser Teilbaum ist Bk ?1 , und die
anderen Unterbäume der Wurzel sind nach Voraussetzung
Bk ? 2 ,..., B0
17.01.2003
Christian John / Tobias Berger
Nr.9
Binomiale Heaps
Korollar:
Der maximale Grad eines Knotens in einem Binomialen Baum, der
n Knoten hat, ist ld n
n = 2k
ld n = k
ld n = log2 n
17.01.2003
(Logarithmus zur Basis 2)
Christian John / Tobias Berger
Nr.10
Binomiale Heaps
2. Binomialer Heap = Eine Baumstruktur die sich aus Binomialen
Bäumen zusammensetzt; jeder Knoten enthält einen Schlüssel
Definition:
Jeder dieser Bäume ist Heap-geordnet, das heißt, der Schlüssel
eines Knotens ist kleiner/gleich der Schlüssel seiner Söhne. Es darf
kein Baum mit gleichem Grad mehrfach vorhanden sein.
17.01.2003
Christian John / Tobias Berger
Nr.11
Binomiale Heaps
Zusammenhang zwischen Binomialem Heap und Binärzahlen:
Ein Binomialer Heap, zusammengesetzt aus Binomialen Bäumen,
lässt sich als Binärzahl verwalten!
Ein Heap mit folgenden Bäumen B0 ,
Binärzahl wie folgt schreiben: IIII
B1 , B2 , B3 , lässt sich als
Ein Baum mit vier Knoten kann als Binärzahl 0I00 dargestellt
werden; wenn Bäume verschmelzen, gleicht dieses einer Addition
von Binärzahlen.
17.01.2003
Christian John / Tobias Berger
Nr.12
Binomiale Heaps
Ein Binomialer Heap mit n Knoten besteht aus höchstens ?ld n?+1
Binomialen Bäumen:
10
8
B0
13
33
B1
41
000I + 00I0
17.01.2003
7
+
2
23
B2
0I00
49
25
6
47
31
54
B3
+
I000
Christian John / Tobias Berger
17
=
IIII
Nr.13
Binomiale Heaps
Repräsentation des Heap
1010
0
01 1
2
12
1
01 6
3
25
0
18
0
11
1
27
0
child
17.01.2003
10 10
2
14
1
17
0
38
0
29
0
P
key
degree
sibling
Christian John / Tobias Berger
Nr.14
Binomiale Heaps
3. Operationen auf Binomiale Heaps
3.1 make-heap()
Erzeugt einen leeren Heap. Ein leerer Heap wird einfach durch
einen nil-Zeiger repräsentiert
Laufzeit:
17.01.2003
? (1)
Christian John / Tobias Berger
Nr.15
Binomiale Heaps
3.2 minimum(h)
Liefert einen Zeiger auf den Knoten mit dem kleinsten Schlüssel im
Heap h. Die Wurzeln der Binomialen Bäume werden also durchsucht.
Laufzeit: ? (ld n)
17.01.2003
Christian John / Tobias Berger
Nr.16
Binomiale Heaps
minimum(h)
min-ptr := nil;
x := head[h];
min := maxint;
while x <> nil do
if key[x] < min then
min := key[x];
min-ptr := x;
endif;
x := sibling[x];
endwhile;
return min-ptr;
17.01.2003
Christian John / Tobias Berger
Nr.17
Binomiale Heaps
3.3 link(y,z)
Diese Funktion “linkt“ drei Zeiger von zwei Knoten um; der Knoten
y wird Sohn von z: y bekommt den bisherigen Sohn von z als
Bruder, bevor y selber der Sohn von z wird.
Laufzeit:
17.01.2003
? (1)
Christian John / Tobias Berger
Nr.18
Binomiale Heaps
link(y,z)
p[y] := z;
sibling[y] := child[z];
child[z] := y;
degree[z] := degree[z] + 1;
17.01.2003
Christian John / Tobias Berger
Nr.19
Binomiale Heaps
3.4 merge(h1,h2)
Merge durchläuft beide Teilmengen sequentiell und erzeugt
die Gesamtfolge sequentiell. Die Gesamtfolge ist kein Binomialer
Heap.
Laufzeit: ? (ld n)
17.01.2003
Christian John / Tobias Berger
Nr.20
Binomiale Heaps
merge(h1,h2)
h-ptr := make-heap();
last-ptr := head[h];
x-ptr := head[h1];
y-ptr := head[h2];
while(x-ptr != nil && y-ptr != nil)
if(degree[x-ptr]<=degree[y-ptr])
sibling[last-ptr] := x-ptr;
x-ptr := sibling[x-ptr];
else
sibling[last-ptr] := y-ptr;
y-ptr := sibling[y-ptr];
last-ptr := sibling[y-ptr];
17.01.2003
Christian John / Tobias Berger
Nr.21
Binomiale Heaps
merge(h1,h2) 2.Teil
while(x-ptr != nil)
sibling[last-ptr] := x-ptr;
x-ptr := sibling[x-ptr];
while(y-ptr != nil)
sibling[last-ptr] := y-ptr;
y-ptr := sibling[y-ptr];
17.01.2003
Christian John / Tobias Berger
Nr.22
Binomiale Heaps
Beispiel der union-Funktion:
Heap[5]:
Heap[7]:
17.01.2003
Christian John / Tobias Berger
Nr.23
1. Binomiale Heaps
Binomiale Heaps
Inhalt
1. Operationen | Wiederholungen
1.1
Binomialer Heap
1.2
minimum(h)
1.3
Datenstruktur eines Heapelements
1.3
link (y,z)
1.4
merge(h1,h2)
2. weitere Operationen
2.1
union(h1,h2)
2.2
insert (h,x)
2.3
extract_min(h)
2.4
decrease key(h,x,k)
2.5
delete key(h,x)
3. Anwendungsbeispiel
17.01.2003
Christian John / Tobias Berger
Nr.24
Binomiale Heaps
Operationen | Wiederholungen | 1
17.01.2003
Christian John / Tobias Berger
Nr.25
1. Operationen | Wiederholungen
Binomiale Heaps
1.1 Binomialer Heap
B0
B1
10
8
13
B2
B3
7
33
2
23
41
49
25
6
47
31
17
54
0001 + 0010
17.01.2003
+
0100
+
Christian John / Tobias Berger
1000
= 1111
Nr.26
1. Operationen | Wiederholungen
Binomiale Heaps
1.2 Datenstruktur eines Heapelements
parent
key
degree
child
17.01.2003
sibling
Christian John / Tobias Berger
Nr.27
1. Operationen | Wiederholungen
Binomiale Heaps
1.2 Datenstruktur eines Heapelements
010
1
0
11
0
2
12
1
18
0
16
0
3
25
0
11
1
09
1
2
14
1
17
0
38
0
29
0
27
0
17.01.2003
Christian John / Tobias Berger
Nr.28
1. Operationen | Wiederholungen
Binomiale Heaps
1.2 minimum(h)
Liefert einen Zeiger auf den Knoten mit dem kleinsten Schlüssel im
Heap h.
Die Wurzeln der Binomialen Bäume werden also durchsucht.
Laufzeit: O (ld n)
17.01.2003
Christian John / Tobias Berger
Nr.29
1. Operationen | Wiederholungen
Binomiale Heaps
1.3 link (y,z)
Diese Funktion “linkt“ drei Zeiger von zwei Knoten um;
der Knoten y wird Sohn von z;
y bekommt den bisherigen Sohn von z als Bruder,
bevor y selber der Sohn von z wird.
Laufzeit: O (1)
link(y,z)
p[y] := z;
sibling[y] := child[z];
child[z] := y;
degree[z] := degree[z] + 1;
17.01.2003
Christian John / Tobias Berger
Nr.30
1. Operationen | Wiederholungen
Binomiale Heaps
1.4 merge(h1,h2)
merge(h1,h2) durchläuft beide Teilmengen sequentiell und
erzeugt die Gesamtfolge sequentiell.
Die Gesamtfolge ist kein Binomialer Heap.
Laufzeit: O (ld n)
17.01.2003
Christian John / Tobias Berger
Nr.31
Binomiale Heaps
weitere Operationen | 2
17.01.2003
Christian John / Tobias Berger
Nr.32
2. weitere Operationen
Binomiale Heaps
2.1 union(h1,h2)
verbindet die die zwei Heaps h1 und h2 und gibt den neuen Head h zurück
benutzt die bekannten Funktionen:
- make()
- link()
- merge()
Laufzeit: O (ld n) (siehe später)
23 22 21 20
Beispiel:
+
17.01.2003
1
0
1
0
1
1
0
0
1
1
1
0
Christian John / Tobias Berger
Nr.33
2. weitere Operationen
Binomiale Heaps
2.1 union(h1,h2) - BEISPIEL
merge()
Heap[5]:
Heap[7]:
Heap[13]:
step1
step2
Heap[13]:
Heap[13]:
step3
Heap[13]:
Beispiel einer union-Funktion
17.01.2003
Christian John / Tobias Berger
Nr.34
2. weitere Operationen
Binomiale Heaps
2.1 union(h1,h2) - PSEUDO CODE
h := make-heap()
head[h] := merge(h1,h 2)
if head[h] = nil
then return h
prev-x := nil
x := head[h]
next-x := sibling[x]
while next-x <> nil
do if (degree[x] <> degree[next-x]) or (sibling[next-x] <> nil
and degree[sibling[next-x]] = degree[x])
then prev-x := x
x := next-x
else if key[x] <= key[next-x]
then sibling[x] := sibling[next-x]
link(next-x,x)
else if prev-x = NIL
then head[H] := next-x
else sibling[prev-x] := next-x
link(x,next-x)
x := next-x
next-x := sibling[x]
return h
17.01.2003
Christian John / Tobias Berger
Nr.35
2. weitere Operationen
Binomiale Heaps
2.1 union(h1,h2) - AUFWAND
Aufwand :
17.01.2003
make_heap()
heap_merge()
while()
O(1)
O(ld n)
O(1) * ( ?ldn1 ?+ ?ldn2 ?+ 2 )
union(h1,h2)
O(ld n)
Christian John / Tobias Berger
Nr.36
2. weitere Operationen
Binomiale Heaps
2.2 insert(h,x)
Stützt sich auf union ab.
Es wird ein Heap h‘ mit x als einzigem Knoten erzeugt
und mit h vereinigt.
Laufzeit: O (ld n)
17.01.2003
Christian John / Tobias Berger
Nr.37
2. weitere Operationen
Binomiale Heaps
2.2 insert(h,x) - PSEUDO CODE
insert(h,x)
h‘ := make-heap();
p[x] := nil;
child[x] := nil;
sibling := nil;
degree[x] := 0;
head[h‘] := x;
h := union(h, h‘);
return h;
17.01.2003
Christian John / Tobias Berger
Nr.38
2. weitere Operationen
Binomiale Heaps
2.3 extract_min(h)
Liefert einen Verweis auf den Knoten mit dem kleinsten Schlüssel
und entfernt diesen aus dem Heap.
Laufzeit: O (ld n)
17.01.2003
Christian John / Tobias Berger
Nr.39
2. weitere Operationen
Binomiale Heaps
2.3 extract_min(h) - PSEUDO CODE
extract_min(h)
1 finde die Wurzel x mit minimalem Schlüssel in der Wurzelliste von h
und entferne x aus der Wurzelliste;
2 h‘ := make-heap();
3 kehre die Reihenfolge der verketteten Söhne von x um
und setzte head[h‘] auf den Kopf der umgedrehten Liste;
4 h := union(h, h‘);
5 return h
Laufzeit: O(ld n)
17.01.2003
Christian John / Tobias Berger
Nr.40
2. weitere Operationen
Binomiale Heaps
2.3 extract_min(h) - BEISPIEL
Heap[7]:
Heap[3]:
x
Heap[3]:
x.child
Heap[3]:
3
1
3
1
2
2
union()
17.01.2003
Christian John / Tobias Berger
Nr.41
2. weitere Operationen
Binomiale Heaps
2.3 extract_min(h) - BEISPIEL
x
x.child
013
1
2
12
1
7
0
18
0
02
1
4
1
45
0
17.01.2003
25
0
2
12
1
7
0
18
0
02
1
4
1
25
0
45
0
Christian John / Tobias Berger
Nr.42
2. weitere Operationen
Binomiale Heaps
2.3 extract_min(h) - BEISPIEL
x.child
Heap[]
nil
012
1
12
1
25
0
x.child
12
1
25
0
temp
Heap[]
Heap[]
x.child
x.child
x.child.sibling
Heap[].sibling
temp
Heap[]
1
12
0
Heap[]
x.child
25
0
x.child
12
1
012
1
Heap[]
nil
25
0
17.01.2003
12
1
012
1
Christian John / Tobias Berger
Nr.43
2. weitere Operationen
Binomiale Heaps
2.3 extract_min(h) - BEISPIEL
x.child
12
1
25
0
Heap[]
1
12
0
x.child
12
1
temp
Heap[]
Heap[]
x.child
x.child
x.child.sibling
Heap[].sibling
temp
25
0
25
0
17.01.2003
25
0
Christian John / Tobias Berger
temp
1
12
0
nil
Heap[]
temp
1
12
0
x.child
12
1
nil
Heap[]
x.child
12
1
temp
nil
Heap[]
temp
1
12
0
nil
Nr.44
2. weitere Operationen
Binomiale Heaps
2.4 decrease_key(h,x,k)
Gegeben: Element z, dessen Schlüssel man verkleinern will
Wenn der neue Wert k kleiner ist als der bisherige x, wird z so oft mit
seinem Vater getauscht, bis der Wert des Vater kleiner ist als k oder z
die Wurzel ist.
Dieses wird gemacht um die Heapstruktur wieder herzustellen.
Laufzeit: O(ld n)
17.01.2003
Christian John / Tobias Berger
Nr.45
2. weitere Operationen
Binomiale Heaps
2.4 decrease_key(h,x,k)
if k > key[x]
then error „new key is greater than current key“
key[x]
k
y
x
z
p[y]
while z
= nil
and key[y] < key[z]
do exchange key[y]
key[z]
//if y and z have satellite fields,exchange them,too
17.01.2003
y
z
z
p[y]
Christian John / Tobias Berger
Nr.46
2. weitere Operationen
Binomiale Heaps
2.4 decrease_key(h,x,k) - BEISPIEL
6
10
7
16
7
16
10
7
28
23
77
13
11
8
14
17
38
29
27
42
17.01.2003
Christian John / Tobias Berger
Nr.47
2. weitere Operationen
Binomiale Heaps
2.5 delete_key(h,x)
Gegeben: Element x, welches wir löschen wollen
Setze Wert von z auf decrease_key()
delete_minimum
Laufzeit: O(ld n)
17.01.2003
Christian John / Tobias Berger
Nr.48
Binomiale Heaps
Anwendungsbeispiel | 3
17.01.2003
Christian John / Tobias Berger
Nr.49
3. Anwendungsbeispiel Binomiale Heaps
3.1 minimal spannende Bäume
D
2
3
Gesucht: minimal spannender Baum
möglich mit binomialen Heaps?
4
E
5
C
7
1
8
A
B
6
17.01.2003
Christian John / Tobias Berger
Nr.50
3. Anwendungsbeispiel Binomiale Heaps
3.1 minimal spannende Bäume
D
2
3
4
E
C
5
7
1
8
A
B
6
A
6
1
A- B
A- E
7
A- C
B
8
5
B-C
B-E
6
B-A
C
3
2
E
1
C-D
D-E
7
4
3
2
5
C-A
C-E
D-C
E-D
E-B
8
C-B
17.01.2003
D
Christian John / Tobias Berger
E-A
4
E-C
Nr.51
3. Anwendungsbeispiel Binomiale Heaps
3.1 minimal spannende Bäume - PSEUDOCODE
mst()
Aufwand
T <- nil
O( |E| * ld(|E|) )
foreach Knoten vi ? V
Ei <- make_heap()
union(Ei,{(vi,v):v ? E}
anz = |V|
while anz > 1
e = extract_min(E1)
if(e.anf, e.end liegen in versch Zuskomp)
anz = anz-1
T <- T+{e}
union (E1, Ei)
return T
17.01.2003
Christian John / Tobias Berger
Nr.52
3. Anwendungsbeispiel Binomiale Heaps
3.1 minimal spannende Bäume
D
2
3
4
E
C
5
7
1
8
A
B
6
A
6
1
A- B
A- E
7
A- C
B
8
5
B-C
B-E
6
B-A
C
3
17.01.2003
2
E
1
C-D
D-E
7
4
3
2
5
C-A
C-E
D-C
E-D
E-B
8
anz = 5
D
C-B
Christian John / Tobias Berger
E-A
4
E-C
Nr.53
3. Anwendungsbeispiel Binomiale Heaps
3.1 minimal spannende Bäume
A
6
1
A- B
E-A
7
2
5
A- C
E-D
E-B
A
5
B-C
B-E
C
6
B-A
nicht in
E-B
E-D
6
4
A- B
E-C
A- C
17.01.2003
D
2
C-D
D-E
7
4
3
C-A
C-E
D-C
E
nil
C-B
2
7
3
8
E-C
5
anz = 4
8
die Liste
4
anz = 4
B
B
8
5
B-C
B-E
6
B-A
C
3
D
2
C-D
D-E
7
4
3
C-A
C-E
D-C
E
nil
8
C-B
Christian John / Tobias Berger
Nr.54
3. Anwendungsbeispiel Binomiale Heaps
3.1 minimal spannende Bäume
A
2
4
D-E
E-C
3
6
5
D-C
A- B
E-B
A
5
B-C
B-E
C
6
B-A
nicht in
D-C
E-C
6
5
A- B
E-B
A- C
17.01.2003
D
E
nil
nil
7
4
C-A
C-E
8
C-B
4
7
3
C-D
A- C
3
anz = 3
8
die Liste
7
anz = 3
B
B
8
5
B-C
B-E
6
B-A
C
3
D
E
nil
nil
C-D
7
4
C-A
C-E
8
C-B
Christian John / Tobias Berger
Nr.55
3. Anwendungsbeispiel Binomiale Heaps
3.1 minimal spannende Bäume
A
B
3
anz = 2
C-D
4
7
4
E-C
C-A
C-E
6
5
8
A- B
E-B
C-B
7
C
8
5
B-C
B-E
D
nil
E
nil
nil
6
B-A
nicht in
die Liste
A
4
7
4
C-E
C-A
E-C
B
8
5
B-C
B-E
C
nil
D
A- C
8
6
5
C-B
A- B
E-B
7
anz = 2
17.01.2003
nil
6
nicht in
B-A
E
nil
die Liste
A- C
Christian John / Tobias Berger
Nr.56
3. Anwendungsbeispiel Binomiale Heaps
3.1 minimal spannende Bäume
A
4
6
C-E
A- B
5
7
7
E-B
C-A
A- C
A
8
5
B-C
B-E
C
D
nil
E
nil
nil
6
B-A
nicht in
die Liste
8
anz = 2
B
C-B
5
6
E-B
A- B
B
8
5
B-C
B-E
7
7
6
C-A
A- C
B-A
C
D
nil
E
nil
nil
8
anz =2
C-B
17.01.2003
Christian John / Tobias Berger
Nr.57
3. Anwendungsbeispiel Binomiale Heaps
3.1 minimal spannende Bäume
A
8
5
6
B-C
B-E
A- B
6
7
7
B-A
C-A
A- C
B
C
nil
D
nil
E
nil
nil
8
anz =1
C-B
D
2
3
E
C
1
minimal spannender Baum
5
A
17.01.2003
B
Christian John / Tobias Berger
Nr.58
Binomiale Heaps
Quellen:
http://www.olli.informatik.uni-oldenburg.de/BHeapA/index.html
http://www.informatik.uniulm.de/dbis/f&l/lehre/SS99/ProseminarSS99/BinomialHeap
s.pdf
http://www.uni-paderborn.de/cs/heiss/lehre/ws97/
ausarbeitungen/marquardt.ps.gz
http://www.informatik.uni-bonn.de/~meinard/papers/
Misc/merzenich98.ps
17.01.2003
Christian John / Tobias Berger
Nr.59