So verwenden Sie C ++ Priority_queue?

In C ++ ist eine Warteschlange eine Listendatenstruktur, in der das erste Element, das in die Liste gesteckt wird. Eine vorrangige Warteschlange in C ++ ist ähnlich, hat aber eine gewisse Bestellung; Es ist das Element mit dem größten Wert, der zuerst entfernt wird. Die vorrangige Warteschlange kann weiterhin so konfiguriert werden, dass es das Element mit dem geringsten Wert ist, der zuerst entfernt wird. Jede Warteschlange muss mindestens die haben drücken() Funktion und die Pop() Funktion. Der drücken() Funktion fügt ein neues Element auf der Rückseite hinzu. Für die normale Warteschlange die Pop() Funktion entfernt das erste Element, das jemals eingedrückt wurde. Für die vorrangige Warteschlange die Pop() Die Funktion entfernt das Element mit höchster Priorität, die je nach Bestellschema der größte oder kleinste sein könnte.

Um das C ++ - Priority_queue zu verwenden, sollte das Programm mit Code wie folgt beginnen:

#enthalten
#enthalten
Verwenden von Namespace STD;

Es enthält die Warteschlangenbibliothek in das Programm.

Um weiter zu lesen, hätte der Leser grundlegende Kenntnisse über C haben sollen++.

Artikelinhalt

• Grundkonstruktion
• Wichtige Mitgliedsfunktionen
• Andere Prioritätswarteschlangenfunktionen
• String -Daten
• Andere vorrangige Warteschlangenkonstruktionen
• Abschluss

Grundkonstruktion

Die Datenstruktur muss zuerst konstruiert werden, bevor sie verwendet werden kann. Die Konstruktion hier bedeutet, ein Objekt aus der Warteschlangenklasse der Bibliothek zu instanziieren. Das Warteschlangenobjekt muss dann vom Programmierer einen Namen geben. Die einfachste Syntax, um eine Prioritätswarteschlange zu erstellen, ist:

Prioritätswarteschlange Queuename;

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

Prioritätswarteschlange pq;

oder

Prioritätswarteschlange pq;

Der Vektor und der Deque sind zwei Datenstrukturen in C++. Ein Priority_queue kann mit beiden erstellt werden. Die Syntax, um eine vorrangige Warteschlange aus der Vektorstruktur zu erstellen, lautet:

Prioritätswarteschlange, vergleiche> pq;

Ein Beispiel für diese Instanziierung ist:

Prioritätswarteschlange, weniger > PQ;

Beachten Sie die Lücke zwischen> und> am Ende der Erklärung. Dies soll Verwirrung mit >> verhindern. Der Standardvergleichscode ist „weniger“, was bedeutet, dass der größte und nicht unbedingt der erste Wert zuerst entfernt wird. Die Erstellungserklärung kann also einfach geschrieben werden wie:

Prioritätswarteschlange > PQ;

Wenn der geringste Wert zuerst entfernt werden soll, muss die Erklärung sein:

Prioritätswarteschlange, größer > PQ;

Wichtige Mitgliedsfunktionen

Die PUSP () -Funktion
Diese Funktion drückt einen Wert, das sein Argument ist, in die Priority_queue. Es kehrt ungültig zurück. Der folgende Code zeigt dies:

Prioritätswarteschlange pq;
pq.Push (10);
pq.Push (30);
pq.Push (20);
pq.Push (50);
pq.Push (40);

Dieser Priority_queue hat 5 Ganzzahlwerte in der Reihenfolge von 10, 30, 20, 50, 40 erhalten. Wenn all diese Elemente aus der vorrangigen Warteschlange herausgekommen werden sollen, werden sie in der Größenordnung von 50, 40, 30, 20, 10 herauskommen.

Die Pop () -Funktion
Diese Funktion entfernt den Wert Priority_queue mit der höchsten Priorität. Wenn der Vergleichscode „größer“ ist, wird das Element mit dem kleinsten Wert entfernt. Wenn es erneut aufgerufen wird, wird das nächste Element mit dem kleinsten Wert des Restes entfernt. Wieder aufgerufen, es entfernt den nächst kleinsten Wert, das vorhanden ist, und so weiter. Es kehrt ungültig zurück. Der folgende Code zeigt dies:

Prioritätswarteschlange, größer > PQ;
pq.pushen ('a');
pq.Push ('C');
pq.Push ('B');
pq.Push ('e');
pq.Push ('D');

Beachten Sie, dass der Name des Objekts, um eine Mitgliedsfunktion aufzurufen, von einem Punkt und dann der Funktion folgen muss.

Die obere () Funktion
Der Pop() Funktion beseitigt den nächsten Wert der höchsten Priorität, gibt ihn jedoch nicht zurück, als Pop() ist eine void -Funktion. Benutze die Spitze() Funktion, um den Wert der höchsten Priorität zu kennen, der als nächstes entfernt werden muss. Der Spitze() Die Funktion gibt eine Kopie des Wertes mit höchster Priorität im Priority_Queue zurück. Der folgende Code, bei dem der nächste Wert der höchsten Priorität der geringste Wert ist, zeigt dies

Prioritätswarteschlange, größer > PQ;
pq.pushen ('a'); pq.Push ('C'); pq.Push ('B'); pq.Push ('e'); pq.Push ('D');
char ch1 = pq.Spitze(); pq.Pop();
char ch2 = pq.Spitze(); pq.Pop();
char ch3 = pq.Spitze(); pq.Pop();
char ch4 = pq.Spitze(); pq.Pop();
char ch5 = pq.Spitze(); pq.Pop();
Cout<

Der Ausgang ist 'A "B" C "D" E'.

Die leere () -Funktion
Wenn ein Programmierer die verwendet Spitze() Funktionieren Sie nach der erfolgreichen Zusammenstellung eine Fehlermeldung wie:

Segmentierungsfehler (Core Dumped)

Überprüfen Sie also immer, ob die vorrangige Warteschlange nicht leer ist, bevor Sie die verwenden Spitze() Funktion. Der leer() Die Mitgliedsfunktion gibt einen Bool zurück, wahr, wenn die Warteschlange leer ist, und falsch, wenn die Warteschlange nicht leer ist. Der folgende Code zeigt dies:

Prioritätswarteschlange pq;
int i1 = 10; int i2 = 30; int i3 = 20; int i4 = 50; int i5 = 40;
pq.pushen (i1); pq.pushen (i2); pq.pushen (i3); pq.pushen (i4); pq.pushen (i5);
während(!pq.leer())

Cout << pq.top() << ";
pq.Pop();

Cout << '\n';

Andere Prioritätswarteschlangenfunktionen

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

Prioritätswarteschlange pq;
int i1 = 10; int i2 = 30; int i3 = 20; int i4 = 50; int i5 = 40;
pq.pushen (i1); pq.pushen (i2); pq.pushen (i3); pq.pushen (i4); pq.pushen (i5);
int len ​​= pq.Größe();
Cout << len << '\n';

Der Ausgang ist 5.

Die SWAP () -Funktion
Wenn zwei Priority_queues von gleicher Art und Größe sind, können sie durch diese Funktion ausgetauscht werden, wie der folgende Code zeigt:

Prioritätswarteschlange pq1;
int i1 = 10; int i2 = 30; int i3 = 20; int i4 = 50; int i5 = 40;
PQ1.pushen (i1); PQ1.pushen (i2); PQ1.pushen (i3); PQ1.pushen (i4); PQ1.pushen (i5);
Prioritätswarteschlange PQA;
int it1 = 1; int it2 = 3; int it3 = 2; int it4 = 5; int it5 = 4;
PQA.pushen (it1); PQA.pushen (it2); PQA.pushen (it3); PQA.pushen (it4); PQA.pushen (it5);
PQ1.Swap (PQA);
während(!PQ1.leer())

Cout << pq1.top() << ";
PQ1.Pop();
cout<<'\n';
während(!PQA.leer())

Cout << pqA.top() << ";
PQA.Pop();
cout<<'\n';

Die Ausgabe ist:

5 4 3 2 1
50 40 30 20 10

Die emplace () fuktion
Der empace () Die Funktion ähnelt der Push -Funktion. Der folgende Code zeigt dies:

Prioritätswarteschlange pq1;
int i1 = 10; int i2 = 30; int i3 = 20; int i4 = 50; int i5 = 40;
PQ1.Emplace (i1);
PQ1.Emplace (i2);
PQ1.Emplace (i3);
PQ1.Emplace (i4);
PQ1.Emplace (i5);
während(!PQ1.leer())

Cout << pq1.top() << ";
PQ1.Pop();
cout<<'\n';

Die Ausgabe ist:

50 40 30 20 10

String -Daten

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

#enthalten
Prioritätswarteschlange pq1;
String S1 = String ("Pen"),
S2 = String ("Bleistift"),
S3 = String ("Übungsbuch"),
S4 = String ("Lehrbuch"),
S5 = String ("Herrscher");
PQ1.Push (S1);
PQ1.Push (S2);
PQ1.Push (S3);
PQ1.Push (S4);
PQ1.Push (S5);
während(!PQ1.leer())

Cout << pq1.top() << " ";
PQ1.Pop();
cout<<'\n';

Die Ausgabe ist:

Lehrbuch Herrscher Bleistiftpenst -Übungsbuch

Andere vorrangige Warteschlangenkonstruktionen

Explizite Schöpfung aus einem Vektor
Eine vorrangige Warteschlange kann aus einem Vektor explizit erstellt werden, wie der folgende Code zeigt:

#enthalten
Vektor vtr = 10, 30, 20, 50, 40;
Prioritätswarteschlange PQ (vtr.begin (), vtr.Ende());
während(!pq.leer())

Cout << pq.top() << ";
pq.Pop();
cout<<'\n';

Der Ausgang ist: 50 40 30 20 10 10. Diesmal muss auch der Vektorheader enthalten sein. Die Argumente für die Konstruktorfunktion nehmen die Start- und Endzeiger des Vektors an. 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 Erklärung für den Konstruktor:

Prioritätswarteschlange, Greater> int>> pq (vtr.begin (), vtr.Ende());

Explizite Schöpfung aus einem Array
Eine vorrangige Warteschlange kann explizit aus einem Array erstellt werden, wie der folgende Code zeigt:

int arr [] = 10, 30, 20, 50, 40;
Prioritätswarteschlange PQ (arr, arr+5);
während(!pq.leer())

Cout << pq.top() << ";
pq.Pop();
cout<<'\n';

Der Ausgang ist: 50 40 30 20 10 10. Die Argumente für die Konstruktorfunktion nehmen 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 Erklärung für den Konstruktor:

Prioritätswarteschlange, größer > PQ (arr, arr+5);

Hinweis: In C ++ wird der Priority_queue tatsächlich als Adapter bezeichnet, nicht nur ein Container.

Custom -Vergleichen Code

Es ist nicht die einzige Option für die Prioritätswarteschlange, alle Werte in der Prioritätswarteschlange aufzusteigen oder alle absteigend. Beispielsweise lautet eine Liste von 11 Ganzzahlen für einen maximalen Haufen:

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

Der höchste Wert beträgt 88. Es folgen zwei Zahlen: 86 und 87, die weniger als 88 sind. Der Rest der Zahlen ist geringer als diese drei Zahlen, aber nicht wirklich in Ordnung. Es gibt zwei leere Zellen in der Liste. Die Zahlen 84 und 82 sind weniger als 86. Die Zahlen 79 und 74 sind weniger als 87. Die Zahlen 80 und 81 sind weniger als 84. Die Zahlen 64 und 69 sind weniger 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 Vergleichencode bereitstellen - siehe später.

Abschluss

A C ++ Priority_Queue ist eine erste in der ersten Warteschlange. Die Mitgliedsfunktion, drücken(), Fügt der Warteschlange einen neuen Wert hinzu. Die Mitgliedsfunktion, Spitze(), liest den Top -Wert in der Warteschlange. Die Mitgliedsfunktion, Pop(), Entfernt, ohne den Top -Wert der Warteschlange zurückzugeben. Die Mitgliedsfunktion, leer(), Überprüft, ob die Warteschlange leer ist. Der Priority_Queue unterscheidet sich jedoch von der Warteschlange, da sie einige Prioritätsalgorithmus folgt. Es kann am größten von zuerst bis zuletzt oder am wenigsten von zuerst bis zuletzt sein. Die Kriterien (Algorithmus) können auch Programmierer definiert werden.