binomiale heaps - math.uni-wuppertal.deschaefer/sammlung/binomialeheaps.pdf · binomiale heaps 2....

17.01.2003 Christian John / Tobias Berger Nr.1

Binomiale Heaps


Binomiale Heaps

Gliederung:

1. Binomialer Baum

2. Binomialer Heap

3. Operationen auf Binomialen Heaps

3.1 - make-heap3.2 - minimum(h)3.3 - link(y,z)3.4 - merge(h1,h2)


Binomiale Heaps

1. Binomialer Baum = Basisstruktur für Binomiale Heaps

Definition:Für ein k>=0 definieren wir die Struktur des Binomialen Baumes:

0B

1?kB

ist ein Baum mit nur einem Knoten

entsteht aus zwei Bäumen , indem man die Wurzel des einen Baumes zum Sohn des anderenmacht

kB


Binomiale Heaps

1?kB

kBkB0B


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:

+ =

1B1B 2B0I0 + 0I0 = I00


Binomiale Heaps

Eigenschaften für Binomiale Bäume:

• besteht exakt aus 2k Knoten

• hat die Höhe k

• es ergeben sich genau 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 ,....,

Alle Knoten haben einen kleineren Grad als die Wurzel.

kB

kB

1?kB

???

????

?ik

0B


Binomiale Heaps

Beweise der Eigenschaften für Binomiale Bäume:

• besteht aus zwei Bäumen , also = 2 = 2k

• da bei der Konstruktion von ein Baum Unterbaum der

Wurzel des anderen wird, erhöht sich die Höhe von

gegenüber der von um genau 11?kB

kB

kBkB 1?kB

1?kB

1?kBkB1?kB


Binomiale Heaps


• Aufgrund der Konstruktion von ergibt sich die Anzahl der

Knoten auf Höhe i als Summe der Anzahl der Knoten auf Höhe i

in plus Anzahl der Knoten auf Höhe i -1 in

Also: + =

1?kB

kB

1?kB

???

????

? ?i

k 1???

????

???11

ik

???

????

?ik


Binomiale Heaps


• die Konstruktion von verändert nur den Ausgangsgrad der

Wurzel des rechten Teilbaumes . Dieser Grad war vor

der Konstruktion k - 1 und ist nun k, da links ein

Teilbaum hinzugekommen ist. Dieser Teilbaum ist , und die

anderen Unterbäume der Wurzel sind nach Voraussetzung

,..., 2?kB

1?kBkB

1?kB

0B


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 (Logarithmus zur Basis 2)


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.


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 , , , , lässt sich als Binärzahl wie folgt schreiben:

Ein Baum mit vier Knoten kann als Binärzahl dargestellt werden; wenn Bäume verschmelzen, gleicht dieses einer Addition von Binärzahlen.

IIII

0I00

2B 3B0B 1B


Binomiale Heaps

000I + 00I0 + 0I00 + I000 = IIII

Ein Binomialer Heap mit n Knoten besteht aus höchstens ?ld n?+1Binomialen Bäumen:

10 7

33 23

41

2

6 1725

54

47 3149

8

130B

1B

2B3B


Binomiale Heaps

Repräsentation des Heap

0

250

121

1 12

0

290

141

1 63

111

01100

380

270

180

170

01 102

Pkeydegreesiblingchild


Binomiale Heaps

3.1 make-heap()

Erzeugt einen leeren Heap. Ein leerer Heap wird einfach durch einen nil-Zeiger repräsentiert

Laufzeit: ? (1)

3. Operationen auf Binomiale Heaps


Binomiale Heaps

3.2 minimum(h)

Liefert einen Zeiger auf den Knoten mit dem kleinsten Schlüssel imHeap h. Die Wurzeln der Binomialen Bäume werden also durchsucht.

Laufzeit: ? (ld n)


Binomiale Heaps

minimum(h)

min-ptr := nil;x := head[h];min := maxint;while x <> nil doif key[x] < min thenmin := key[x];min-ptr := x;

endif;x := sibling[x];

endwhile;return min-ptr;


Binomiale Heaps

3.3 link(y,z)

Diese Funktion “linkt“ drei Zeiger von zwei Knoten um; der Knoteny wird Sohn von z: y bekommt den bisherigen Sohn von z als Bruder, bevor y selber der Sohn von z wird.

Laufzeit: ? (1)


Binomiale Heaps

link(y,z)

p[y] := z;sibling[y] := child[z];child[z] := y;degree[z] := degree[z] + 1;


Binomiale Heaps

3.4 merge(h1,h2)

Merge durchläuft beide Teilmengen sequentiell und erzeugt die Gesamtfolge sequentiell. Die Gesamtfolge ist kein BinomialerHeap.

Laufzeit: ? (ld n)


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];

elsesibling[last-ptr] := y-ptr;y-ptr := sibling[y-ptr];

last-ptr := sibling[y-ptr];


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];


Binomiale HeapsBeispiel der union-Funktion:

Heap[5]:

Heap[7]:


Binomiale HeapsInhalt

1. Operationen | Wiederholungen1.1 Binomialer Heap1.2 minimum(h)1.3 Datenstruktur eines Heapelements1.3 link (y,z)1.4 merge(h1,h2)

2. weitere Operationen2.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

1. Binomiale Heaps


Binomiale Heaps

Operationen | Wiederholungen | 1


Binomiale Heaps1.1 Binomialer Heap

1. Operationen | Wiederholungen

0001 + 0010 + 0100 + 1000 = 1111

10 7

33 23

41

2

6 1725

54

47 3149

8

13

B0 B1 B2 B3


Binomiale Heaps1.2 Datenstruktur eines Heapelements


parent

key

degree

child sibling


Binomiale Heaps1.2 Datenstruktur eines Heapelements


0

250

121

1 12

0

290

141

1 63

111

01100

380

270

180

170

01 92


Binomiale Heaps1.2 minimum(h)

Liefert einen Zeiger auf den Knoten mit dem kleinsten Schlüssel imHeap h. Die Wurzeln der Binomialen Bäume werden also durchsucht.

Laufzeit: O (ld n)



Binomiale Heaps1.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;



Binomiale Heaps1.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)



Binomiale Heaps

weitere Operationen | 2


Binomiale Heaps2.1 union(h1,h2)

2. weitere Operationen

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)

Beispiel: 1 0 0 1+ 0 1 0 1

1 1 1 0

23 22 21 20


Binomiale Heaps2.1 union(h1,h2) - BEISPIEL


Beispiel einer union-Funktion

Heap[5]: Heap[7]: Heap[13]:

Heap[13]: Heap[13]: Heap[13]:

merge()

step1 step2 step3


Binomiale Heaps2. weitere Operationen2.1 union(h1,h2) - PSEUDO CODE

h := make-heap() head[h] := merge(h1,h2)if head[h] = nil

then return hprev-x := nilx := 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-xelse sibling[prev-x] := next-x

link(x,next-x) x := next-x

next-x := sibling[x]return h


Binomiale Heaps2. weitere Operationen2.1 union(h1,h2) - AUFWAND

Aufwand :

O(1)make_heap()O(ld n)heap_merge()O(1) * ( ? ldn1 ?+ ? ldn2 ?+ 2 )while()

O(ld n)union(h1,h2)


Binomiale Heaps2.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)


Binomiale Heaps2.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;


Binomiale Heaps2.3 extract_min(h)


Liefert einen Verweis auf den Knoten mit dem kleinsten Schlüsselund entfernt diesen aus dem Heap.

Laufzeit: O (ld n)


Binomiale Heaps2.3 extract_min(h) - PSEUDO CODE


extract_min(h)

1 finde die Wurzel x mit minimalem Schlüssel in der Wurzelliste von hund 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)


Binomiale Heaps2. weitere Operationen2.3 extract_min(h) - BEISPIEL

1 3

2

Heap[7]:

x

Heap[3]:

x.child

Heap[3]:

Heap[3]:3 1

2

union()



0

250

121

113

180

x0

70

41

122

450

x.child

250

121

180

0

70

41

122

450



x.child

250

1210112

Heap[]

x.child

250

121 0112

Heap[]

x.child

250 0112

Heap[]

121

x.child

250 0112

Heap[]

121

nil

nil

Heap[] x.child

x.child x.child.sibling

temp Heap[]

Heap[].sibling temp



Heap[] x.child

x.child x.child.sibling

temp Heap[]

Heap[].sibling temp

x.child

250

121 0112

Heap[]

nil

temp

x.child

250

121 0112

Heap[]

nil

temp

x.child

250

121 0112

Heap[]

nil

temp

x.child

250

121 0112

Heap[]

nil

temp


Binomiale Heaps2.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)


Binomiale Heaps2.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

y z

z p[y]

=


Binomiale Heaps2.4 decrease_key(h,x,k) - BEISPIEL


6

10 8 14 29

16 28 13 11 17 38

7 23 77 27

42

16

16

7

16

7

10

10

7

10

7

66


Binomiale Heaps2.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)


Binomiale Heaps

Anwendungsbeispiel | 3


Binomiale Heaps

2

1

3

4

5

6

78

A B

C

D

E

3.1 minimal spannende Bäume


Gesucht: minimal spannender Baum

möglich mit binomialen Heaps?


Binomiale Heaps

2

1

3

4

5

6

78

A B

C

D

E

A16

7

A - B A - E

A - C

B58

6

B - C B - E

B - A

C3

7 4

8

C - D

C - A C - E

C - B

D2

3

D - E

D - C

E

4

1

2 5

E - A

E - D E - B

E - C




Binomiale Heaps3.1 minimal spannende Bäume - PSEUDOCODE


mst()

T <- nil

foreach Knoten vi ? V

Ei <- make_heap()union(Ei,{(vi,v):v ? E}anz = |V|

while anz > 1e = extract_min(E1)if(e.anf, e.end liegen in versch Zuskomp)

anz = anz-1T <- T+{e}union (E1, Ei)

return T

Aufwand

O( |E| * ld(|E|) )


Binomiale Heaps

2

1

3

4

5

6

78

A B

C

D

E

A16

7

A - B A - E

A - C

B58

6

B - C B - E

B - A

C3

7 4

8

C - D

C - A C - E

C - B

D2

3

D - E

D - C

E

4

1

2 5

E - A

E - D E - B

E - Canz = 5




Binomiale Heaps

A6

7

A - B

A - C

B58

6

B - C B - E

B - A

C3

7 4

8

C - D

C - A C - E

C - B

D2

3

D - E

D - C

E

4

1

2 5

E - A

E - D E - B

E - C

nil

anz = 4

A

6

7

A - B

A - C

B58

6

B - C B - E

B - A

C3

7 4

8

C - D

C - A C - E

C - B

D2

3

D - E

D - C

E

4

25

E - DE - B

E - C

nil

anz = 4

nicht in

die Liste




Binomiale Heaps

A

6

7

A - B

A - C

B58

6

B - C B - E

B - A

C3

7 4

8

C - D

C - A C - E

C - B

D E4

5

E - B

E - Cnil

anz = 3

2

3

D - E

D - C

nil

nicht in

die Liste

A

6

7

A - B

A - C

B58

6

B - C B - E

B - A

C3

7 4

8

C - D

C - A C - E

C - B

D E4

5

E - B

E - Cnil

anz = 3

3

D - Cnil




Binomiale Heaps

A

6

7

A - B

A - C

B58

6

B - C B - E

B - A

3

7 4

8

C - D

C - A C - E

C - B

D E

4

5

E - B

E - C

nilanz = 2

nilC

nil

A

6

7

A - B

A - C

B58

6

B - C B - E

B - A

74

8

C - AC - E

C - B

D

E

4

5

E - B

E - C

nil

anz = 2

nil

Cnil

nicht in

die Liste

nicht in

die Liste




Binomiale Heaps

A6

7

A - B

A - C

7

4

8

C - A

C - E

C - Banz = 2

5

E - B

D Enilnil

Cnil

B58

6

B - C B - E

B - A

A6

7

A - B

A - C

7

8

C - A

C - Banz =2

5

E - B

D Enilnil

Cnil

B58

6

B - C B - E

B - A

nicht in

die Liste




Binomiale Heaps

A6

7

A - B

A - C

7

8

C - A

C - Banz =1

D Enilnil

Cnil58

6

B - C B - E

B - A

Bnil

2

1

3

5

A B

C

D

E

minimal spannender Baum




Binomiale Heaps

Quellen:

http://www.olli.informatik.uni-oldenburg.de/BHeapA/index.html

http://www.informatik.uni-ulm.de/dbis/f&l/lehre/SS99/ProseminarSS99/BinomialHeaps.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

binomiale heaps - math.uni-wuppertal.deschaefer/sammlung/binomialeheaps.pdf · binomiale heaps 2....

Documents