Menu

Stakke og køer i STL

stacks queues stl

Prøv Vores Instrument Til At Fjerne Problemer

Lær implementeringen af ​​stakke og køer i STL med eksempler.

Stakke og køer er to containere i STL, som er meget grundlæggende. De er de enkleste containere, der har brede applikationer inden for softwareprogrammering.

I denne vejledning vil vi se en detaljeret implementering af begge disse containere i STL. Vi vil også gennemgå de forskellige operationer, der understøttes af stack og kø med eksempler.

=> Pas på den enkle C ++ træningsserie her.

STAKKER OG KØER i STL

Hvad du vil lære:

Stakke

Stackcontainer i STL er en type containeradaptere. Det bruges til at replikere en stakdatastruktur i C ++. Stakbeholder er et sæt elementer, hvor elementerne indsættes i den ene ende og også slettes i samme ende.

Dette fælles punkt for tilføjelse og sletning er kendt som “Top of the stack”.

Den billedlige gengivelse af stakken er vist nedenfor.

stak

Som vist i ovenstående repræsentation er stakken en beholder, i hvilken elementer tilføjes og slettes fra den samme ende kaldet Top of the stack.

Da tilføjelse og sletning sker i samme ende, kan vi sige, at stakcontaineren er LIFO (sidste ind, først ud) type arbejde. Dette betyder, at det element, der tilføjes først, er det sidste, der slettes.

For at implementere stakbeholder skal vi medtage overskriften i vores program.

#include

Den generelle erklæringssyntaks for stackcontainer er:

stack stackName;

Stakoperationer

Lad os derefter diskutere de forskellige operationer, der stabler container i STL understøtter.

  • skubbe : push-operation bruges til at indsætte et element i stakken. Denne handling tilføjer altid elementer øverst i stakken.

Overvej et tomt stak-mystack af heltal .

mystack

Lad os derefter tilføje element 1 til stakken.

tilføj element 1 til stakken

Derefter tilføjer vi element 3 til stakken.

tilføj element 3 til stakken

Ifølge gengivelsen tilføjes et element som et resultat af en skubbehandling øverst på stakken. Efter hver trykoperation øges størrelsen på stakken med 1.

  • pop : pop-operation bruges til at fjerne et element fra stakken. Det fjernede element er det, der er peget på ved toppen af ​​stakken. Som et resultat af popoperationen reduceres stakkens størrelse med 1.

Lad os se, hvordan popoperationen ser ud:

Overvej stack mystack som ovenfor, hvor vi allerede har skubbet 2 elementer.

mystack2

Lad os nu kalde funktionen pop (). Når dette opkald udføres, fjernes elementet øverst i stakken, og 'Top' peger på det næste element som vist nedenfor.

element

Hvis vi igen kalder pop (), fjernes det næste element (i dette tilfælde 1), hvilket resulterer i en tom stak.

element

hvad er det bedste program til fjernelse af malware
  • top : Returnerer det øverste element i stakken.
  • tom : Kontrollerer, om stakken er tom eller ej.
  • størrelse: Returnerer størrelsen på stakken, dvs. antallet af elementer i stakken.

Nedenfor er et eksempel på Stack-implementering for bedre at forstå operationerne.

#include #include using namespace std; void printStack(stack stk) { while (!stk.empty()) { cout << ' ' << stk.top(); stk.pop(); } cout << ' '; } int main () { stack oddstk; oddstk.push(1); oddstk.push(3); oddstk.push(5); oddstk.push(7); oddstk.push(9); cout << 'The stack is : '; printStack(oddstk); cout << ' Size of stack: ' << oddstk.size(); cout << ' Top of stack: ' << oddstk.top(); cout << ' oddstk.pop() : '; oddstk.pop(); printStack(oddstk); cout<<' Another pop(): '; oddstk.pop(); printStack(oddstk); return 0; }

stakimplementeringsoutput

Ovenstående eksempel viser tydeligt push-operationen, der genererer en stak. Det viser også stakken efter to på hinanden følgende popoperationer.

Således har vi set stack og dens operationer i STL. Desuden vil vi i denne vejledning se den detaljerede implementering af endnu en simpel STL-container, der er 'Kø'.

Kø

Køen er endnu en container i STL, som også er meget enkel og nyttig. Købeholder er en replika af kødatastrukturen i C ++. I modsætning til stak er der i købeholderen to ender, dvs. front og bag.

Elementer føjes til køen bagpå, mens de slettes fra forsiden af ​​køen. Generelt bruger køen FIFO (arrangement første ind, først ud).

For at implementere en køcontainer i et program skal vi medtage en header i koden.

#include

Den generelle syntaks til køerklæring er:

kø kønavn;

Vi erklærer købeholderen som følger:

Queue myqueue;

Køoperationer

Nu ser vi de forskellige operationer understøttet af køen.

  • skubbe: Funktion 'push' tilføjer elementet i slutningen af ​​køen, dvs. på bagsiden af ​​køen.
  • pop: Funktion 'pop' fjerner det første element i køen, dvs. elementet forrest i køen.

Lad os forstå push- og pop-funktionerne i køen.

Overvej en tom kø, der er erklæret over myqueue. Nu skubber vi et lige nummer 2 i køen med operationen

myqueue.push (2);

Nu vil køen se ud:

myqueue.pop ();

Dernæst tilføjer vi '4' til køen med opkaldet 'myqueue.push (4)'.

Nu ser køen ud som vist nedenfor:

myqueue.push (4)

Som det ses ovenfor, skubbes elementerne ind i køen fra bagenden eller bagfra.

Lad os nu køre operation på myqueue.

myqueue.pop ();

myqueue.pop ();

Så som vi ser, når pop () kaldes, fjernes element foran i køen. Dette betyder, at det første element, der indtastes i køen, er det første element, der er ude af køen.

  • foran: Denne funktion returnerer en henvisning til det første element i køen.
  • tilbage: Tilbage returnerer en henvisning til det sidste element i køen.
  • tom: Kontrollerer, om køen er tom.
  • størrelse: Returnerer køens størrelse, dvs. antallet af elementer i køen.

Nedenfor er et eksempel på et program, der demonstrerer de operationer, der bruges af køcontaineren.

#include #include using namespace std; void printQueue(queue myqueue) { queue secqueue = myqueue; while (!secqueue.empty()) { cout << ' ' << secqueue.front(); secqueue.pop(); } cout << ' '; } int main() { queue myqueue; myqueue.push(2); myqueue.push(4); myqueue.push(6); myqueue.push(8); cout << 'The queue myqueue is : '; printQueue(myqueue); cout << ' myqueue.size() : ' << myqueue.size(); cout << ' myqueue.front() : ' << myqueue.front(); cout << ' myqueue.back() : ' << myqueue.back(); cout << ' myqueue.pop() : '; myqueue.pop(); printQueue(myqueue); return 0; }

Produktion:

Android Interview spørgsmål og svar pdf

Kø-myqueue er: 2 4 6 8

myqueue.size (): 4

myqueue.front (): 2

myqueue.back (): 8

myqueue.pop (): 4 6 8

Som vist ovenfor erklærer vi først en køcontainer. Derefter tilføjer vi de første fire lige tal ved hjælp af push-operationen. Derefter popper vi elementet fra køen og viser den ændrede kø.

købeholder

Konklusion

Med dette er vi kommet til slutningen af ​​denne tutorial om stakke og køer. Som allerede nævnt er dette de enkleste containere, vi har i STL. En anden variant af købeholderen er kendt som 'Prioritetskø'.

I vores kommende tutorial vil vi diskutere mere om Priority Queue i STL !!

=> Besøg her for at lære C ++ fra bunden.

Anbefalet læsning

^