Die Präsentation wird geladen. Bitte warten

Die Präsentation wird geladen. Bitte warten

01.04.2004(c) W. Conen, FH GE, GIN21 GIN2 – 2. Vorlesung, SS04 Prof. Dr. Wolfram Conen 1.4.2004 Rund um Dijkstra: - Bucket/Radix-Sort - Priority Queues.

Ähnliche Präsentationen


Präsentation zum Thema: "01.04.2004(c) W. Conen, FH GE, GIN21 GIN2 – 2. Vorlesung, SS04 Prof. Dr. Wolfram Conen 1.4.2004 Rund um Dijkstra: - Bucket/Radix-Sort - Priority Queues."—  Präsentation transkript:

1 (c) W. Conen, FH GE, GIN21 GIN2 – 2. Vorlesung, SS04 Prof. Dr. Wolfram Conen Rund um Dijkstra: - Bucket/Radix-Sort - Priority Queues - Heap

2 (c) W. Conen, FH GE, GIN22 Schnelles Sortieren Situation: n (Schlüssel-)Werte aus [1,n] Keine Duplikate. Kosten? O(n)

3 (c) W. Conen, FH GE, GIN23 Schnelles Sortieren: BucketSort Töpfe: Ergebnis: Situation: m Töpfe, Schlüsselwerte aus [1,m], Duplikate

4 (c) W. Conen, FH GE, GIN24 Schneller Sortieren: BucketSort in mehreren Phasen (Radixsort) Situation: n Werte aus [0,,n k -1], Duplikate möglich Kosten normaler Bucketsort: O(n+n k ) Idee: Wir wenden ihn mehrfach an! Beispiel: n Werte aus [0,,n 2 -1], m = n 1.Phase: Wert i einfügen in B k mit k = Wert i MOD m 2.Phase: Ergebnisliste durchlaufen, Wert i nach B k mit k = Wert i DIV m, dort am ENDE anfügen

5 (c) W. Conen, FH GE, GIN25 Schneller Sortieren: BucketSort in mehreren Phasen Beispiel: n = 10, Werte aus [0,,99], 1. Phase 3 MOD 10 = 3 18 MOD 10 = 8 Töpfe: Ergebnis 1. Phase:

6 (c) W. Conen, FH GE, GIN26 Schneller Sortieren: BucketSort in mehreren Phasen Beispiel: n = 10, Werte aus [0,,99], 2. Phase 60 DIV 10 = 6 18 DIV 10 = 1 Töpfe: 60 Ergebnis:

7 (c) W. Conen, FH GE, GIN27 Bucket/Radix Sort: Review Wenn wir die Größe des Schlüsselbereichs als Konstante ansehen, dann sortieren wir zu Kosten von O(n) Aus einer sortieren Folge können wir zu Kosten von O(1) das minimale Element finden und entnehmen Aber Dijkstra verändert ja auch noch die Distanz-Werte der Knoten...

8 (c) W. Conen, FH GE, GIN28 Priority Queues INSERT: Warteschlangen, in die Elemente gemäß einer Priorität eingeordnet werden DELETE MIN: Es wird jeweils das Element höchster Priorität entnommen (das soll das Element mit dem minimalen Wert sein) Für uns noch wichtig: DECREASE KEY – der Wert eines Knotens verringert sich! Das sind genau die Operationen, die wir im Dijkstra brauchen: Initialer Aufbau des Queues (INSERT), Updates der Knotenwerte (DECREASE KEY), Entnahme des besten Knotens (DELETE MIN)

9 (c) W. Conen, FH GE, GIN29 Priority Queues Genauer: –INSERT(Q,v): Füge Knoten v mit Wert Wert(v) in Priority-Queue Q ein –(Q,v*) Ã DELETE MIN(Q): Liefere den Knoten mit dem minimalen Wert und lösche ihn aus dem Priority- Queue Q, liefere Q zurück –Q Ã DECREASE KEY(Q,v,Wert): Verringere den (Schlüssel-)Wert des Knotens v auf Wert.

10 (c) W. Conen, FH GE, GIN210 Priority Queues: Implementierung Wie kann man das effizient implementieren? Z.B. mittels eines sogenannte Heaps! (wir betrachten zunächst nur die Operationen INSERT und DELETE MIN) Was ist ein Heap (=Haufen)? Das ist ein partiell- geordneter Baum: Definition: Ein partiell-geordneter (binärer) Baum ist ein knotenmarkierter binärer Baum T, in dem für jeden Teilbaum T´ mit Wurzel w gilt: 8 y 2 T´: Wert(w) · Wert(y)

11 (c) W. Conen, FH GE, GIN211 Partiell-geordneter Baum (Schlüssel-)Werte: Alle Wurzeln erfüllen die Bedingung! Ist der Baum eindeutig?

12 (c) W. Conen, FH GE, GIN212 Partiell-geordneter Baum (Schlüssel-)Werte: Alle Wurzeln erfüllen die Bedingung! Aber der Baum ist nicht mehr balanciert!

13 (c) W. Conen, FH GE, GIN213 Heap: INSERT Algorithm INSERT(Q,v) Füge v auf der ersten freien Position der untersten Ebene ein (wenn voll, neue Ebene beginnen) p à Vater(v) Solange p existiert und Wert(v) < Wert(p) tue Vertausche die Werte von p und v; v à p; p à Vater(p) Wir betrachten links- vollständige partiell geordnete Bäume: –alle Ebenen bis auf die letzte sind voll besetzt –auf der letzten Ebene sitzen die Knoten soweit links wie möglich

14 (c) W. Conen, FH GE, GIN214 Heap: INSERT Algorithm INSERT(Q,v) Füge v auf der ersten freien Position der untersten Ebene ein (wenn voll, neue Ebene beginnen) p à Vater(v) Solange p existiert und Wert(v) < Wert(p) tue Vertausche die Werte von p und v; v à p; p à Vater(p) Einfügen von p ! à và v Wert(v) < Wert(p)? Klar! Also: Vertauschen!

15 (c) W. Conen, FH GE, GIN215 Heap: INSERT Algorithm INSERT(Q,v) Füge v auf der ersten freien Position der untersten Ebene ein (wenn voll, neue Ebene beginnen) p à Vater(v) Solange p existiert und Wert(v) < Wert(p) tue Vertausche die Werte von p und v; v à p; p à Vater(p) Einfügen von v ! à pà p Wert(v) < Wert(p)? Klar! Also: Vertauschen!

16 (c) W. Conen, FH GE, GIN216 Heap: INSERT Algorithm INSERT(Q,v) Füge v auf der ersten freien Position der untersten Ebene ein (wenn voll, neue Ebene beginnen) p à Vater(v) Solange p existiert und Wert(v) < Wert(p) tue Vertausche die Werte von p und v; v à p; p à Vater(p) Einfügen von p ! à và v Wert(v) < Wert(p)? Nein! Also: Fertig!

17 (c) W. Conen, FH GE, GIN217 Heap: INSERT Ist INSERT korrekt? Wir betrachten eine einzelne Vertauschung der Werte von v und p, es gilt also Wert(v) < Wert(p). Wert(p) ist minimal bzgl. aller Unterbäume von p (und damit aller Unterbäume von v – das gilt auch nach dem Positionswechsel!) Wg. Wert(v) < Wert(p) ist dann auchWert(v) nach Vertauschung minimal für alle Unterbäume, also ist der neue Baum partiell geordnet (unter der Annahme, dass der Ausgangsbaum partiell geordnet war). Algorithm INSERT(Q,v) Füge v auf der ersten freien Position der untersten Ebene ein (wenn voll, neue Ebene beginnen) p à Vater(v) Solange p existiert und Wert(v) < Wert(p) tue Vertausche die Werte von p und v; v à p; p à Vater(p)

18 (c) W. Conen, FH GE, GIN218 Heap: DELETE MIN Algorithm DELETE MIN (Q): (Q, Min) Sei w die Wurzel des Heaps mit den Söhnen s 1, s 2 ; Min à Wert(w) Sei k der letzte Knoten (unten, rechts) Wert(w) à Wert(k); Lösche k; Solange s 1 oder s 2 existieren und (Wert(w) > Wert(s 1 ) oder Wert(w) > Wert(s 2 )) tue Vertausche den Wert von w mit dem kleineren Wert der beiden Söhne, dieser Sohn sei s; w à s; s 1 à Linker_Sohn(w); s 2 à Rechter_Sohn(w) Gib Q und Min zurück. Entfernen des Minimums: w ! à kà k

19 (c) W. Conen, FH GE, GIN219 Heap: DELETE MIN Algorithm DELETE MIN (Q): (Q, Min) Sei w die Wurzel des Heaps mit den Söhnen s 1, s 2 ; Min à Wert(w) Sei k der letzte Knoten (unten, rechts) Wert(w) à Wert(k); Lösche k; Solange s 1 oder s 2 existieren und (Wert(w) > Wert(s 1 ) oder Wert(w) > Wert(s 2 )) tue Vertausche den Wert von w mit dem kleineren Wert der beiden Söhne, dieser Sohn sei s; w à s; s 1 à Linker_Sohn(w); s 2 à Rechter_Sohn(w) Gib Q und Min zurück. Entfernen des Minimums: w ! s1 !s1 !s2 !s2 ! Bedingung für s = s 1 erfüllt! Also: Tauschen s =

20 (c) W. Conen, FH GE, GIN220 Heap: DELETE MIN Algorithm DELETE MIN (Q): (Q, Min) Sei w die Wurzel des Heaps mit den Söhnen s 1, s 2 ; Min à Wert(w) Sei k der letzte Knoten (unten, rechts) Wert(w) à Wert(k); Lösche k; Solange s 1 oder s 2 existieren und (Wert(w) > Wert(s 1 ) oder Wert(w) > Wert(s 2 )) tue Vertausche den Wert von w mit dem kleineren Wert der beiden Söhne, dieser Sohn sei s; w à s; s 1 à Linker_Sohn(w); s 2 à Rechter_Sohn(w) Gib Q und Min zurück. Entfernen des Minimums: w ! Bedingung nicht erfüllt! Also: Fertig! s1 !s1 !s2 !s2 !

21 (c) W. Conen, FH GE, GIN221 Heap: DELETE MIN Ist DELETE MIN korrekt? Wir betrachten eine einzelne vertauschung der Werte von w und s, es gilt also Wert(s) < Wert(w). Wert(s) ist minimal bzgl. aller Unterbäume von s. Es wurde ausgewählt, also ist es auch minimal im Vergleich zum anderen Kind-Baum – das gilt auch nach dem Positionswechsel!) w ist möglicherweise nicht minimal für seinen Unterbaum. Das wird aber weiterbehandelt (w sinkt dann weiter!) bis schließlich Wert(w) · Wert(s1) und Wert(w) · Wert(s2). Algorithm DELETE MIN (Q): (Q, Min) Sei w die Wurzel des Heaps mit den Söhnen s 1, s 2 ; Min à Wert(w) Sei k der letzte Knoten (unten, rechts) Wert(w) à Wert(k); Lösche k; Solange s 1 oder s 2 existieren und (Wert(w) > Wert(s 1 ) oder Wert(w) > Wert(s 2 )) tue Vertausche den Wert von w mit dem kleineren Wert der beiden Söhne, dieser Sohn sei s; w à s; s 1 à Linker_Sohn(w); s 2 à Rechter_Sohn(w) Gib Q und Min zurück.

22 (c) W. Conen, FH GE, GIN222 Priority Queue Mit dem Heap lassen sich INSERT und DELETE MIN mit Aufwand O(log n) realisieren! Das gleiche gilt für Updates, also DECREASE KEY- Operationen (analog zu INSERT plus schnelles Auffinden, kommt noch)! Damit können wir (für sparsam besetzte Graphen) Dijkstra verbessern! Wie es noch besser geht: s. Tarjan bzw. die nächste Veranstaltung


Herunterladen ppt "01.04.2004(c) W. Conen, FH GE, GIN21 GIN2 – 2. Vorlesung, SS04 Prof. Dr. Wolfram Conen 1.4.2004 Rund um Dijkstra: - Bucket/Radix-Sort - Priority Queues."

Ähnliche Präsentationen


Google-Anzeigen