Wie verwende ich C++ Priority_queue?

How Use C Priority_queue

In C++ ist eine Warteschlange eine Listendatenstruktur, bei der das erste in die Liste aufzunehmende Element das erste zu entfernende Element ist, wenn das Entfernen erfolgen soll. Eine Prioritätswarteschlange in C++ ist ähnlich, hat aber eine gewisse Ordnung; es ist das Element mit dem größten Wert, das zuerst entfernt wird. Die Prioritätswarteschlange kann weiterhin so konfiguriert werden, dass das Element mit dem geringsten Wert zuerst entfernt wird. Jede Warteschlange muss mindestens die drücken() Funktion und die knall () Funktion. Die drücken() Funktion fügt hinten ein neues Element hinzu. Für die normale Warteschlange ist die knall () -Funktion entfernt das erste Element, das jemals eingefügt wurde. Für die Prioritätswarteschlange wird das knall () -Funktion entfernt das Element mit der höchsten Priorität, das je nach Sortierschema das größte oder kleinste sein kann.

Um die C++-Prioritätswarteschlange zu verwenden, sollte das Programm mit folgendem Code beginnen:



#enthalten
#enthalten
mit Namensraumstd;

Es schließt die Warteschlangenbibliothek in das Programm ein.



Um weiterlesen zu können, sollte der Leser über Grundkenntnisse in C++ verfügen.



Artikelinhalt

Grundkonstruktion

Die Datenstruktur muss zuerst erstellt werden, bevor sie verwendet werden kann. Konstruktion bedeutet hier das Instanziieren eines Objekts aus der Queue-Klasse der Bibliothek. Dem Queue-Objekt muss dann vom Programmierer ein Name gegeben werden. Die einfachste Syntax zum Erstellen einer Prioritätswarteschlange ist:

Prioritätswarteschlange<Typ>Warteschlangenname;

Bei dieser Syntax wird der größte Wert zuerst entfernt. Ein Beispiel für die Instanziierung ist:

Prioritätswarteschlange<int>pq;

oder



Prioritätswarteschlange<verkohlen>pq;

Der Vektor und der Deque sind zwei Datenstrukturen in C++. Mit beiden kann eine priority_queue erstellt werden. Die Syntax zum Erstellen einer Prioritätswarteschlange aus der Vektorstruktur lautet:

Prioritätswarteschlange<Typ, Vektor<gleicher Typ>, vergleichen>pq;

Ein Beispiel für diese Instanziierung ist:

Prioritätswarteschlange<int, Vektor<int>, weniger<int> >pq;

Beachten Sie die Lücke zwischen > und > am Ende der Deklaration. Dies soll Verwechslungen mit >> vermeiden. Der Standard-Vergleichscode ist kleiner, was bedeutet, dass der größte und nicht unbedingt der erste Wert zuerst entfernt wird. Die Erstellungsanweisung kann also einfach wie folgt geschrieben werden:

Prioritätswarteschlange<int, Vektor<int> >pq;

Wenn der kleinste Wert zuerst entfernt werden soll, muss die Anweisung lauten:

Prioritätswarteschlange<int, Vektor<int>, größer<int> >pq;

Wichtige Memberfunktionen

Die push()-Funktion
Diese Funktion schiebt einen Wert, der ihr Argument ist, in die priority_queue. Es kehrt leer zurück. Der folgende Code veranschaulicht dies:

Prioritätswarteschlange<int>pq;

pq.drücken(10);
pq.drücken(30);
pq.drücken(zwanzig);
pq.drücken(fünfzig);
pq.drücken(40);

Diese prioritätswarteschlange hat 5 ganzzahlige Werte in der Reihenfolge 10, 30, 20, 50, 40 erhalten. Wenn alle diese Elemente aus der Prioritätswarteschlange herausgenommen werden sollen, werden sie in der Reihenfolge 50, 40, 30, 20, 10.

Die pop()-Funktion
Diese Funktion entfernt den Wert mit der höchsten Priorität aus der priority_queue. Wenn der Vergleichscode größer ist, wird das Element mit dem kleinsten Wert entfernt. Wenn es erneut aufgerufen wird, entfernt es das nächste Element mit dem kleinsten Wert des Rests; erneut aufgerufen, entfernt es den nächstkleineren vorhandenen Wert und so weiter. Es kehrt leer zurück. Der folgende Code veranschaulicht dies:

Prioritätswarteschlange<verkohlen, Vektor<verkohlen>, größer<int> >pq;
pq.drücken('zu');pq.drücken('C');pq.drücken('B');pq.drücken('Und');pq.drücken('D');

Beachten Sie, dass zum Aufrufen einer Memberfunktion dem Namen des Objekts ein Punkt und dann die Funktion folgen muss.

Die top()-Funktion
Die knall () Funktion entfernt den nächsten Wert mit der höchsten Priorität, gibt ihn aber nicht zurück, da knall () ist eine Leerfunktion. Verwenden Sie die oben() Funktion, um den Wert mit der höchsten Priorität zu kennen, der als nächstes entfernt werden muss. Die oben() -Funktion gibt eine Kopie des Wertes mit der höchsten Priorität in der prioritäts_warteschlange zurück. Der folgende Code, bei dem der nächste Wert mit der höchsten Priorität der niedrigste Wert ist, veranschaulicht dies

Prioritätswarteschlange<verkohlen, Vektor<verkohlen>, größer<int> >pq;
pq.drücken('zu');pq.drücken('C');pq.drücken('B');pq.drücken('Und');pq.drücken('D');
verkohlench1=pq.oben();pq.Pop();
verkohlench2=pq.oben();pq.Pop();
verkohlench3=pq.oben();pq.Pop();
verkohlench4=pq.oben();pq.Pop();
verkohlench5=pq.oben();pq.Pop();

Kosten<<ch1<<''<<ch2<<''<<ch3<<''<<ch4<<''<<ch5<<' ';

Die Ausgabe ist ‚a‘ ‚b‘ ‚c‘ ‚d‘ ‚e‘.

Die empty() Funktion
Wenn ein Programmierer die oben() Funktion auf einer leeren priority_queue, nach der erfolgreichen Kompilierung würde er eine Fehlermeldung erhalten wie:

Segmentierungsfehler(kerngedumpt)

Überprüfen Sie daher immer, ob die Prioritätswarteschlange nicht leer ist, bevor Sie die oben() Funktion. Die leer() Die Memberfunktion gibt einen bool zurück, true, wenn die Warteschlange leer ist, und false, wenn die Warteschlange nicht leer ist. Der folgende Code veranschaulicht dies:

Prioritätswarteschlange<int>pq;
inti1= 10; inti2= 30; inti3= zwanzig; inti4= fünfzig; inti5= 40;
pq.drücken(i1);pq.drücken(i2);pq.drücken(i3);pq.drücken(i4);pq.drücken(i5);

während(!pq.leer())
{
Kosten <<pq.oben() << '';
pq.Pop();
}
Kosten << ' ';

Andere Funktionen der Prioritätswarteschlange

Die size() Funktion
Diese Funktion gibt die Länge der Prioritätswarteschlange zurück, wie der folgende Code veranschaulicht:

Prioritätswarteschlange<int>pq;
inti1= 10; inti2= 30; inti3= zwanzig; inti4= fünfzig; inti5= 40;
pq.drücken(i1);pq.drücken(i2);pq.drücken(i3);pq.drücken(i4);pq.drücken(i5);

intlen=pq.Größe();
Kosten <<len<< ' ';

Die Ausgabe ist 5.

Die swap()-Funktion
Wenn zwei priority_queues den gleichen Typ und die gleiche Größe haben, können sie mit dieser Funktion ausgetauscht werden, wie der folgende Code zeigt:

Prioritätswarteschlange<int>pq1;
inti1= 10; inti2= 30; inti3= zwanzig; inti4= fünfzig; inti5= 40;
pq1.drücken(i1);pq1.drücken(i2);pq1.drücken(i3);pq1.drücken(i4);pq1.drücken(i5);

Prioritätswarteschlange<int>pqA;
intes1= 1; intes2= 3; intit3= 2; intes4= 5; intes5= 4;
pqA.drücken(es1);pqA.drücken(es2);pqA.drücken(it3);pqA.drücken(es4);pqA.drücken(es5);

pq1.Tauschen(pqA);

während(!pq1.leer())
{
Kosten <<pq1.oben() << '';
pq1.Pop();
} Kosten<<' ';

während(!pqA.leer())
{
Kosten <<pqA.oben() << '';
pqA.Pop();
} Kosten<<' ';

Die Ausgabe ist:

 5  4  3  2  1
 50  40  30  20 ​​ 10

Die emplace() Funktion
Die einlagern() Die Funktion ähnelt der Push-Funktion. Der folgende Code veranschaulicht dies:

Prioritätswarteschlange<int>pq1;
inti1= 10; inti2= 30; inti3= zwanzig; inti4= fünfzig; inti5= 40;
pq1.einlagern(i1);pq1.einlagern(i2);pq1.einlagern(i3);pq1.einlagern(i4);pq1.einlagern(i5);

während(!pq1.leer())
{
Kosten <<pq1.oben() << '';
pq1.Pop();
} Kosten<<' ';

Die Ausgabe ist:

50 40 30 20 10

String-Daten

Beim Vergleichen von Strings sollte die String-Klasse verwendet werden und nicht die direkte Verwendung der String-Literale, da diese Zeiger und nicht die tatsächlichen Strings vergleichen würden. Der folgende Code zeigt, wie die String-Klasse verwendet wird:

#enthalten
Prioritätswarteschlange<Schnur>pq1;
Saite s1=Schnur('Stift'), s2=Schnur('Bleistift'), s3=Schnur('Übungsheft'), s4=Schnur('Lehrbuch'), s5=Schnur('Herrscher');

pq1.drücken(s1);pq1.drücken(s2);pq1.drücken(s3);pq1.drücken(s4);pq1.drücken(s5);
während(!pq1.leer())
{
Kosten <<pq1.oben() << '';
pq1.Pop();
} Kosten<<' ';

Die Ausgabe ist:

 Lehrbuch  Lineal  Bleistift  Stift  Übungsbuch

Andere Konstruktionen mit Prioritätswarteschlangen

Explizite Erstellung aus einem Vektor
Eine Prioritätswarteschlange kann explizit aus einem Vektor erstellt werden, wie der folgende Code zeigt:

#enthalten
Vektor<int>vtr= {10,30,zwanzig,fünfzig,40};

Prioritätswarteschlange<int>pq(vtr.Start(), vtr.Ende());

während(!pq.leer())
{
Kosten <<pq.oben() << '';
pq.Pop();
} Kosten<<' ';

Die Ausgabe lautet: 50 40 30 20 10. Diesmal muss auch der Vektorheader enthalten sein. Die Argumente für die Konstruktorfunktion übernehmen die Start- und Endzeiger des Vektors. Der Datentyp für den Vektor und der Datentyp für die priority_queue müssen gleich sein.

Um den geringsten Wert zur Priorität zu machen, wäre die Deklaration für den Konstruktor:

Prioritätswarteschlange<int, Vektor<int>, größer>int> >pq(vtr.Start(), vtr.Ende());

Explizite Erstellung aus einem Array
Eine Prioritätswarteschlange kann explizit aus einem Array erstellt werden, wie der folgende Code zeigt:

intarr[] = {10,30,zwanzig,fünfzig,40};

Prioritätswarteschlange<int>pq(arr, arr+5);

während(!pq.leer())
{
Kosten <<pq.oben() << '';
pq.Pop();
} Kosten<<' ';

Die Ausgabe lautet: 50 40 30 20 10. Die Argumente für die Konstruktorfunktion übernehmen die Start- und Endzeiger des Arrays. arr gibt den Startzeiger zurück, arr+5 gibt den Zeiger direkt hinter dem Array zurück und 5 ist die Größe des Arrays. Der Datentyp für das Array und der Datentyp für die Priority_queue müssen gleich sein.

Um den geringsten Wert zur Priorität zu machen, wäre die Deklaration für den Konstruktor:

Prioritätswarteschlange<int, Vektor<int>, größer<int> >pq(arr, arr+5);

Hinweis: In C++ wird die priority_queue eigentlich als Adapter bezeichnet, nicht nur als Container.

Benutzerdefinierter Vergleichscode

Alle Werte in der Prioritätswarteschlange aufsteigend oder alle absteigend zu haben, ist nicht die einzige Option für die Prioritätswarteschlange. Eine Liste mit 11 ganzen Zahlen für einen maximalen Heap lautet beispielsweise:

88, 86, 87, 84, 82, 79,74, 80, 81,, 64, 69

Der höchste Wert ist 88. Es folgen zwei Zahlen: 86 und 87, die kleiner als 88 sind. Der Rest der Zahlen ist kleiner als diese drei Zahlen, aber nicht wirklich in Ordnung. Die Liste enthält zwei leere Zellen. Die Zahlen 84 und 82 sind kleiner als 86. Die Zahlen 79 und 74 sind kleiner als 87. Die Zahlen 80 und 81 sind kleiner als 84. Die Zahlen 64 und 69 sind kleiner als 79.

Die Platzierung der Zahlen folgt den Max-Heap-Kriterien – siehe später. Um ein solches Schema für die priority_queue bereitzustellen, muss der Programmierer seinen eigenen Vergleichscode bereitstellen – siehe später.

Abschluss

Eine C++-Prioritätswarteschlange ist eine First-In-First-Out-Warteschlange. Die Memberfunktion, drücken(), fügt der Warteschlange einen neuen Wert hinzu. Die Memberfunktion, oben(), liest den obersten Wert in der Warteschlange. Die Memberfunktion, knall (), entfernt, ohne den obersten Wert der Warteschlange zurückzugeben. Die Memberfunktion, leer(), prüft, ob die Warteschlange leer ist. Jedoch unterscheidet sich die priority_queue von der Warteschlange darin, dass sie einem Prioritätsalgorithmus folgt. Es kann am größten sein, vom ersten bis zum letzten oder am kleinsten, vom ersten bis zum letzten. Die Kriterien (Algorithmus) können auch vom Programmierer definiert werden.