Upang magamit ang C ++ priority_queue, ang programa ay dapat magsimula sa code tulad ng:
# isama
# isama
gamit namespaceoras;
Kasama rito ang queue library sa programa.
Upang magpatuloy sa pagbabasa, ang mambabasa ay dapat magkaroon ng pangunahing kaalaman sa C ++.
Nilalaman ng Artikulo
- Pangunahing Konstruksyon
- Mahalagang Pag-andar ng Miyembro
- Iba Pang Mga Pag-andar ng Priority Queue
- String Data
- Iba Pang Mga Priority Construction
- Konklusyon
Pangunahing Konstruksyon
Ang istraktura ng data ay dapat na itayo muna bago ito magamit. Ang konstruksyon dito ay nangangahulugang pagsisiksik ng isang bagay mula sa pila sa klase ng aklatan. Ang object ng pila ay dapat magkaroon ng isang pangalan na ibinigay dito ng programmer. Ang pinakasimpleng syntax upang lumikha ng isang priyoridad na pila ay:
priority_queue<uri>pila ng Pangalan;
Sa syntax na ito, ang pinakadakilang halaga ay aalisin muna. Ang isang halimbawa ng instantiation ay:
priority_queue<int>pq;o
priority_queue<char>pq;
Ang vector at ang deque ay dalawang mga istruktura ng data sa C ++. Ang isang priority_queue ay maaaring malikha kasama ang alinman sa mga ito. Ang syntax upang lumikha ng isang priyoridad na pila mula sa istraktura ng vector ay:
priority_queue<uri, vector<parehong uri>, ihambing>pq;Ang isang halimbawa ng instantiation na ito ay:
priority_queue<int, vector<int>, mas kaunti<int> >pq;Pansinin ang puwang sa pagitan ng> at> sa pagtatapos ng deklarasyon. Ito ay upang maiwasan ang pagkalito sa >>. Ang default na ihambing na code ay mas kaunti, nangangahulugang ang pinakamalaki, at hindi kinakailangang ang unang halaga, ay aalisin muna. Kaya, ang pahayag ng paglikha ay maaaring nakasulat lamang bilang:
priority_queue<int, vector<int> >pq;Kung ang pinakamaliit na halaga ay aalisin muna, kung gayon ang pahayag ay dapat na:
priority_queue<int, vector<int>, mas malaki<int> >pq;Mahalagang Pag-andar ng Miyembro
Ang push () Function
Ang pagpapaandar na ito ay nagtutulak sa isang halaga, na kung saan ay ang argumento, sa priority_queue. Bumalik itong walang bisa. Ang sumusunod na code ay naglalarawan nito:
pqitulak(10);
pqitulak(30);
pqitulak(dalawampu);
pqitulak(limampu);
pqitulak(40);
Ang priority_queue na ito ay nakatanggap ng 5 mga halaga ng integer sa pagkakasunud-sunod ng 10, 30, 20, 50, 40. Kung ang lahat ng mga elementong ito ay dapat na lumabas mula sa priyoridad na pila, pagkatapos ay lalabas sila sa pagkakasunud-sunod ng 50, 40, 30, 20, 10.
Ang pop () Function
Ang pagpapaandar na ito ay aalisin mula sa priority_queue ang halaga na may pinakamataas na priyoridad. Kung ang ihambing na code ay mas malaki, pagkatapos ay aalisin ang elemento na may pinakamaliit na halaga. Kung tinawag ulit, aalisin ang susunod na elemento na may pinakamaliit na halaga ng natitira; tinawag ulit, tinatanggal nito ang susunod na pinakamaliit na halaga na naroroon, at iba pa. Bumalik itong walang bisa. Ang sumusunod na code ay naglalarawan nito:
pqitulak('to');pqitulak('c');pqitulak('b');pqitulak('At');pqitulak('d');
Tandaan na upang tumawag sa isang pagpapaandar ng miyembro, ang pangalan ng bagay ay dapat na sundan ng isang tuldok, at pagkatapos ang pagpapaandar.
Ang tuktok () Pag-andar
Ang pop () inaalis ng pagpapaandar ang susunod na halaga ng pinakamataas na prayoridad, ngunit hindi ito ibabalik, bilang pop () ay isang walang bisa na pagpapaandar. Gamitin ang tuktok () pagpapaandar upang malaman ang halaga ng pinakamataas na priyoridad na kailangang alisin sa susunod. Ang tuktok () Nagbabalik ang function ng isang kopya ng halagang pinakamataas na priyoridad sa priority_queue. Ang sumusunod na code, kung saan ang susunod na halaga ng pinakamataas na priyoridad ay ang pinakamaliit na halaga, ay inilalarawan ito
pqitulak('to');pqitulak('c');pqitulak('b');pqitulak('At');pqitulak('d');
charch1=pqtuktok();pqpop();
charch2=pqtuktok();pqpop();
charch3=pqtuktok();pqpop();
charch4=pqtuktok();pqpop();
charch5=pqtuktok();pqpop();
gastos<<ch1<<'<<ch2<<'<<ch3<<'<<ch4<<'<<ch5<<' n';
Ang output ay 'a' 'b' 'c' 'd' 'e'.
Ang walang laman () Pag-andar
Kung gagamitin ng isang programmer ang tuktok () gumana sa isang walang laman na priority_queue, pagkatapos ng matagumpay na pagtitipon, makakatanggap siya ng isang mensahe ng error tulad ng:
Kaya, laging suriin kung ang priyoridad na pila ay hindi walang laman bago gamitin ang tuktok () pagpapaandar Ang walang laman () Ang pagpapaandar ng miyembro ay nagbabalik ng isang bool, totoo, kung ang pila ay walang laman, at hindi totoo kung ang pila ay hindi walang laman. Ang sumusunod na code ay naglalarawan nito:
priority_queue<int>pq;inti1= 10; inti2= 30; inti3= dalawampu; inti4= limampu; inti5= 40;
pqitulak(i1);pqitulak(i2);pqitulak(i3);pqitulak(i4);pqitulak(i5);
habang(!pqwalang laman())
{
gastos <<pqtuktok() << ';
pqpop();
}
gastos << ' n';
Iba Pang Mga Pag-andar ng Priority Queue
Ang laki () Pag-andar
Ibinabalik ng pagpapaandar na ito ang haba ng priyoridad na pila, tulad ng inilalarawan ng sumusunod na code:
inti1= 10; inti2= 30; inti3= dalawampu; inti4= limampu; inti5= 40;
pqitulak(i1);pqitulak(i2);pqitulak(i3);pqitulak(i4);pqitulak(i5);
intlen=pqlaki();
gastos <<len<< ' n';
Ang output ay 5.
Ang pagpapalit () Pag-andar
Kung ang dalawang priority_queues ay magkatulad na uri at sukat, maaari silang mapalitan ng pagpapaandar na ito, tulad ng ipinapakita ng sumusunod na code:
inti1= 10; inti2= 30; inti3= dalawampu; inti4= limampu; inti5= 40;
pq1.itulak(i1);pq1.itulak(i2);pq1.itulak(i3);pq1.itulak(i4);pq1.itulak(i5);
priority_queue<int>pqA;
intito1= 1; intito2= 3; intito3= 2; intito4= 5; intito5= 4;
pqAitulak(ito1);pqAitulak(ito2);pqAitulak(ito3);pqAitulak(ito4);pqAitulak(ito5);
pq1.magpalit(pqA);
habang(!pq1.walang laman())
{
gastos <<pq1.tuktok() << ';
pq1.pop();
} gastos<<' n';
habang(!pqAwalang laman())
{
gastos <<pqAtuktok() << ';
pqApop();
} gastos<<' n';
Ang output ay:
& emsp; 5 & emsp; 4 & emsp; 3 & emsp; 2 & emsp; 1
& emsp; 50 & emsp; 40 & emsp; 30 & emsp; 20 & emsp; 10
Ang lugar ng lugar () Fuction
Ang pumalit () Ang pagpapaandar ay katulad ng pagpapaandar ng push. Ang sumusunod na code ay naglalarawan nito:
inti1= 10; inti2= 30; inti3= dalawampu; inti4= limampu; inti5= 40;
pq1.pumalit(i1);pq1.pumalit(i2);pq1.pumalit(i3);pq1.pumalit(i4);pq1.pumalit(i5);
habang(!pq1.walang laman())
{
gastos <<pq1.tuktok() << ';
pq1.pop();
} gastos<<' n';
Ang output ay:
50 40 30 20 10
String Data
Kapag naghahambing ng mga string, dapat gamitin ang string class at hindi ang direktang paggamit ng mga string literals sapagkat ihinahambing ang mga payo at hindi ang mga tunay na string. Ipinapakita ng sumusunod na code kung paano ginagamit ang string class:
# isamapriority_queue<lubid>pq1;
string s1=lubid('pen'), s2=lubid('lapis'), s3=lubid('ehersisyo libro'), s4=lubid('text book'), s5=lubid('pinuno');
pq1.itulak(s1);pq1.itulak(s2);pq1.itulak(s3);pq1.itulak(s4);pq1.itulak(s5);
habang(!pq1.walang laman())
{
gastos <<pq1.tuktok() << ';
pq1.pop();
} gastos<<' n';
Ang output ay:
& emsp; text book & emsp; pinuno & emsp; lapis & emsp; pen & emsp; ehersisyo na libro
Iba Pang Mga Priority Construction
Malaswang Paglikha mula sa isang Vector
Ang isang priyoridad na pila ay maaaring malikha malikha mula sa isang vector tulad ng ipinapakita ng sumusunod na code:
vector<int>vtr= {10,30,dalawampu,limampu,40};
priority_queue<int>pq(vtr.magsimula(), vtr.magtapos());
habang(!pqwalang laman())
{
gastos <<pqtuktok() << ';
pqpop();
} gastos<<' n';
Ang output ay: 50 40 30 20 10. Sa oras na ito, ang vector header ay dapat ding isama. Ang mga argumento para sa pagpapaandar ng tagapagbuo ay kumukuha ng pagsisimula at pagtatapos ng mga payo ng vector. Ang uri ng data para sa vector at ang uri ng data para sa priority_queue ay dapat na pareho.
Upang gawing mas priyoridad ang pinakamaliit na halaga, ang deklarasyon para sa tagatayo ay:
priority_queue<int, vector<int>, mas malaki>int> >pq(vtr.magsimula(), vtr.magtapos()); Malaswang Paglikha mula sa isang Array
Ang isang priyoridad na pila ay maaaring malikha malikha mula sa isang array tulad ng ipinapakita ng sumusunod na code:
priority_queue<int>pq(arr, arr+5);
habang(!pqwalang laman())
{
gastos <<pqtuktok() << ';
pqpop();
} gastos<<' n';
Ang output ay: 50 40 30 20 10. Ang mga argumento para sa pagpapaandar ng tagapagbuo ay nagsisimula sa mga panimula at pagtatapos na mga payo ng array. ibabalik ng arr ang start pointer, ibabalik ng arr + 5 ang pointer na lampas lang sa array, at 5 ang laki ng array. Ang uri ng data para sa array at ang uri ng data para sa priority_queue ay dapat na pareho.
Upang gawing mas priyoridad ang pinakamaliit na halaga, ang deklarasyon para sa tagatayo ay:
priority_queue<int, vector<int>, mas malaki<int> >pq(arr, arr+5);Tandaan: Sa C ++, ang priority_queue ay talagang tinatawag na isang adapter, hindi lamang isang lalagyan.
Pasadyang Paghambing ng Code
Ang pagkakaroon ng lahat ng mga halaga sa priyoridad na pag-akyat sa pila o lahat ng pababang ay hindi lamang ang pagpipilian para sa pangunahing pila. Halimbawa, ang isang listahan ng 11 mga integer para sa isang maximum na magbunton ay:
88, 86, 87, 84, 82, 79,74, 80, 81 ,, 64, 69
Ang pinakamataas na halaga ay 88. Sinusundan ito ng dalawang numero: 86 at 87, na mas mababa sa 88. Ang natitirang mga numero ay mas mababa sa tatlong numerong ito, ngunit hindi talaga maayos. Mayroong dalawang walang laman na mga cell sa listahan. Ang mga bilang na 84 at 82 ay mas mababa sa 86. Ang mga bilang na 79 at 74 ay mas mababa sa 87. Ang mga bilang na 80 at 81 ay mas mababa sa 84. Ang mga bilang na 64 at 69 ay mas mababa sa 79.
Ang paglalagay ng mga numero ay sumusunod sa pamantayan ng max-heap - tingnan sa paglaon. Upang maibigay ang gayong pamamaraan para sa priority_queue, ang programmer ay kailangang magbigay ng kanyang sariling ihambing na code - tingnan sa paglaon.
Konklusyon
Ang isang C ++ priority_queue ay isang first-in-first-out na pila. Ang pagpapaandar ng miyembro, itulak (), nagdaragdag ng isang bagong halaga sa pila. Ang pagpapaandar ng miyembro, tuktok (), binabasa ang nangungunang halaga sa pila. Ang pagpapaandar ng miyembro, pop (), aalisin nang hindi ibabalik ang nangungunang halaga ng pila. Ang pagpapaandar ng miyembro, walang laman (), suriin kung ang pila ay walang laman. Gayunpaman, ang priority_queue ay naiiba sa pila, sa na, sumusunod ito sa ilang prayoridad na algorithm. Maaari itong maging pinakadakila, mula una hanggang huli, o hindi bababa sa, mula una hanggang huli. Ang pamantayan (algorithm) ay maaari ding tukuyin ng programmer.