k √ l k -Level-Buckets.Diesebestehendannaus k ArraysderLänge DieVerallgemeinerungvon2-Level-Bucketsführtzu EADS7.1Buckets276/530 ľ 7.1.3 C ErnstW.Mayr .DadurchlassensichdieSpeicher-undZeitkomplexitätweiterverbessern,derImplementierungsaufwandsteigtjedo

(1)

7.1.3 k-Level-Buckets

Die Verallgemeinerung von 2-Level-Buckets f¨ uhrt zu

k-Level-Buckets. Diese bestehen dann aus k Arrays der L¨ ange

l

√

k

C

m

. Dadurch lassen sich die Speicher- und Zeitkomplexit¨ at

weiter verbessern, der Implementierungsaufwand steigt jedoch

stark an.

(2)

7.2 van Emde Boas-Priority Queues Universum U , |U | = N, U ⊂

N

. Hier: U = {0, 1, . . . , N − 1}.

Wir untersuchen hier eine bessere Priority Queue f¨ ur den Fall

n ≥ log N .

(3)

. . . . . .

0 N −1

0 1 1 0 . . . 1 0 . . . 1

- - - - q

q A

A U

q

?

q

?

· · · ·

O

Delete

. . . . . .

0 N −1

0 1 1 0 . . . 0 0 . . . 1

- - -

q

q A

A U

q

· · · ·

? HH

@@ @@

Insert Baum mit √

N Verzweigungen

(4)

Notation

Sei

k ∈

N

, k ≥ 2 k

⁰

=

k 2

k

⁰⁰

= k

2 x ∈ [0..2

^k

− 1] (x hat ≤ k Bits) x

⁰

=

j

x 2

^k⁰⁰

k

(x

⁰

vordere H¨ alfte von x) x

⁰⁰

= x mod 2

^k⁰⁰

(x

⁰⁰

hintere H¨ alfte von x) Sei

S = {x

₁

, . . . , x

m

} ⊆ [0..2

^k

− 1] .

(5)

Definition 66

Eine k-Struktur T f¨ ur S besteht aus:

1

der Zahl T.size = |{x

₁

, . . . , x

_m

}| = |S| = m;

2

einer doppelt verketteten Liste T.list, die die Elemente von S in aufsteigender Reihenfolge enth¨ alt;

3

einem Bitvektor T.b[0..2

^k

− 1] mit T.b[i] =

⁰₁

, falls

^i6∈S_i∈S

einem Zeiger (Pointer) Vektor T.p[0 . . . 2

^k

− 1]. Falls T.b[i] = 1, dann zeigt T.p[i] auf i in der Liste aus 2.

4

einer k

⁰

-Struktur T.top und einem Feld T.bottom[0 . . . 2

^k⁰

− 1]

von k

⁰⁰

-Strukturen. Falls m = 1, dann T.top, T.bottom und

die zugeh¨ origen k

⁰⁰

-Strukturen leer, T.size = 1. T.list = {x},

der Bitvektor wird nicht ben¨ otigt. Falls m > 1, dann ist T.top

eine k

⁰

-Struktur f¨ ur die durch {x

⁰₁

, x

⁰₂

, . . . , x

⁰_m

} gegebene

Menge, und f¨ ur jedes y ∈ [0 . . . 2

^k⁰

− 1] ist T.bottom[y] eine

k

⁰⁰

-Struktur f¨ ur die Menge {x

⁰⁰_i

; 1 ≤ i ≤ m; y = x

⁰_i

}

(6)

Beispiel 67

k = 4, S = {2, 3, 7, 10, 13}, T.size = 5:

T.p ⊥ ⊥ ⊥ ⊥ ⊥ ⊥ ⊥ ⊥ ⊥ ⊥ ⊥

0 N −1

T.b 0 0 1 1 0 0 0 1 0 0 1 0 0 1 0 0

2 0010

3 0011

7 0111

10 1010

13 1101

- - - -

q

q A

A U

q

? q

T.list

?

T.top ist 2-Struktur f¨ ur {0, 1, 2, 3}

T.bottom[0] ist eine 2-Struktur f¨ ur {2, 3}

T.bottom[1] ist eine 2-Struktur f¨ ur {3}

T.bottom[2] ist eine 2-Struktur f¨ ur {2}

T.bottom[3] ist eine 2-Struktur f¨ ur {1}

(7)

Operation Succ(x) findet min{y ∈ S; y > x} in der k-Struktur T.

if k = 1 or T.Size ≤ 2 then naive Suche

elif x ≥ max in T.list then return Succ(x) gibt’s nicht else

x

⁰

:=

j

x 2^k⁰⁰

k

; x

⁰⁰

:= x mod 2

^k⁰⁰

;

if T.top.b[x

⁰

] = 1 and x

⁰⁰

< max{T.bottom[x

⁰

]} then return x

⁰

· 2

^k⁰⁰

+ Succ(x

⁰⁰

, T.bottom[x

⁰

])

else

z

⁰

:=Succ(x

⁰

, T.top); return z

⁰

· 2

^k⁰⁰

+ min{T.bottom[z

⁰

]}

fi

(8)

JJ

HH HH H H

J J J J J J

JJ

T.top

T.Bottom[0]

T.Bottom[1]

T.Bottom

h

2

^k

0

− 1

i

2

^k

0

x

succ(x)

−−−−→

(9)

Kosten:

T(k) ≤ c + T(

k 2

) = O(log k) .

Lemma 68

Die Succ-Operation hat Zeitbedarf O(log k).

Beweis:

√

(10)

Insert Operation:

falls x bereits in Priority Queue, dann fertig bestimme Succ(x, T), f¨ uge x davor ein bestimme x

⁰

und x

⁰⁰

behandle die entsprechenden Unterstrukturen rekursiv:

Insert(x

⁰

,T.top), Insert(x

⁰⁰

,T.bottom[x

⁰

]) (nur ein nicht trivialer rekursiver Aufruf)

Zeitbedarf: naiv O(log

²

k), Optimierung: das oberste Succ tut

alles ⇒ O(log k).

(11)

Delete Operation:

Komplexit¨ at von Delete in k-Struktur: O(log k)

Kosten der Initialisierung: ∼ Gr¨ oße der Datenstruktur

(12)

Platzbedarf f¨ ur k-Struktur: Sei S(k) der Platzbedarf f¨ ur eine k-Struktur. Dann gilt:

S(1) = c

S(k) = c2

^k

+ S(k

⁰

) + 2

^k⁰

S(k

⁰⁰

) f¨ ur k ≥ 2 Wir ersetzen zur Vereinfachung:

S(k) = c2

^k

+ S( k

2 ) + 2

^k²

S( k

2 )

(13)

Lemma 69

S(k) = O(2

^k

· log k)

Beweis:

Zeige: S(k) := c

⁰

2

^k

log k funktioniert.

F¨ ur k = 1 ist das klar.

(14)

Beweis (Forts.):

Rekursionsschritt:

Platz f¨ ur k-Struktur ≤ c2

^k

+ c

⁰

2

^k²

(log k − 1) + 2

^k²

c

⁰

2

^k²

(log k − 1)

= c2

^k

+ c

⁰

2

^k²

(1 + 2

^k²

)(log k − 1)

= c2

^k

+ c

⁰

2

^k²

(2

^k²

log k + log k − 2

^k²

− 1)

≤ c2

^k

+ c

⁰

2

^k²

(2

^k²

log k + log k − 2

^k²

)

≤ c

⁰

2

^k

log k , falls

c2

^k

+ c

⁰

2

^k

log k + c

⁰

2

^k²

log k − c

⁰

2

^k

≤ c

⁰

2

^k

log k

⇔ c

⁰

2

^k²

log k ≤ (c

⁰

− c)2

^k

⇔ c

⁰

− c

c

⁰

≥ log k

2

^k

(gilt f¨ ur c

⁰

groß genug.)

(15)

Satz 70

Sei N = 2

^k

, Universum U = {0, . . . , N − 1}. Wird eine Teilmenge S ⊆ U durch eine k-Struktur dargestellt, dann ben¨ otigen die Operationen Insert, Delete und FindMin jeweils Zeit O(log log N ), die Initialisierung Zeit O(N log log N ). Der Platzbedarf ist

ebenfalls O(N log log N ).

Beweis:

s.o.

(16)

Literatur zu van Emde Boas-Priority Queue:

Kurt Mehlhorn:

Data structures and algorithms 1: Sorting and searching, pp. 290–296,

EATCS Monographs on Theoretical Computer Science, Springer Verlag: Berlin-Heidelberg-New York-Tokyo, 1984

P. van Emde Boas, R. Kaas, E. Zijlstra:

Design and implementation of an efficient priority queue

Math. Systems Theory 10 (1976), pp. 99–127

(17)

7.3 Radix-Heaps

Radix-Heaps stellen eine M¨ oglichkeit zur effizienten Realisierung von Priority Queues dar, wobei ¨ ahnliche Randbedingungen wie bei den 2-Level-Buckets vorausgesetzt werden. Dabei wird die

amortisierte Laufzeit der langsamsten Zugriffsfunktion im Vergleich zu diesen verbessert, n¨ amlich von O( √

C) auf O(log C). C bezeichne wie bei den 2-Level-Buckets die maximale Differenz zwischen zwei Schl¨ usseln im Heap.

Die Grundidee besteht darin, anstelle einer Hierarchie von Buckets

konstanter Gr¨ oße solche mit exponentiell zunehmender Gr¨ oße zu

verwenden. Somit sind nur noch O(log C) Buckets zur Verwaltung

der Elemente im Heap n¨ otig. Wie bei 2-Level-Buckets h¨ angt die

Laufzeit der “teueren“ Operationen direkt von der Anzahl der

Buckets ab.

(18)

pppppppppppppppppppp

0 1 2 4 8 16

1

z }| {

1

z }| {

2

z }| {

4

z }| {

8

z }| {

B = dlog(C + 1)e + 1 Buckets Randbedingungen:

Schl¨ ussel ∈

N0

max. Schl¨ ussel − min. Schl¨ ussel stets ≤ C

Monotonie von ExtractMin

(19)

Implementierung:

B := dlog(C + 1)e + 1 Buckets b[0..B − 1]

(untere) Schranken f¨ ur Buckets u[0..B]

Index b no[x] des aktuellen Buckets f¨ ur x Invarianten:

i)

u[i] ≤ Schl¨ ussel in b[i] < u[i + 1]

ii)

u[0] = 0, u[1] = u[0] + 1, u[B] = ∞;

0 ≤ u[i + 1] − u[i] ≤ 2

ⁱ⁻¹