A C ++ prioritás_sor használatához a programnak a következő kóddal kell kezdődnie:
#befoglalni
#befoglalni
segítségével névtérórák;
Ez magában foglalja a sorkönyvtárat a programban.
Az olvasás folytatásához az olvasónak rendelkeznie kellett a C ++ alapismereteivel.
Cikk tartalma
- Alapszerkezet
- Fontos tagfunkciók
- Egyéb prioritási sor funkciók
- String adatok
- Egyéb prioritási sor konstrukciók
- Következtetés
Alapszerkezet
Az adatstruktúrát először fel kell építeni, mielőtt használni lehetne. Az építés itt azt jelenti, hogy egy objektumot a könyvtár sorosztályából példányosítunk. A sorobjektumnak ezután nevet kell adnia a programozónak. A prioritási sor létrehozásának legegyszerűbb szintaxisa a következő:
prioritás_sor<típus>queueName;
Ezzel a szintaxissal először a legnagyobb érték kerül eltávolításra. Példa a példányosításra:
prioritás_sor<int>pq;vagy
prioritás_sor<char>pq;
A vektor és a dekk két adatstruktúra a C ++ - ban. Egy prioritás_sor létrehozható bármelyikkel. A szintaxis a vektorstruktúrából a prioritási sor létrehozásához a következő:
prioritás_sor<típus, vektor<azonos típusú>, hasonlítsd össze>pq;Példa erre a példányosításra:
prioritás_sor<int, vektor<int>, Kevésbé<int> >pq;Figyelje meg a nyilatkozat végén a> és> közötti szakadékot. Ez azért van, hogy elkerüljük a >> összetévesztést. Az alapértelmezett összehasonlító kód kevesebb, azaz a legnagyobb, és nem feltétlenül az első érték kerül eltávolításra. Tehát a létrehozási nyilatkozatot egyszerűen a következőképpen lehet írni:
prioritás_sor<int, vektor<int> >pq;Ha először a legkisebb értéket kell eltávolítani, akkor a következőnek kell lennie:
prioritás_sor<int, vektor<int>, nagyobb<int> >pq;Fontos tagfunkciók
A push () függvény
Ez a függvény egy értéket tol, amely az argumentuma, a prioritás_sorba. Üresen tér vissza. A következő kód ezt szemlélteti:
pq.nyom(10);
pq.nyom(30);
pq.nyom(húsz);
pq.nyom(ötven);
pq.nyom(40);
Ez a prioritás_sor 5 egész számot kapott, 10, 30, 20, 50, 40 nagyságrendben. Ha mindezeket az elemeket ki kell emelni a prioritási sorból, akkor ezek 50, 40, 30, 20, 10.
A pop () függvény
Ez a funkció eltávolítja a prioritás_sorbó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 meghívjuk, eltávolítja a következő elemet a többi legkisebb értékével; újra meghívva eltávolítja a következő legkisebb értéket, és így tovább. Üresen tér vissza. A következő kód ezt szemlélteti:
pq.nyom('nak nek');pq.nyom('c');pq.nyom('b');pq.nyom('És');pq.nyom('d');
Vegye figyelembe, hogy egy tagfüggvény meghívásához az objektum nevét egy pontnak kell követnie, majd a függvényt.
A felső () függvény
Az pop () függvény eltávolítja a legmagasabb prioritású következő értéket, de nem adja vissza, mint pop () üres függvény. Használja a fel () funkciót annak érdekében, hogy megtudja a legközelebb eltávolítandó legmagasabb prioritás értékét. Az fel () függvény a prioritás_sorban található legmagasabb prioritású érték másolatát adja vissza. Ezt mutatja a következő kód, ahol a legmagasabb prioritású következő érték a legkisebb
pq.nyom('nak nek');pq.nyom('c');pq.nyom('b');pq.nyom('És');pq.nyom('d');
charch1=pq.tetején();pq.pop();
charch2=pq.tetején();pq.pop();
charch3=pq.tetején();pq.pop();
charch4=pq.tetején();pq.pop();
charch5=pq.tetején();pq.pop();
költség<<ch1<<''<<ch2<<''<<ch3<<''<<ch4<<''<<ch5<<' n';
A kimenet „a” „b” „c” „d” „e”.
Az üres () függvény
Ha egy programozó használja a fel () függvény üres prioritás_során, a sikeres fordítás után hibaüzenetet kap, például:
Ezért mindig ellenőrizze, hogy a prioritási sor nem üres -e a fel () funkció. Az üres() A tag 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<int>pq;inti1= 10; inti2= 30; inti3= húsz; inti4= ötven; inti5= 40;
pq.nyom(i1);pq.nyom(i2);pq.nyom(i3);pq.nyom(i4);pq.nyom(i5);
míg(!pq.üres())
{
költség <<pq.tetején() << '';
pq.pop();
}
költség << ' n';
Egyéb prioritási sor funkciók
A size () függvény
Ez a függvény a prioritási sor hosszát adja vissza, amint azt a következő kód szemlélteti:
inti1= 10; inti2= 30; inti3= húsz; inti4= ötven; inti5= 40;
pq.nyom(i1);pq.nyom(i2);pq.nyom(i3);pq.nyom(i4);pq.nyom(i5);
intlen=pq.méret();
költség <<len<< ' n';
A kimenet 5.
A swap () függvény
Ha két prioritás_sor azonos típusú és méretű, akkor ez a funkció felcserélheti őket, ahogy az alábbi kód mutatja:
inti1= 10; inti2= 30; inti3= húsz; inti4= ötven; inti5= 40;
pq1.nyom(i1);pq1.nyom(i2);pq1.nyom(i3);pq1.nyom(i4);pq1.nyom(i5);
prioritás_sor<int>pqA;
intez1= 1; intez2= 3; intez3= 2; intez4= 5; intez5= 4;
pqA.nyom(ez1);pqA.nyom(ez2);pqA.nyom(ez3);pqA.nyom(ez4);pqA.nyom(ez5);
pq1.csere(pqA);
míg(!pq1.üres())
{
költség <<pq1.tetején() << '';
pq1.pop();
} költség<<' n';
míg(!pqA.üres())
{
költség <<pqA.tetején() << '';
pqA.pop();
} költség<<' n';
A kimenet:
& emsp; 5 & emsp; 4 & emsp; 3 & emsp; 2 & emsp; 1
& emsp; 50 & emsp; 40 & emsp; 30 & emsp; 20 & emsp; 10
Az emplace () Fuction
Az tüzelőállásba hoz() funkció hasonló a push funkcióhoz. A következő kód ezt szemlélteti:
inti1= 10; inti2= 30; inti3= húsz; inti4= ötven; inti5= 40;
pq1.tüzelőállásba hoz(i1);pq1.tüzelőállásba hoz(i2);pq1.tüzelőállásba hoz(i3);pq1.tüzelőállásba hoz(i4);pq1.tüzelőállásba hoz(i5);
míg(!pq1.üres())
{
költség <<pq1.tetején() << '';
pq1.pop();
} költség<<' n';
A kimenet:
50 40 30 20 10
String adatok
A karakterláncok összehasonlításakor a karakterlánc -osztályt kell használni, és nem a karakterlánc -literálok közvetlen használatát, mert a mutatókat hasonlítaná össze, és nem a tényleges karakterláncokat. A következő kód bemutatja a karakterlánc osztály használatát:
#befoglalniprioritás_sor<húr>pq1;
karakterlánc s1=húr('toll'), s2=húr('ceruza'), s3=húr('munkafüzet'), s4=húr('tankönyv'), s5=húr('vonalzó');
pq1.nyom(s1);pq1.nyom(s2);pq1.nyom(s3);pq1.nyom(s4);pq1.nyom(s5);
míg(!pq1.üres())
{
költség <<pq1.tetején() << '';
pq1.pop();
} költség<<' n';
A kimenet:
& emsp; tankönyv & vonalzó & emsp; ceruza & toll
Egyéb prioritási sor konstrukciók
Kifejezett teremtés vektorból
Egy prioritási sor kifejezetten létrehozható egy vektorból, ahogy az alábbi kód mutatja:
vektor<int>vtr= {10,30,húsz,ötven,40};
prioritás_sor<int>pq(vtr.kezdődik(), vtr.vége());
míg(!pq.üres())
{
költség <<pq.tetején() << '';
pq.pop();
} költség<<' n';
A kimenet: 50 40 30 20 10. Ezúttal a vektorfejlécet is bele kell foglalni. A konstruktor függvény argumentumai a vektor kezdő és végmutatóit veszik. A vektor adattípusának és a prioritás_sor adattípusának azonosnak kell lennie.
Annak érdekében, hogy a legkisebb érték legyen a prioritás, a kivitelező nyilatkozata a következő lenne:
prioritás_sor<int, vektor<int>, nagyobb>int> >pq(vtr.kezdődik(), vtr.vége()); Kifejezett teremtés tömbből
Egy prioritási sor kifejezetten létrehozható egy tömbből, ahogy az alábbi kód mutatja:
prioritás_sor<int>pq(arr, arr+5);
míg(!pq.üres())
{
költség <<pq.tetején() << '';
pq.pop();
} költség<<' n';
A kimenet: 50 40 30 20 10. A konstruktor függvény argumentumai a tömb kezdő és végmutatóit veszik. Az arr visszaadja a kezdőmutatót, az arr+5 a tömb melletti mutatót, az 5 pedig a tömb méretét. A tömb adattípusának és a prioritás_sor adattípusának azonosnak kell lennie.
Annak érdekében, hogy a legkisebb érték legyen a prioritás, a kivitelező nyilatkozata a következő lenne:
prioritás_sor<int, vektor<int>, nagyobb<int> >pq(arr, arr+5);Megjegyzés: A C ++ nyelvben a prioritás_sort valójában adapternek nevezik, nem csak tárolónak.
Egyéni összehasonlítási kód
A prioritási sorban lévő összes érték növekvő vagy csökkenő értéke nem az egyetlen lehetőség a prioritási sorban. Például a maximális halom 11 egész szám listája:
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 kevesebbek, 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. és 82. szám kisebb, mint 86. A 79. és 74. szám kevesebb, mint 87. A 80. és 81. szám kevesebb, mint 84. A 64. és 69. szám kevesebb, mint 79.
A számok elhelyezése a max-kupac kritériumokat követi-lásd később. Annak érdekében, hogy ilyen sémát biztosítson a prioritás_sorhoz, a programozónak meg kell adnia saját összehasonlító kódját - lásd később.
Következtetés
A C ++ prioritás_sor az első az első sorban sor. A tag funkció, nyom(), új értéket ad a sorhoz. A tag funkció, felső (), beolvassa a sor legfelső értékét. A tag funkció, pop (), eltávolítja a sor felső értékének visszaadása nélkül. A tag funkció, üres(), ellenőrzi, hogy üres -e a sor. A prioritás_sor azonban különbözik a várólistától, mivel valamilyen prioritási algoritmust követ. Ez lehet a legnagyobb, az elsőtől az utolsóig, vagy a legkevésbé, az elsőtől az utolsóig. A kritériumok (algoritmus) programozó által is definiálhatók.