C++ Priority_queue gebruiken?

In C++ is een wachtrij een lijstgegevensstructuur waarbij het eerste element dat in de lijst moet worden geplaatst, het eerste element is dat moet worden verwijderd, wanneer verwijdering moet plaatsvinden. Een prioriteitswachtrij in C++ is vergelijkbaar, maar heeft enige ordening; het is het element met de grootste waarde dat als eerste wordt verwijderd. De prioriteitswachtrij kan nog steeds zo worden geconfigureerd dat het het element met de minste waarde is dat als eerste wordt verwijderd. Elke wachtrij moet minimaal de . hebben Duwen() functie en de knal() functie. De Duwen() functie voegt een nieuw element toe aan de achterkant. Voor de normale wachtrij, de knal() functie verwijdert het eerste element dat ooit is ingedrukt. Voor de prioriteitswachtrij, de knal() functie verwijdert het element met de hoogste prioriteit, wat de grootste of de kleinste kan zijn, afhankelijk van het bestelschema.

Om de C++ priority_queue te gebruiken, zou het programma moeten beginnen met code zoals:

#include
#include
namespace std; gebruiken;

Het bevat de wachtrijbibliotheek in het programma.

Om verder te kunnen lezen, moet de lezer een basiskennis van C . hebben gehad++.

Artikel Inhoud

Inleiding - zie hierboven
Basisconstructie
Belangrijke ledenfuncties
Andere prioriteitswachtrijfuncties
Tekenreeksgegevens
Andere prioriteitswachtrijconstructies
Conclusie

Basisconstructie

De datastructuur moet eerst worden geconstrueerd voordat deze kan worden gebruikt. Constructie betekent hier het instantiëren van een object uit de wachtrijklasse van de bibliotheek. Het wachtrij-object moet dan een naam hebben die de programmeur eraan heeft gegeven. De eenvoudigste syntaxis om een prioriteitswachtrij te maken is:

prioriteits-rij wachtrijNaam;

Met deze syntaxis wordt de grootste waarde het eerst verwijderd. Een voorbeeld van de instantie is:

prioriteits-rij pq;

De vector en de deque zijn twee datastructuren in C++. Met beide kan een priority_queue worden gemaakt. De syntaxis om een prioriteitswachtrij te maken op basis van de vectorstructuur is:

prioriteits-rij, vergelijk> pq;

Een voorbeeld van deze instantie is:

prioriteits-rij, minder > pq;

Let op de opening tussen > en > aan het einde van de aangifte. Dit om verwarring met >> . te voorkomen. De standaard vergelijkingscode is "minder"”, wat betekent dat de grootste, en niet noodzakelijk de eerste waarde, als eerste wordt verwijderd. De creatieverklaring kan dus eenvoudig worden geschreven als:

prioriteits-rij > pq;

Als de minste waarde eerst moet worden verwijderd, moet de instructie zijn:

prioriteits-rij, groter > pq;

Belangrijke ledenfuncties

De push()-functie
Deze functie duwt een waarde, die het argument is, in de prioriteit_wachtrij. Het keert leeg terug. De volgende code illustreert dit:

prioriteits-rij pq;
pq.duwen(10);
pq.duwen (30);
pq.duwen(20);
pq.duwen(50);
pq.duwen(40);

Deze prioriteit_wachtrij heeft 5 gehele waarden ontvangen in de volgorde 10, 30, 20, 50, 40. Als al deze elementen uit de prioriteitswachtrij moeten worden gehaald, zullen ze verschijnen in de volgorde 50, 40, 30, 20, 10.

De pop()-functie
Deze functie verwijdert uit de priority_queue de waarde met de hoogste prioriteit. Als de vergelijkingscode "groter" is”, dan zal het het element met de kleinste waarde verwijderen. Als het opnieuw wordt aangeroepen, verwijdert het het volgende element met de kleinste waarde van de rest; opnieuw gebeld, het verwijdert de volgende kleinste aanwezige waarde, enzovoort. Het keert leeg terug. De volgende code illustreert dit:

prioriteits-rij, groter > pq;
pq.duwen('een'); pq.duwen('c'); pq.duwen('b'); pq.duwen('e'); pq.duwen('d');

Merk op dat om een lidfunctie aan te roepen, de naam van het object gevolgd moet worden door een punt, en dan de functie.

De top() Functie
De knal() functie verwijdert de volgende waarde met de hoogste prioriteit, maar geeft deze niet terug, zoals knal() is een ongeldige functie. Gebruik de top() functie om de waarde met de hoogste prioriteit te kennen die vervolgens moet worden verwijderd. De top() functie retourneert een kopie van de waarde met de hoogste prioriteit in de prioriteit_wachtrij. De volgende code, waarbij de volgende waarde met de hoogste prioriteit de minste waarde is, illustreert dit:

prioriteits-rij, groter > pq;
pq.duwen('een'); pq.duwen('c'); pq.duwen('b'); pq.duwen('e'); pq.duwen('d');
char ch1 = pq.top(); pq.knal();
char ch2 = pq.top(); pq.knal();
char ch3 = pq.top(); pq.knal();
char ch4 = pq.top(); pq.knal();
char ch5 = pq.top(); pq.knal();
cout<De uitvoer is 'a"b"c"d"e'.

De lege() functie
Als een programmeur de top() functie op een lege prioriteit_wachtrij, na de succesvolle compilatie, zou hij een foutmelding ontvangen zoals:

Segmentatiefout (kern gedumpt)

Controleer dus altijd of de prioriteitswachtrij niet leeg is voordat u de top() functie. De leeg() member functie retourneert een bool, true, als de wachtrij leeg is, en false als de wachtrij niet leeg is. De volgende code illustreert dit:

prioriteits-rij pq;
int i1 = 10; int i2 = 30; int i3 = 20; int i4 = 50; int i5 = 40;
pq.duwen (i1); pq.duwen (i2); pq.duwen (i3); pq.duwen (i4); pq.duwen(i5);
terwijl(!pq.leeg())

cout << pq.top() << ";
pq.knal();

cout << '\n';

Andere prioriteitswachtrijfuncties

De maat () Functie:
Deze functie retourneert de lengte van de prioriteitswachtrij, zoals de volgende code illustreert:

prioriteits-rij pq;
int i1 = 10; int i2 = 30; int i3 = 20; int i4 = 50; int i5 = 40;
pq.duwen (i1); pq.duwen (i2); pq.duwen (i3); pq.duwen (i4); pq.duwen(i5);
int len = pq.grootte();
cout << len << '\n';

De uitvoer is 5.

De swap()-functie
Als twee prioriteitswachtrijen van hetzelfde type en dezelfde grootte zijn, kunnen ze door deze functie worden verwisseld, zoals de volgende code laat zien:

prioriteits-rij pq1;
int i1 = 10; int i2 = 30; int i3 = 20; int i4 = 50; int i5 = 40;
pq1.duwen (i1); pq1.duwen (i2); pq1.duwen (i3); pq1.duwen (i4); pq1.duwen(i5);
prioriteits-rij pqA;
int it1 = 1; int it2 = 3; int it3 = 2; int it4 = 5; int it5 = 4;
pqA.duwen(it1); pqA.duwen (it2); pqA.duwen(it3); pqA.duwen (it4); pqA.duwen(it5);
pq1.omwisselen (pqA);
terwijl(!pq1.leeg())

cout << pq1.top() << ";
pq1.knal();
schat<<'\n';
terwijl(!pqA.leeg())

cout << pqA.top() << ";
pqA.knal();
schat<<'\n';

De uitvoer is:

5 4 3 2 1
50 40 30 20 10

De emplace()-functie
De plaats() functie is vergelijkbaar met de push-functie. De volgende code illustreert dit:

prioriteits-rij pq1;
int i1 = 10; int i2 = 30; int i3 = 20; int i4 = 50; int i5 = 40;
pq1.plaats(i1); pq1.plaats(i2); pq1.plaats(i3); pq1.plaats(i4); pq1.plaats(i5);
terwijl(!pq1.leeg())

cout << pq1.top() << ";
pq1.knal();
schat<<'\n';

De uitvoer is:

50 40 30 20 10

Tekenreeksgegevens

Bij het vergelijken van tekenreeksen moet de tekenreeksklasse worden gebruikt en niet het directe gebruik van de letterlijke tekenreeksen, omdat het pointers zou vergelijken en niet de daadwerkelijke tekenreeksen. De volgende code laat zien hoe de tekenreeksklasse wordt gebruikt:

#include
prioriteits-rij pq1;
string s1 = string ("pen"), s2 = string ("potlood"), s3 = string ("oefenboek"), s4 = string ("tekstboek"), s5 = string ("liniaal");
pq1.duw(s1); pq1.duw(s2); pq1.duw(s3); pq1.duw(s4); pq1.duw(s5);
terwijl(!pq1.leeg())

cout << pq1.top() << " ";
pq1.knal();
schat<<'\n';

De uitvoer is:

tekstboek heerser potlood pen werkboek

Andere prioriteitswachtrijconstructies

Expliciete creatie van een vector
Een prioriteitswachtrij kan expliciet worden gemaakt op basis van een vector, zoals de volgende code laat zien:

#include
vector vtr = 10, 30, 20, 50, 40;
prioriteits-rij pq(vtr.begin(), vtr.einde());
terwijl(!pq.leeg())

cout << pq.top() << ";
pq.knal();
schat<<'\n';

De output is: 50 40 30 20 10. Deze keer moet ook de vectorkop worden opgenomen. De argumenten voor de constructorfunctie nemen de begin- en eindwijzers van de vector. Het gegevenstype voor de vector en het gegevenstype voor de prioriteit_wachtrij moeten hetzelfde zijn.

Om de minste waarde de prioriteit te geven, zou de verklaring voor de constructor zijn:

prioriteits-rij, groter>int> > pq(vtr.begin(), vtr.einde());

Expliciete creatie vanuit een array
Een prioriteitswachtrij kan expliciet worden gemaakt op basis van een array, zoals de volgende code laat zien:

int arr[] = 10, 30, 20, 50, 40;
prioriteits-rij pq(arr, arr+5);
terwijl(!pq.leeg())

cout << pq.top() << ";
pq.knal();
schat<<'\n';

De output is: 50 40 30 20 10. De argumenten voor de constructorfunctie nemen de begin- en eindaanwijzers van de array. arr retourneert de startaanwijzer, "arr+5" retourneert de aanwijzer net voorbij de array, en 5 is de grootte van de array. Het datatype voor de array en het datatype voor de priority_queue moeten hetzelfde zijn.

Om de minste waarde de prioriteit te geven, zou de verklaring voor de constructor zijn:

prioriteits-rij, groter > pq(arr, arr+5);

Opmerking: in C++ wordt de prioriteit_wachtrij eigenlijk een adapter genoemd, niet alleen een container.

Aangepaste vergelijkingscode

Alle waarden in de prioriteitswachtrij oplopend of allemaal aflopend hebben is niet de enige optie voor de prioriteitswachtrij. Een lijst met 11 gehele getallen voor een maximale heap is bijvoorbeeld:

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

De hoogste waarde is 88. Dit wordt gevolgd door twee getallen: 86 en 87, die kleiner zijn dan 88. De rest van de nummers zijn minder dan deze drie nummers, maar niet echt in orde. Er zijn twee lege cellen in de lijst. De nummers 84 en 82 zijn kleiner dan 86. De nummers 79 en 74 zijn kleiner dan 87. De getallen 80 en 81 zijn kleiner dan 84. De getallen 64 en 69 zijn kleiner dan 79.

De plaatsing van de nummers volgt de max-heap criteria - zie later. Om een dergelijk schema voor de prioriteit_wachtrij te bieden, moet de programmeur zijn eigen vergelijkingscode opgeven - zie later.

Conclusie

Een C++ priority_queue is een first-in-first-out wachtrij. De ledenfunctie, Duwen(), voegt een nieuwe waarde toe aan de wachtrij. De ledenfunctie, top(), leest de hoogste waarde in de wachtrij. De ledenfunctie, knal(), verwijdert zonder de hoogste waarde van de wachtrij terug te geven. De ledenfunctie, leeg(), controleert of de wachtrij leeg is. De prioriteit_wachtrij verschilt echter van de wachtrij, in die zin dat het een prioriteitsalgoritme volgt. Het kan het grootst zijn, van de eerste tot de laatste, of de minste, van de eerste tot de laatste. De criteria (algoritme) kunnen ook door de programmeur worden gedefinieerd.