stacks queues stl
Lär dig implementeringen av stackar och köer i STL med exempel.
Staplar och köer är två containrar i STL som är mycket grundläggande till sin natur. De är de enklaste behållarna som har breda applikationer inom programvaruprogrammering.
I denna handledning kommer vi att se en detaljerad implementering av båda dessa containrar i STL. Vi kommer också att gå igenom de olika operationerna som stöds av stack och kö med exempel.
=> Se upp den enkla C ++ träningsserien här.
Vad du kommer att lära dig:
Travar
Stackcontainer i STL är en typ av containeradaptrar. Den används för att replikera en stapeldatastruktur i C ++. Stackbehållare är en uppsättning element där elementen infogas i ena änden och också raderas i samma ände.
Denna vanliga punkt för tillägg och radering är känd som 'Top of the stack'.
Bildens bild av stacken visas nedan.
Som visas i ovanstående representation är stacken en behållare i vilken element läggs till och raderas från samma ände som kallas Top of the stack.
Eftersom tillägg och radering sker i samma ände kan vi säga att stackcontainern är typ av LIFO (sista in, först ut) typ av arbete. Detta innebär att elementet som läggs till först är det sista som ska raderas.
För att implementera stackcontainer måste vi inkludera rubriken i vårt program.
#include Den allmänna deklarationssyntaxen för stackcontainer är:
stack stackName; Stack-operationer
Låt oss sedan diskutera de olika operationerna som staplar behållare i STL stöder.
- skjuta på : push-operation används för att infoga ett element i stacken. Denna åtgärd lägger alltid till element högst upp i stacken.
Tänk på en tom stackmystack av heltal .
Låt oss sedan lägga till element 1 i stacken.
Sedan lägger vi till element 3 i stacken.
Enligt representationen läggs ett element till som en följd av en tryckoperation högst upp på stacken. Efter varje tryckoperation ökas stackens storlek med 1.
- pop- : pop-operation används för att ta bort ett element från stacken. Det borttagna elementet är det som pekas mot toppen av stacken. Som ett resultat av popoperationen minskas stackstorleken med 1.
Låt oss se hur popoperationen ser ut:
Tänk på stackmystacket som ovan där vi redan har pressat två element.
Låt oss nu kalla funktionen pop (). När det här samtalet utförs tas elementet längst upp i stacken bort och 'Top' pekar på nästa element som visas nedan.
Om vi återigen kallar pop () kommer nästa element (i detta fall 1) att tas bort, vilket resulterar i en tom stack.
intervjufrågor och svar för mobil testning pdf
- topp : Returnerar det översta elementet i stacken.
- tömma : Kontrollerar om stacken är tom eller inte.
- storlek: Returnerar storleken på stacken, dvs. antalet element i stacken.
Nedan ges ett exempel på Stack-implementering för att bättre förstå operationerna.
#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; } 
Ovanstående exempel visar tydligt pushoperationen som genererar en stack. Den visar också stacken efter två på varandra följande popoperationer.
Således har vi sett stack och dess verksamhet i STL. Vidare, i denna handledning kommer vi att se den detaljerade implementeringen av ännu en enkel STL-behållare som är 'Kö'.
Kö
Kön är ännu en container i STL som också är mycket enkel och användbar. Köbehållare är en replika av ködatastrukturen i C ++. Till skillnad från stack finns det i köbehållaren två ändar, dvs främre och bakre.
Element läggs till i kön på baksidan medan de raderas från kön. I allmänhet använder kön typ av arrangemang av FIFO (First in, First Out).
För att implementera en köbehållare i ett program måste vi inkludera en rubrik i koden.
#include Den allmänna syntaksen för deklarering av kön är:
hur man bygger java-projekt i förmörkelse
kö könamn;
Vi förklarar köbehållaren enligt följande:
Queue myqueue; Köoperationer
Nu ser vi de olika operationerna som stöds av kön.
- skjuta på: Funktionen 'push' lägger till elementet i slutet av kön, dvs längst bak i kön.
- pop: Funktionen 'pop' tar bort det första elementet i kön, dvs. elementet längst fram i kön.
Låt oss förstå push- och pop-funktionerna i kön.
Tänk på en tom kö som deklareras ovanför myqueue. Nu trycker vi på ett jämnt nummer 2 i kön med operationen
myqueue.push (2);
Nu kommer kön att se ut:
Därefter lägger vi till '4' i kön med samtalet 'myqueue.push (4)'.
Nu ser kön ut som visas nedan:
Som framgår ovan skjuts elementen in i kön från baksidan eller baksidan.
Låt oss nu köra på myqueue.
myqueue.pop ();
Så som vi ser, när pop () anropas, tas elementet framför kön bort. Detta innebär att det första elementet som matas in i kön är det första elementet som står utanför kön.
- främre: Denna funktion returnerar en referens till det första elementet i kön.
- tillbaka: Tillbaka returnerar en referens till det sista elementet i kön.
- tömma: Kontrollerar om kön är tom.
- storlek: Returnerar storleken på kön, dvs. antalet element i kön.
Nedan följer ett exempelprogram som visar de operationer som används av köbehållaren.
#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:
Kön myqueue är: 2 4 6 8
myqueue.size (): 4
myqueue.front (): 2
myqueue.back (): 8
myqueue.pop (): 4 6 8
Som visas ovan förklarar vi först en köbehållare. Sedan använder vi push-operationen de fyra första jämna siffrorna i den. Därefter poppar vi elementet från kön och visar den ändrade köen.
Slutsats
Med detta har vi kommit till slutet av denna handledning om staplar och köer. Som redan nämnts är detta de enklaste behållarna som vi har i STL. En annan variant av köbehållaren är känd som 'Priority Queue'.
I vår kommande handledning kommer vi att diskutera mer om Priority Queue i STL !!
=> Besök här för att lära dig C ++ från Scratch.