A C ++ Priority_queue használata?

A C ++ nyelven a várólista egy olyan lista adatstruktúra, ahol a lista első elemét az első eltávolítandó elemként kell eltávolítani. A C ++ prioritási sora hasonló, de van némi sorrendje; először a legnagyobb értékű elemet távolítják el. A prioritási sor továbbra is konfigurálható úgy, hogy először a legkevesebb értékű elem kerüljön eltávolításra. Bármelyik sornak legalább a nyom() funkció és a pop() funkció. A nyom() függvény új elemet ad hátul. A normál sorban a pop() funkció eltávolítja az első betolt elemet. Az elsőbbségi sorhoz a pop() függvény eltávolítja a legmagasabb prioritású elemet, amely a rendelési sémától függően lehet a legnagyobb vagy a legkisebb.

A C ++ priority_queue használatához a programnak a következő kóddal kell kezdődnie:

#include
#include
névtér használata std;

Ez magában foglalja a sorkönyvtárat a programban.

Az olvasás folytatása érdekében az olvasónak alapvető ismeretekkel kellett volna rendelkeznie a C-ről++.

A cikk tartalma

Bevezetés - lásd fent
Alapszerkezet
Fontos tagfunkciók
Egyéb prioritási sor funkciók
Karakterlánc-adatok
Egyéb kiemelt várólisták
Következtetés

Alapszerkezet

Az adatszerkezetet használat előtt először össze kell állítani. Az építkezés itt egy objektum példányosítását jelenti a könyvtár sorosztályából. Ezután a sorobjektumnak rendelkeznie kell egy névvel, amelyet a programozó adott neki. A prioritási sor létrehozásának legegyszerűbb szintaxisa:

prioritás_sor queueName;

Ezzel a szintaxissal először a legnagyobb értéket távolítják el. A példányosításra példa:

prioritás_sor pq;

vagy

prioritás_sor pq;

A vektor és a deque két adatszerkezet C-ben++. Bármelyikükkel létrehozható egy prioritási_sor. Az elsődleges sor létrehozásának szintaxisa a vektorstruktúrából:

prioritás_sor, összehasonlít> pq;

Példa erre a példányosításra:

prioritás_sor, Kevésbé > pq;

Figyelje meg a> és> közötti szakadékot a nyilatkozat végén. Ennek célja a >> -vel való összetévesztés elkerülése. Az alapértelmezett összehasonlító kód „kevesebb”, Vagyis a legnagyobbat, és nem feltétlenül az első értéket távolítanák el először. Tehát a létrehozási utasítás egyszerűen így írható:

prioritás_sor > pq;

Ha először a legkevesebb értéket kell eltávolítani, akkor a következőnek kell lennie:

prioritás_sor, nagyobb > pq;

Fontos tagfunkciók

A push () funkció
Ez a függvény kitol egy értéket, amely az argumentuma, a priority_queue-ba. Érvénytelenül tér vissza. A következő kód ezt szemlélteti:

prioritás_sor pq;
pq.nyomás (10);
pq.nyomás (30);
pq.nyomás (20);
pq.nyomás (50);
pq.tolás (40);

Ez a priority_queue 5 egész értéket kapott, 10, 30, 20, 50, 40 sorrendben. Ha ezeket az elemeket ki akarjuk dobni a prioritási sorból, akkor 50, 40, 30, 20, 10 sorrendben kerülnek elő.

A pop () függvény
Ez a függvény eltávolítja a prioritás_kódból a legmagasabb prioritású értéket. Ha az összehasonlító kód „nagyobb”, Akkor eltávolítja a legkisebb értékű elemet. Ha újra hívja, akkor eltávolítja a következő elemet, amelynek a többi értéke a legkisebb; újra hívják, eltávolítja a következő legkisebb jelen lévő értéket stb. Érvénytelenül tér vissza. A következő kód ezt szemlélteti:

prioritás_sor, nagyobb > pq;
pq.nyomás ('a'); pq.nyomja ('c'); pq.nyomja ('b'); pq.nyomja ('e'); pq.nyomja ('d');

Ne feledje, hogy a tagfüggvény meghívásához az objektum nevét egy ponttal kell követni, majd a függvényt.

A felső () függvény
A pop() függvény eltávolítja a legmagasabb prioritás következő értékét, de nem adja vissza, mint pop() egy void függvény. Használja a top () függvény annak érdekében, hogy megtudja a legmagasabb prioritás értékét, amelyet legközelebb el kell távolítani. A top () függvény adja vissza a prioritás_minta legmagasabb prioritásának értékét. A következő kód, ahol a legmagasabb prioritású következő érték a legkevesebb, ezt szemlélteti

prioritás_sor, nagyobb > pq;
pq.nyomás ('a'); pq.nyomja ('c'); pq.nyomja ('b'); pq.nyomja ('e'); pq.nyomja ('d');
char ch1 = pq.teteje (); pq.pop();
char ch2 = pq.teteje (); pq.pop();
char ch3 = pq.teteje (); pq.pop();
char ch4 = pq.teteje (); pq.pop();
char ch5 = pq.teteje (); pq.pop();
cout<A kimenet 'a "b" c "d" e ".

Az üres () függvény
Ha egy programozó a top () függvény egy üres prioritási soron, a sikeres fordítás után hibaüzenetet kap, például:

Szegmentációs hiba (mag ki van dobva)

Tehát mindig ellenőrizze, hogy a prioritási sor nem üres-e, mielőtt a top () funkció. A üres() A member függvény egy bool értéket ad vissza, igaz, ha a sor üres, és hamis, ha a sor nem üres. A következő kód ezt szemlélteti:

prioritás_sor pq;
int i1 = 10; int i2 = 30; int i3 = 20; int i4 = 50; int i5 = 40;
pq.nyomja (i1); pq.nyomás (i2); pq.nyomás (i3); pq.nyomja (i4); pq.nyomja (i5);
míg(!pq.üres())

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

cout << '\n';

Egyéb prioritási sor funkciók

A méret () Funkció
Ez a függvény adja vissza az elsőbbségi sor hosszát, ahogy a következő kód szemlélteti:

prioritás_sor pq;
int i1 = 10; int i2 = 30; int i3 = 20; int i4 = 50; int i5 = 40;
pq.nyomja (i1); pq.nyomás (i2); pq.nyomás (i3); pq.nyomás (i4); pq.nyomja (i5);
int len = pq.méret();
cout << len << '\n';

A kimenet 5.

A swap () függvény
Ha két priority_queue azonos típusú és méretű, akkor ez a függvény felcserélheti őket, ahogy a következő kód mutatja:

prioritás_sor pq1;
int i1 = 10; int i2 = 30; int i3 = 20; int i4 = 50; int i5 = 40;
pq1.nyomja (i1); pq1.nyomás (i2); pq1.nyomás (i3); pq1.nyomás (i4); pq1.nyomja (i5);
prioritás_sor pqA;
int it1 = 1; int it2 = 3; int it3 = 2; int it4 = 5; int it5 = 4;
pqA.nyomja (it1); pqA.nyomja (it2); pqA.nyomja (it3); pqA.nyomja (it4); pqA.nyomja (it5);
pq1.csere (pqA);
míg(!pq1.üres())

cout << pq1.top() << ";
pq1.pop();
cout<<'\n';
míg(!pqA.üres())

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

A kimenet:

5 4 3 2 1
50 40 30 20 10

Az emplace () Fuction
A tüzelőállásba hoz() funkció hasonló a push funkcióhoz. A következő kód ezt szemlélteti:

prioritás_sor pq1;
int i1 = 10; int i2 = 30; int i3 = 20; int i4 = 50; int i5 = 40;
pq1.emhely (i1); pq1.emhely (i2); pq1.emhely (i3); pq1.emhely (i4); pq1.emhely (i5);
míg(!pq1.üres())

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

A kimenet:

50 40 30 20 10

Karakterlánc-adatok

A karakterláncok összehasonlításakor a karakterlánc osztályt kell használni, nem pedig a karakterláncok közvetlen használatát, mert a mutatókat hasonlítaná, és nem a tényleges karakterláncokat. A következő kód megmutatja a karakterlánc osztály használatát:

#include
prioritás_sor pq1;
string s1 = string ("toll"), s2 = string ("ceruza"), s3 = string ("füzet"), s4 = string ("tankönyv"), s5 = string ("vonalzó");
pq1.nyomás (s1); pq1.nyomás (s2); pq1.nyomás (s3); pq1.nyomás (s4); pq1.nyomja (s5);
míg(!pq1.üres())

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

A kimenet:

tankönyv vonalzó ceruza toll füzet

Egyéb kiemelt várólisták

Kifejezett alkotás vektorból
A prioritási sor kifejezetten létrehozható egy vektorból, amint azt a következő kód mutatja:

#include
vektor vtr = 10, 30, 20, 50, 40;
prioritás_sor pq (vtr.kezdődik (), vtr.vége ());
míg(!pq.üres())

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

A kimenet: 50 40 30 20 10. Ezúttal a vektor fejlécét is be kell vonni. A konstruktor függvény argumentumai megadják a vektor kezdő és végpontját. A vektor adattípusának és a priority_queue adattípusának meg kell egyeznie.

A prioritás legkisebb értékének elérése érdekében a konstruktor deklarációja a következő lenne:

prioritás_sor, nagyobb> int>> pq (vtr.kezdődik (), vtr.vége ());

Kifejezett alkotás egy tömbből
A prioritási sor kifejezetten létrehozható egy tömbből, amint azt a következő kód mutatja:

int arr [] = 10, 30, 20, 50, 40;
prioritás_sor pq (arr, arr + 5);
míg(!pq.üres())

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

A kimenet: 50 40 30 20 10. A konstruktor függvény argumentumai a tömb kezdő és vég mutatóját veszik fel. Az arr a kezdő mutatót adja vissza, az „arr + 5” a tömböt túlmutató mutatót adja vissza, az 5 pedig a tömb mérete. A tömb adattípusának és a prioritási sor adattípusának meg kell egyeznie.

A prioritás legkisebb értékének elérése érdekében a konstruktor deklarációja a következő lenne:

prioritás_sor, nagyobb > pq (arr, arr + 5);

Megjegyzés: A C ++ nyelven a prioritás_kettőt valójában adapternek hívják, nem csak tárolónak.

Egyedi összehasonlító kód

Ha az összes érték növekvő vagy csökkenő sorrendben van, akkor az egyetlen lehetőség a prioritási sorban. Például egy 11 egész számot tartalmazó lista a maximális kupac számára:

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

A legmagasabb érték 88. Ezt két szám követi: 86 és 87, amelyek kisebbek, mint 88. A többi szám kisebb, mint ez a három szám, de nem igazán sorrendben. Két üres cella van a listában. A 84-es és a 82-es szám kevesebb, mint 86. A 79-es és a 74-es szám kevesebb, mint 87. A 80-as és a 81-es szám kisebb, mint 84. A 64-es és a 69-es szám kevesebb, mint 79.

A számok elhelyezése megfelel a maximális kupac kritériumainak - lásd később. Annak érdekében, hogy egy ilyen sémát biztosítson a prioritás_mező számára, a programozónak meg kell adnia a saját összehasonlító kódját - lásd később.

Következtetés

A C ++ prioritási sor egy első az elsőben sor. A tag funkció, nyom(), új értéket ad a sorba. A tag funkció, top (), beolvassa a sor legfelső értékét. A tag funkció, pop(), eltávolítja a sor legfelső értékének visszaadása nélkül. A tag funkció, üres(), ellenőrzi, hogy a sor üres-e. A prioritás_sor azonban eltér a várólistától, mivel néhány prioritási algoritmust követ. Ez lehet legnagyobb, elsőtől utolsóig, vagy legkevésbé, elsőtől utolsóig. A kritériumok (algoritmus) programozó által is meghatározhatók.