UNION-FIND / 1 ADT UNION-FIND verwaltet disjunkte ZerlegungS1

UNION-FIND / 1
HEINZ NIXDORF INSTITUT
Theoretische Informatik
Friedhelm Meyer auf der Heide
ADT UNION-FIND
verwaltet disjunkte Zerlegung S1,..., Sk von V = { 1 ,...,n }
Operationen:
Make-Set (v) :
Union (x,y) :
Find-Set (x) :
Erzeugt Menge { v } mit Namen {v}
x sei in Si , y sei in Sj
→ erzeuge Si ∪ Sj , gebe der Menge
beliebigen Namen aus Si ∪ Sj ,
“zerstöre“ Si, Sj
Finde namengebendes Element
der Menge, in der x liegt.
UNION-FIND / 2
DS1: Array und Listen
HEINZ NIXDORF INSTITUT
Theoretische Informatik
Friedhelm Meyer auf der Heide
A[i] enthält Name der Menge, die i enthält
→ Find-Set benötigt Zeit O(1)
(Aber: Union benötigt Zeit
O(n))
A [1 : n]:
L(S):
Lineare Liste für Menge S, identifiziert durch
Namen von S, Size (S):
Größe von S.
Union (x,y): i = Find-Set (x) ; j = Find-Set (y) ;
(Sei (οBdA) Size (Si) >= Size (Sj)
Durchlaufe Sj und aktualisiere die zugehörigen
Einträge in A mit i .
L(Si) ← L (Si) + L(Sj)
Zeit:
Make-Set, Find-Set: O(1)
Union O(min(|S i| , |Sj|)
UNION-FIND / 3
Zeit für n-1 Unions , startend bei n
einelementigen Mengen: O(n log(n))
Zeit für Algorithmus von Kruskal:
O(|E| log |E|)
+ O(|V| log |V|)
+ O(|V|)
+ O(|E|)
= O(|E| log |E|)
(sortieren)
(n-1 mal Union)
(n mal Make-Set)
(2|E| mal Find-Set)
HEINZ NIXDORF INSTITUT
Theoretische Informatik
Friedhelm Meyer auf der Heide
UNION-FIND / 4
DS 2 :
HEINZ NIXDORF INSTITUT
Theoretische Informatik
Friedhelm Meyer auf der Heide
Bäume
Jede Menge wird als Baum verwaltet, Wurzel ist Namenselement.
Zu jedem Baum gibt es Variable Size (S)
Make-Set
Find-Set (v) : Laufe von v aus in seinem Baum zur Wurzel,
dort steht Name
Union (x,y) : i = Find-Set (x) ; j = Find-Set (y) ;
(οBdA sei size (Si) ≥ size (Sj))
Hänge Wurzel von Sj unter Wurzel von Si ;
Size (Si) ← Size (Si) + Size (Sj)
Zeit : Make-Set, Union: O(1)
Find-Set (x) : O(Tiefe des Baums in dem x liegt).
UNION-FIND / 5
HEINZ NIXDORF INSTITUT
Theoretische Informatik
Friedhelm Meyer auf der Heide
Wie tief werden die Bäume ?
Behauptung: Baum mit Tiefe d hat mind. 2 d Knoten.
→ Union benötigt Zeit O(log(n))
→ Zeit für Kruskal‘s Algorithmus wird dadurch nicht
verbessert.
UNION-FIND / 6
HEINZ NIXDORF INSTITUT
Theoretische Informatik
. Friedhelm Meyer auf der Heide
DS 3 : Bäume und Weg-Komprimierung
Wie DS 2,
aber bei FIND-SET(x) wird jeder Knoten
auf dem Weg von x zur Wurzel
direkt unter die Wurzel gehängt.
→ Zeit für FIND bleibt O(Tiefe des Baumes)
→ Aber: Zeit für n-1 Unions und f Find-SetOperationen: O((n+f ) • log*(n))
log*(n) : = min{k | z(k)≥n} , mit z(0) = 1,
Bsp: log*(n)≤5 für alle n≤265536
z(i) =2 z(i-1)
UNION-FIND / 7
HEINZ NIXDORF INSTITUT
Theoretische Informatik
Friedhelm Meyer auf der Heide
Bäume + Weg-Komprimierung
liefert Zeit O(|E| log*|E|) für Kruskals Algorithmus,
falls Kanten sortiert vorliegen.
(Vorher : Zeit O(|V|log |V| + |E|) ; für
dünne Graphen schlechter als neue DS)
Implementierung des Algorithmus
von Prim / 1
HEINZ NIXDORF INSTITUT
Theoretische Informatik
Friedhelm Meyer auf der Heide
Baum T enhalte Knoten S, R : = V - S.
Wir benötigen zu jedem x∈R eine Kante
(i,x) von S mit i∈S, die minimales Gewicht Key (x) hat.
→ Verwalte R bzgl. der Schlüssel key(x) als
Priority Queue Q.
Initialisierung: R = V, also n mal Insert (Q, x).
Pro Iteration: Extract-Min (Q) ; (Ergebnis sei x)
Decrease-Key (Q, y) für alle Nachbarn
y von x.
Implementierung des Algorithmus
von Prim / 2
O(|V| ⋅ log(|V|)
+ O(|E| log(|V|)
HEINZ NIXDORF INSTITUT
Theoretische Informatik
Friedhelm Meyer auf der Heide
(|V| mal Insert,
|V| Extract-Min)
(|E| mal Decrease-Key)
= O(|E| log(|E|)
Bessere Implementationen der Priority Queue, durch
Fibonacci-Heaps, liefern Zeit O(|E|) für alle |E| vielen
Decrease-Key-Operationen zusammen.
→ Zeit O(|V|log|V| + |E|) für Algo von Prim.