Prioritätswarteschlangen

Präsentation zum Thema: "Prioritätswarteschlangen"—  Präsentation transkript:

1 Prioritätswarteschlangen
In vielen Anwendungen müssen Datensätze mit Schlüsseln der Reihe nach verarbeitet werden, doch nicht unbedingt in einer vollständig sortierten Reihenfolge und nicht unbedingt auf einmal. Eine geeignete Datenstruktur muss unter solchen Bedingungen die Eigenschaft haben, dass sie die Operationen des Einfügens eines neuen Elementes und des Löschen des größten Elementes unterstützt. Eine derartige Datenstruktur, die Schlangen (Löschen des ältesten Elements) und Stapeln(Löschen des neuesten Elements) gegenüber gestellt werden kann, wird Prioritätswarteschlange (priority queue) genannt. Diese kann man sich als Verallgemeinerung des Stapels und der Schlange vorstellen.

2 Anwendungsbeispiele für Prioritätswarteschlangen:
- Simulationssysteme, wo die Schlüssel den „Ereigniszeiten“ entsprechen könnten, die der Reihe nach verarbeitet werden müssen - das Job-Scheduling in Computersystemen, wo die Schlüssel den „Prioritäten“ entsprechen könnten, die angeben, welche Benutzer zuerst bedient werden und - numerische Berechnungen, wo die Schlüssel Berechnungsfehler sein können, so dass der größte zuerst bearbeitet werden kann. Prioritätswarteschlangen können als Basis für verschiedene fundamentale Algorithmen zum Durchsuchen von Graphen dienen. Der Hauptgrund der Nützlichkeit von Prioritätswarte-schlangen besteht in ihrer Flexibilität, da sie die Möglichkeit geben, eine Vielzahl verschiedenartiger Operationen mit Mengen von Datensätzen mit Schlüsseln effizient auszuführen.

3 Aufbau und Unterhaltung einer Datenstruktur,
die Datensätze mit numerischen Schlüsseln (Prioritäten) enthält und einige der folgenden Operationen unterstützt: - Aufbauen (construct) einer Prioritätswarteschlange aus N gegebenen Elementen. - Einfügen (insert) eines neuen Elements. - Entfernen (remove) des größten Elements. - Ersetzen (replace) des größten Elements durch ein neues Element (außer, wenn das neue Element größer ist). - Verändern (change) der Priorität eines Elements. - Löschen (delete) eines beliebigen angegebenen Elements. - Zusammenfügen (join) von zwei Prioritätswarteschlangen zu einer neuen, größeren.

4 Die Operation replace entspricht fast einem insert,
gefolgt von remove, (wobei der Unterschied darin besteht, dass die Prioritätswarteschlange sich vorübergehend um ein Element verlängert); das ist etwas anderes, als wenn einem remove ein insert folgt. In ähnlicher Weise könnte die Operation change als ein delete implementiert werden, dem insert folgt, und construct könnte mit wiederholter Benutzung der Operation insert implementiert werden. Die Operation join erfordert für eine effiziente Implementierung höherentwickelte Datenstrukturen. Hier wird eine klassische Datenstruktur, die Heap genannt wird, behandelt und die effiziente Implementationen der ersten fünf Operationen ermöglicht.

5 Elementare Implementationen
Die Prioritätswarteschlange ist ein ausgezeichnetes Beispiel einer abstrakten Datenstruktur. Sie ist mittels der Operationen, die auf ihr ausgeführt werden , eindeutig definiert, unabhängig davon, wie die Daten in irgendeiner speziellen Implementation organisiert und verarbeitet werden. Elementare Implementationen Eine Methode der Organisation einer Prioritäts-warteschlange ist eine ungeordnete Liste, wobei die Elemente einfach in einem Feld a [1] , ..., a [N] aufbewahrt werden, ohne die Schlüssel zu beachten. Hiermit lassen sich construct, insert und remove leicht implementieren. (Reservierung von a[0] und evtl. a[N+1] für Markenwerte).

6 static int a [maxN + 1], N; construct (int b[], int M) { for ( N = 1; N <= M; N++ ) a [N] = b[N]; } insert (int v) { a[++ N] = v ; } int remove ( ) { int j , max, v ; max = 1 ; for ( j = 2 ; j <= N ; j++ ) if ( a [j] > a [max]) max = j ; v = a [max]; a [max] = a[N --]; return v ; }

7 Die Operation construct ist lediglich eine Feldkopie
und für insert inkrementiert man einfach N und legt das neue Element in a [N] ab, wobei diese Operation eine konstante Zeit benötigt. Remove erfordert dagegen das Durchsuchen des Feldes, um das Element mit dem größten Schlüssel zu finden, wofür eine lineare Zeit benötigt wird ( alle Elemente im Feld müssen betrachtet werden), danach das Vertauschen von a[N] mit dem Element mit dem größten Schlüssel und das Dekrementieren von N. Die Implementation von replace ist ähnlich. Um die Operation change zu implementieren (Verändern der Priorität des Elements in a [k]), kann man einfach den neuen Wert speichern, und um das Element in a[k] zu löschen (delete), kann man es, wie in der letzten Zeile von remove, mit a [N] vertauschen und N dekrementieren.

8 Eine andere elementare Form der Organisation,
die benutzt werden kann, ist eine geordnete Liste, wobei wiederum ein Feld a [1] , ... , a [N] verwendet wird, die Elemente jedoch entsprechend der wachsenden Reihenfolge ihrer Schlüssel aufbewahrt werden. Jeder Algorithmus für Prioritätswarteschlangen kann in einen Sortieralgorithmus umgewandelt werden, in dem wiederholt insert benutzt wird, um eine Prioritätswarte-schlange zu erzeugen, die alle zu sortierenden Elemente enthält, und indem danach wiederholt remove benutzt wird, um die Prioritätswarteschlange zu leeren, wobei die Elemente in umgekehrter Reihenfolge erhalten werden. Die Benutzung einer als ungeordnete Liste dargestellten Prioritätswarteschlange entspricht somit Selection Sort, und die Verwendung einer geordneten Liste entspricht Insertion Sort.

9 Anstelle der oben angegebenen Implementation mit Hilfe
eines Feldes können auch verkettete Listen für die ungeordnete Liste oder die geordnete Liste verwendet werden. Die ändert nichts an den grundlegenden Merkmalen der Leistungsfähigkeit für insert, remove oder replace, gibt jedoch die Möglichkeit, delete und join in konstanter Zeit auszuführen. Es lohnt sich diese einfachen Implementationen zu merken, da sie in der Praxis kompliziertere Methoden überlegen sein können. Beispiel: ungeordnete Liste günstig, wenn nur wenig remove-Operationen, jedoch sehr viele Einfügungen ausgeführt werden, geordnete Liste ist geeignet, wenn bei den einzufügenden Elementen immer zu erwarten ist, dass sie dem größten Element in der Prioritätswarteschlange nahe kommen.

10 Die Datenstruktur des Heaps
Die Datenstruktur, die man verwendet, um die Operationen mit Prioritätswarteschlangen zu ermöglichen, beinhaltet das Speichern der Datensätze in einem Feld so, dass jeder Schlüssel garantiert größer ist als die Schlüssel auf zwei bestimmten anderen Positionen. Jeder dieser Schlüssel muss wiederum größer sein als zwei weitere Schlüssel usw. Diese Ordnung lässt sich sehr leicht veranschaulichen, in dem man das Feld in Form einer zweidimensionalen Baumstruktur zeichnet, wobei von jedem Knoten Linien nach unten zu den beiden Knoten führen, von denen bekannt ist, dass sie kleiner sind. Diese Struktur wird „vollständiger binärer Baum“ genannt.

11 Diese Struktur kann erzeugt werden, in dem ein Knoten
(Wurzel genannt) gezeichnet wird und dann nach unten und von links nach rechts fortgefahren wird, in dem jeweils zwei Knoten unter einem Knoten der vorangehenden Ebene gezeichnet und mit ihm verbunden werden, bis N Knoten gezeichnet worden sind. Die beiden Knoten unter jedem Knoten werden dessen (direkte) Nachfolger (children) genannt, der Knoten über jedem Knoten heißt dessen (direkter) Vorgänger (parent). Forderung: Die Schlüssel im Baum müssen der Heap-Bedingung genügen: Der Schlüssel in jedem Knoten soll größer sein (oder gleich) als die Schlüssel in seinen Nachfolgern (falls er Nachfolger besitzt). Daraus folgt, dass sich der größte Schlüssel in der Wurzel befindet.

12 Darstellung eines Heaps als vollständiger Baum
1 X G O T A R S E I M N 2 3 4 5 6 7 8 9 10 11 12 Darstellung: vollständiger binärer Bäume sequentiell innerhalb eines Feldes: - die Wurzel auf Position 1 setzen, - ihre Nachfolger auf die Positionen 2 und 3, - die Knoten der nachfolgenden Ebene auf die Positionen 4, 5, 6 und 7 usw.

13 Darstellung eines Heaps als Feld
k a [k] X G O T A N M S I R E Diese Darstellungsform ist sehr nützlich, da es sehr leicht ist, von einem Knoten zu seinem Vorgänger und zu seinen Nachfolgern zu gelangen. - Der Vorgänger des Knotens auf Position j befindet sich auf Position j/2 ( abgerundet auf die nächste ganze Zahl, falls j ungerade ist ), und - die beiden Nachfolger des Knotens auf Position j befinden sich auf den Positionen 2j und 2j + 1. Dadurch ist die Traversierung des Baumes sehr einfach. Ein Heap ist ein als ein Feld dargestellter vollständiger binärer Baum, in dem jeder Knoten der Heap-Bedingung genügt. Insbesondere befindet sich der größte Schlüssel stets auf der ersten Position im Feld.

14 Alle Algorithmen operieren entlang eines Pfades (path)
von der Wurzel zum unteren Ende des Heaps (indem sie sich einfach vom Vorgänger zum Nachfolger oder umgekehrt bewegen). In einem Heap mit N Knoten befinden sich auf allen Pfaden etwa lgN Knoten. Es gibt etwa N/2 Knoten auf der untersten Ebene N/4 Knoten mit direkten Nachfolgern auf der untersten Ebene N/8 Knoten mit „Enkeln“ auf der untersten Ebene usw. Jede „Generation“ besitzt halb so viele Knoten wie die nächste, woraus folgt, dass höchstens lg N Generationen existieren können. Folglich können alle Operationen mit Prioritätswarteschlangen (mit Ausnahme von join ) bei Verwendung von Heaps in logarithmischer Zeit ausgeführt werden.

15 Algorithmen mit Heaps Die Algorithmen für Prioritätswarteschlangen unter Verwendung von Heaps laufen alle in der Weise ab, dass sie zuerst eine einfache Strukturänderung vornehmen, welche die Heap-Bedingung verletzen könnte, und anschließend den Heap durchlaufen und ihn so modifizieren, dass die Erfüllung der Heap-Bedingung überall gewährleistet ist. Einige Algorithmen durchlaufen den Heap von der untersten Ebene zur Spitze, andere von der Spitze nach unten. Bei allen Algorithmen wird vorausgesetzt, dass die Datensätze aus einem Wort bestehende ganzzahlige Schlüssel sind, die in einem Feld a von einer maximalen Größe gespeichert sind, wobei die aktuelle Größe des Heaps in einer ganzen Zahl N gespeichert ist.

16 Einfügen eines neuen Elements ( P ) in einen Heap
X G P T A R S E I O N M

17 Aufbau eines Heaps - Implementierung der Operation insert - Inkrementierung von N (da sich die Größe des Heaps um 1 erhöht) - Ablegen des einzufügenden Datensatzes in a[N] - falls die Heap-Bedingung verletzt ist (der neue Knoten ist größer als sein Vorgänge), Austausch der Knoten - falls immer noch Verletzung der Heap-Bedingung, dann wieder Austausch der Knoten usw. bis alle Knoten in der geforderten Reihenfolge liegen.

18 Beispiel-Programm In diesem Programm fügt insert ein neues Element in a[N] ein und ruft dann upheap (N) auf, um die Verletzung der Heap-Bedingung in N zu korrigieren. upheap ( int k) { int v ; v = a [k] ; a [0] = INT_MAX; while (a [k/2] <= v) { a [k] = a [k/2] ; k = k/2 ; } a [k] = v ; } insert (int v) { a [++ N] = v ; upheap (N) ; }

19 Die replace-Operation erfordert das Ersetzen des Schlüssels
bei der Wurzel durch einen neuen Schlüssel und danach die Bewegung im Heap von oben nach unten, um die Heap-Bedingung wieder herzustellen. Die Operation „remove the largest“ (Entfernen des größten Elements) erfordert nahezu den gleichen Prozess. Da der Heap nach der Operation ein Element weniger haben wird, ist es erforderlich, N zu dekrementieren. Im Mittelpunkt der Implementation dieser beiden Operationen steht der Prozess der Korrektur eines Heap, in dem die Heap-Bedingung überall erfüllt ist, außer möglicherweise an der Wurzel. Wenn der Schlüssel an der Wurzel zu klein ist, muss er im Heap nach unten bewegt werden, ohne dass dabei die Heap-Bedingung bei irgendeinem der berührten Knoten verletzt wird.

20 Weitere Implementationen sind:
downheap (int k) { int j, v ; v = A [k]; while ( k <= N/2 ) { j = k + k ; if ( j < N && a [j] < a [j+1] ) j++ ; if ( v >= a[j] ) break; a [k] = a [j]; k = j ; } a [k] = v ; } Diese Prozedur bewegt sich im Heap nach unten, wobei der Knoten auf Position k, falls erforderlich, mit dem größeren seiner beiden Nachfolger, ausgetauscht wird. Dieser Prozess bricht ab, wenn der Knoten auf Position k größer ist als beide Nachfolger oder wenn die unterste Ebene erreicht ist.

21 Bei der remove-Operation wird folgende Implementation
angewendet: int remove ( ) { int v= a[1] ; a[1] = a[N --] ; downheap (1) ; return v ; } Die Implementation der replace-Operation hat folgende Form: int replace (int v) { a[0] = v ; downheap (0) ; return a[0] ; }

22 Eigenschaften des Heap:
Alle grundlegenden Operationen insert, remove, replace, (downheap und upheap), delete und change erfordern weniger als 2 lg N Vergleiche, wenn sie für einen Heap mit N Elementen ausgeführt werden. Alle diese Operationen beinhalten eine Bewegung längs eines Pfades zwischen der Wurzel und der untersten Ebene des Heap, welcher für einen Heap der Größe N nicht mehr als lg N Elemente umfasst. Der Faktor 2 entsteht durch downheap, welches in seiner inneren Schleife zwei Vergleiche ausführt; die anderen Operationen erfordern nur lg N Vergleiche.

23 Heapsort Auf der Grundlage der bisher dargestellten grundlegenden Operationen mit Heaps kann eine elegante und effiziente Sortiermethode definiert werden. Diese Heapsort genannte Methode, verwendet keinen zusätzlichen Speicherplatz und garantiert, dass M Elemente in ungefähr M log M Schritten sortiert werden, unabhängig von den Eingabedaten. Die Idee besteht darin, einen Heap aufzubauen, der die zu sortierenden Elemente enthält, und sie danach alle in der richtigen Reihenfolge zu entfernen. Eine Möglichkeit des Sortierens besteht darin, die Elemente nacheinander in einen ursprünglich leeren Heap einzufügen, wie in den ersten zwei Zeilen des folgenden Codes (welche in Wirklichkeit nur construct (a, N) implementiert), und danach n remove-Operationen auszuführen, wobei das entfernte Element auf den Platz gesetzt wird, der von dem sich verkleinernden Heap gerade freigegeben wurde.

24 heapsort (int a [], int N )
{ int k; construct (a, 0); for ( k = 1 ; k <= N ; k++) insert ( a [k] ) ; for (k = N; k >= 1; k --) a [k] = remove ( ) ; } A S S T O . . . A S A O . . . A R I Beispiel: ASORTINGEXAMPLE

25 Vollständiger Heap , wenn die Schlüssel in der angegebenen Reihenfolge in einen ursprünglich leeren Heap eingefügt werden. X G P T A R S E I O N M L In Wirklichkeit ist es besser, den Heap aufzubauen, in dem man ihn rückwärts durchläuft und kleine Heaps von unten her erzeugt. Bei dieser Methode wird jede Position im Feld als Wurzel eines kleinen Heaps betrachtet, und es wird die Tatsache ausgenutzt, dass downheap für solche kleinen Heaps ebenso gut arbeitet wie für den großen Heap. Indem der Heap rückwärts durchlaufen wird, ist jeder Knoten die Wurzel eines Heaps, für den die Heap-Bedingung erfüllt ist.

26 remove kann implementiert werden,
in dem zunächst das erste und das letzte Element vertauscht werden, dann N dekrementiert und schließlich downheap (1) aufgerufen wird. Dies führt zu folgender Implementation von Heapsort: heapsort ( int a [ ] , int N ) { int k, t ; for ( k = N / 2 ; k >= 1 ; k -- ) downheap (a, N , k ) ; while ( N > 1) { t = a [ 1 ] ; a [1] = a [N] ; a [N] = t ; downheap (a , --N, 1 ) ; }

27 Eigenschaft: Bottom Up Aufbau eines Heaps erfolgt in linearer Zeit.
Der Grund für diese Eigenschaft besteht darin, dass die meisten bearbeiteten Heaps klein sind. Um zum Beispiel einen Heap aus 127 Elementen aufzubauen, ruft die Methode dawnheap für (64 Heaps der Größe 1), 32 Heaps der Größe 3, 16 Heaps der Größe 7, 8 Heaps der Größe 15, 4 Heaps der Größe 31, 2 Heaps der Größe 63 und einen Heap der Größe 127 auf, so dass im ungünstigsten Fall 64 * * * * * * * 6 = 120 „Übertragungen“ (doppelt so viele Vergleiche ) benötigt werden. Für N = 2 ist eine obere Schranke für die Anzahl der Vergleiche durch  (k - 1 ) 2 n - k = 2 n - n - 1 < N gegeben. Ein ähnlicher Beweis gilt, wenn N keine Zweierpotenz ist. 1  k  n

28 Eigenschaft: Heapsort benötigt für das Sortieren von
N Elementen weniger als 2N lg N Vergleiche. Durch diese Eigenschaft ist Heapsort von praktischem Interesse. Die Anzahl der benötigten Schritte für das Sortieren von N Elementen ist für beliebige Eingabedaten garantiert proportional zu N log N. Im Unterschied zu anderen behandelten Methoden gibt es keine „ungünstigen“ Eingabedaten, bei denen Heapsort langsamer abläuft.

29 Indirekte Heaps Bei vielen Anwendungen von Prioritätswarteschlangen möchte man die Datensätze nicht verschieben. Stattdessen möchte man, dass die Prioritätswarteschlangen-Routine nicht Werte zurück gibt, sondern anzeigt, welcher der Datensätze der größte ist. Das ist mit der schon beschriebenen Idee des „indirekten Sortierens“ oder des „Pointer Sort“ (Zeiger-Sortieren) vergleichbar. Es ist zweckmäßig, Heaps auf diese Art zu nutzen. Hier arbeiten die Prioritätswarteschlangen-Routinen, anstatt die Schlüssel im Feld a umzuordnen, mit einem Feld p von Indizes, die sich auf das Feld a beziehen. a [p[k]] ist somit der Datensatz, der dem k-ten Element des Heap entspricht, für 1  k  N .

30 Indirekte Heap-Datenstrukturen
Außerdem wird ein Feld q eingeführt, in dem die Heap-Position des k-ten Elements des Feldes gespeichert wird, damit werden die Operationen delete und change ermöglicht. Der Eintrag von q für das größte Element im Feld ist die Zahl 1. Indirekte Heap-Datenstrukturen k a [k] X R P T G N O S M A E I L p[k] a [p[k]] q[k] Die Implementationen werden entsprechend modifiziert.

31 Weiterentwickelte Implementationen der join-Operation
Wenn die join-Operation effizient ausgeführt werden muss, sind die bisher angegebenen Implementationen unzureichend und es werden weiter entwickelte Techniken benötigt. Unter „effizient“ verstehen wir, dass join ungefähr in der gleichen Zeit ausgeführt werden sollte wie die anderen Operationen. Die bisherigen Methoden scheiden aus, da zwei große Heaps nur zusammen gefügt werden können, indem alle Elemente mindestens eines Heaps in ein großer Feld bewegt werden. Bei einer direkten Darstellung mit Verkettungen müßten in jedem Knoten Verkettungen vorgesehen werden, die auf den Vorgänger und beide Nachfolger zeigen. Es erweist sich, dass die Heap-Bedingung selbst zu stark zu sein scheint, als dass eine effiziente Implementation der join-Operation möglich wäre. Alle höherentwickelten Daten-strukturen, die zur Lösung dieses Problems bestimmt sind, schwächen entweder die Heap-Bedingung oder die Ausgewogenheits-Bedingung ab, um die für join benötigte Flexibilität zu erhalten. Diese Strukturen gestatten die Ausführung aller Operationen in logarithmischer Zeit.