Jak používat C ++ Priority_queue?

How Use C Priority_queue

V C ++ je fronta datová struktura seznamu, kde první prvek, který má být zařazen do seznamu, je prvním prvkem, který má být odebrán, když má dojít k odebrání. Fronta priorit v C ++ je podobná, ale má určité uspořádání; je to prvek s největší hodnotou, který je odstraněn jako první. Frontu priorit lze i nadále konfigurovat tak, aby se nejprve odstranil prvek s nejnižší hodnotou. Jakákoli fronta musí mít alespoň tam() funkce a pop () funkce. The tam() funkce přidá nový prvek na zadní stranu. Pro normální frontu je pop () funkce odstraní první prvek, který byl kdy vložen. Pro frontu priorit je pop () funkce odstraní prvek s nejvyšší prioritou, která může být největší nebo nejmenší, v závislosti na schématu řazení.

Aby bylo možné používat C ++ priority_queue, program by měl začínat kódem jako:



#zahrnout
#zahrnout
použitím jmenný prostorhodiny;

Zahrnuje knihovnu front do programu.



Aby čtenář mohl pokračovat ve čtení, měl mít základní znalosti C ++.



Obsah článku

Základní konstrukce

Datová struktura musí být nejprve vytvořena, než může být použita. Konstrukce zde znamená vytvoření instance objektu z třídy fronty knihovny. Objekt fronty pak musí mít název, který mu dal programátor. Nejjednodušší syntaxe k vytvoření prioritní fronty je:

prioritní_fronta<typ>queueName;

Při této syntaxi se nejprve odstraní největší hodnota. Příkladem instance je:

prioritní_fronta<int>pq;

nebo



prioritní_fronta<char>pq;

Vektor a deque jsou dvě datové struktury v C ++. S každou z nich lze vytvořit prioritu_fronty. Syntaxe pro vytvoření prioritní fronty z vektorové struktury je:

prioritní_fronta<typ, vektor<stejný typ>, porovnat>pq;

Příkladem této instance je:

prioritní_fronta<int, vektor<int>, méně<int> >pq;

Všimněte si mezery mezi> a> na konci deklarace. Toto má zabránit záměně s >>. Výchozí porovnávací kód je menší, což znamená, že největší a ne nutně první hodnota bude odstraněna jako první. Prohlášení o vytvoření lze tedy jednoduše napsat jako:

prioritní_fronta<int, vektor<int> >pq;

Pokud má být nejdříve odstraněna nejmenší hodnota, pak musí být příkaz:

prioritní_fronta<int, vektor<int>, větší<int> >pq;

Důležité členské funkce

Funkce push ()
Tato funkce vloží hodnotu, což je její argument, do priority_queue. Vrací se to prázdné. Následující kód to ilustruje:

prioritní_fronta<int>pq;

pq.tam(10);
pq.tam(30);
pq.tam(dvacet);
pq.tam(padesátka);
pq.tam(40);

Tato prioritní_fronta obdržela 5 celočíselných hodnot v pořadí 10, 30, 20, 50, 40. Pokud mají být všechny tyto prvky vysunuty z fronty priorit, vyjdou v pořadí 50, 40, 30, 20, 10.

Funkce pop ()
Tato funkce odebere z priority_queue hodnotu s nejvyšší prioritou. Pokud je porovnávací kód větší, odebere prvek s nejmenší hodnotou. Pokud se znovu zavolá, odstraní další prvek s nejmenší hodnotou zbytku; znovu vyvolá, odstraní další nejmenší přítomnou hodnotu atd. Vrací se to prázdné. Následující kód to ilustruje:

prioritní_fronta<char, vektor<char>, větší<int> >pq;
pq.tam('na');pq.tam('C');pq.tam('b');pq.tam('A');pq.tam('d');

Všimněte si toho, že pro volání členské funkce musí za názvem objektu následovat tečka a poté funkce.

Funkce top ()
The pop () funkce odstraní další hodnotu s nejvyšší prioritou, ale nevrátí ji jako pop () je prázdná funkce. Použijte horní() funkci, aby bylo možné zjistit hodnotu nejvyšší priority, kterou je třeba příště odstranit. The horní() funkce vrací kopii hodnoty s nejvyšší prioritou ve frontě priority. Následující kód, kde další hodnota s nejvyšší prioritou je nejmenší hodnota, to ilustruje

prioritní_fronta<char, vektor<char>, větší<int> >pq;
pq.tam('na');pq.tam('C');pq.tam('b');pq.tam('A');pq.tam('d');
charch1=pq.horní();pq.pop();
charch2=pq.horní();pq.pop();
charch3=pq.horní();pq.pop();
charch4=pq.horní();pq.pop();
charch5=pq.horní();pq.pop();

náklady<<ch1<<''<<ch2<<''<<ch3<<''<<ch4<<''<<ch5<<' n';

Výstupem je „a“ „b“ „c“ „d“ „e“.

Funkce empty ()
Pokud programátor používá horní() funkce na prázdné prioritní frontě, po úspěšné kompilaci by obdržel chybovou zprávu, jako například:

Porucha Segmentace(vyhozeno jádro)

Před použitím souboru vždy zkontrolujte, zda není fronta priorit prázdná horní() funkce. The prázdný() členská funkce vrací bool, true, pokud je fronta prázdná, a false, pokud fronta není prázdná. Následující kód to ilustruje:

prioritní_fronta<int>pq;
inti1= 10; inti2= 30; inti3= dvacet; inti4= padesátka; inti5= 40;
pq.tam(i1);pq.tam(i2);pq.tam(i3);pq.tam(i4);pq.tam(i5);

zatímco(!pq.prázdný())
{
náklady <<pq.horní() << '';
pq.pop();
}
náklady << ' n';

Další funkce prioritní fronty

Funkce size ()
Tato funkce vrací délku fronty priorit, jak ukazuje následující kód:

prioritní_fronta<int>pq;
inti1= 10; inti2= 30; inti3= dvacet; inti4= padesátka; inti5= 40;
pq.tam(i1);pq.tam(i2);pq.tam(i3);pq.tam(i4);pq.tam(i5);

intjen=pq.velikost();
náklady <<jen<< ' n';

Výstup je 5.

Funkce swap ()
Pokud jsou dvě priority_queues stejného typu a velikosti, mohou být touto funkcí prohozeny, jak ukazuje následující kód:

prioritní_fronta<int>pq1;
inti1= 10; inti2= 30; inti3= dvacet; inti4= padesátka; inti5= 40;
pq1.tam(i1);pq1.tam(i2);pq1.tam(i3);pq1.tam(i4);pq1.tam(i5);

prioritní_fronta<int>pqA;
intit1= 1; intit2= 3; intit3= 2; intit4= 5; intit5= 4;
pqA.tam(it1);pqA.tam(it2);pqA.tam(it3);pqA.tam(it4);pqA.tam(it5);

pq1.vyměnit(pqA);

zatímco(!pq1.prázdný())
{
náklady <<pq1.horní() << '';
pq1.pop();
} náklady<<' n';

zatímco(!pqA.prázdný())
{
náklady <<pqA.horní() << '';
pqA.pop();
} náklady<<' n';

Výstupem je:

& emsp; 5 & emsp; 4 & emsp; 3 & emsp; 2 & emsp; 1
& emsp; 50 & emsp; 40 & emsp; 30 & emsp; 20 & emsp; 10

Funkce emplace () Fuction
The umístit() funkce je podobná funkci push. Následující kód to ilustruje:

prioritní_fronta<int>pq1;
inti1= 10; inti2= 30; inti3= dvacet; inti4= padesátka; inti5= 40;
pq1.umístit(i1);pq1.umístit(i2);pq1.umístit(i3);pq1.umístit(i4);pq1.umístit(i5);

zatímco(!pq1.prázdný())
{
náklady <<pq1.horní() << '';
pq1.pop();
} náklady<<' n';

Výstupem je:

50 40 30 20 10

Řetězcová data

Při porovnávání řetězců by měla být použita třída řetězců a ne přímé použití řetězcových literálů, protože by porovnávala ukazatele a ne skutečné řetězce. Následující kód ukazuje, jak se používá třída řetězců: The following code shows how the string class is used:

#zahrnout
prioritní_fronta<tětiva>pq1;
řetězec s1=tětiva('pero'), s2=tětiva('tužka'), s3=tětiva('sešit'), s4=tětiva('učebnice'), s5=tětiva('pravítko');

pq1.tam(s1);pq1.tam(s2);pq1.tam(s3);pq1.tam(s4);pq1.tam(s5);
zatímco(!pq1.prázdný())
{
náklady <<pq1.horní() << '';
pq1.pop();
} náklady<<' n';

Výstupem je:

& emsp; učebnice & emsp; pravítko & emsp; tužka & emsp; pero & emsp; sešit

Další stavby prioritních front

Explicitní tvorba z vektoru
Frontu priorit lze vytvořit explicitně z vektoru, jak ukazuje následující kód:

#zahrnout
vektor<int>vtr= {10,30,dvacet,padesátka,40};

prioritní_fronta<int>pq(vtr.začít(), vtr.konec());

zatímco(!pq.prázdný())
{
náklady <<pq.horní() << '';
pq.pop();
} náklady<<' n';

Výstup je: 50 40 30 20 10. Tentokrát musí být zahrnuto také záhlaví vektoru. Argumenty pro funkci konstruktoru mají počáteční a koncový ukazatel vektoru. Datový typ pro vektor a datový typ pro prioritu_fronta musí být stejný.

Aby byla prioritou nejmenší hodnota, deklarace pro konstruktor by byla:

prioritní_fronta<int, vektor<int>, větší>int> >pq(vtr.začít(), vtr.konec());

Explicitní tvorba z pole
Frontu priorit lze vytvořit explicitně z pole, jak ukazuje následující kód:

intarr[] = {10,30,dvacet,padesátka,40};

prioritní_fronta<int>pq(arr, arr+5);

zatímco(!pq.prázdný())
{
náklady <<pq.horní() << '';
pq.pop();
} náklady<<' n';

Výstup je: 50 40 30 20 10. Argumenty pro funkci konstruktoru mají počáteční a koncové ukazatele pole. arr vrací počáteční ukazatel, arr+5 vrací ukazatel těsně za polem a 5 je velikost pole. Datový typ pro pole a datový typ pro prior_queue musí být stejný.

Aby byla prioritou nejmenší hodnota, deklarace pro konstruktor by byla:

prioritní_fronta<int, vektor<int>, větší<int> >pq(arr, arr+5);

Poznámka: V jazyce C ++ se prioritní_fronta ve skutečnosti nazývá adaptér, nejen kontejner.

Vlastní srovnávací kód

Mít všechny hodnoty ve frontě priorit vzestupně nebo všechny sestupně není jedinou možností pro frontu priorit. Například seznam 11 celých čísel pro maximální hromadu je:

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

Nejvyšší hodnota je 88. Následují dvě čísla: 86 a 87, která jsou menší než 88. Zbytek čísel je menší než tato tři čísla, ale ne ve skutečnosti. V seznamu jsou dvě prázdné buňky. Čísla 84 a 82 jsou menší než 86. Čísla 79 a 74 jsou menší než 87. Čísla 80 a 81 jsou menší než 84. Čísla 64 a 69 jsou menší než 79.

Umístění čísel se řídí kritérii maximální hromady-viz později. Aby bylo možné poskytnout takové schéma pro prior_queue, musí programátor poskytnout svůj vlastní porovnávací kód - viz dále.

Závěr

C ++ priority_queue je fronta první v první. Členská funkce, tam(), přidá novou hodnotu do fronty. Členská funkce, horní(), čte nejvyšší hodnotu ve frontě. Členská funkce, pop (), odebere bez vrácení nejvyšší hodnoty fronty. Členská funkce, prázdný(), zkontroluje, zda je fronta prázdná. Fronta priority_queue se však liší od fronty v tom, že dodržuje nějaký algoritmus priority. Může být největší, od prvního do posledního, nebo nejmenší, od prvního do posledního. Kritéria (algoritmus) lze také definovat programátorem.