stack data structure c with illustration
hvordan man skriver en god prøvesak
Alt du trenger å vite om Stack In C ++.
Stack er en grunnleggende datastruktur som brukes til å lagre elementer på en lineær måte.
Stack følger LIFO (sist inn, først ut) rekkefølge eller tilnærming der operasjonene utføres. Dette betyr at elementet som ble lagt sist til bunken vil være det første elementet som blir fjernet fra bunken.
=> Besøk her for å se hele C ++ treningsserien for alle.
Hva du vil lære:
Stack In C ++
En stabel ligner på den virkelige stakken eller en haug med ting som vi stabler hver over hverandre.
Nedenfor er en billedlig fremstilling av Stack.
Som vist ovenfor er det en haug med plater stablet oppå hverandre. Hvis vi vil legge til et annet element i det, legger vi det øverst på bunken som vist i figuren ovenfor (venstre side). Denne operasjonen for å legge til et element i stabelen kalles “ Trykk ”.
På høyre side har vi vist en motsatt operasjon, dvs. vi fjerner et element fra bunken. Dette gjøres også fra samme ende, dvs. toppen av bunken. Denne operasjonen kalles “ Pop ”.
Som vist i figuren ovenfor ser vi at push og pop utføres fra samme ende. Dette gjør at stabelen følger LIFO-ordren. Posisjonen eller enden fra hvilken elementene skyves inn eller poppes ut til / fra bunken kalles “ Toppen av bunken ”.
Først når det ikke er noen gjenstander i bunken, er toppen av bunken satt til -1. Når vi legger til et element i bunken, økes toppen av bunken med 1 som indikerer at varen er lagt til. I motsetning til dette blir toppen av bunken redusert med 1 når en gjenstand spratt ut av bunken.
Deretter vil vi se noen av de grunnleggende operasjonene til stabeldatastrukturen som vi trenger når vi implementerer stabelen.
Grunnleggende operasjoner
Følgende er de grunnleggende operasjonene som støttes av stabelen.
- skyve - Legger til eller skyver et element i bunken.
- pop - Fjerner eller spretter et element ut av bunken.
- kikke - Får toppelementet i bunken, men fjerner den ikke.
- er full - Tester om bunken er full.
- er tom - Tester om bunken er tom.
Illustrasjon
Illustrasjonen ovenfor viser sekvensen av operasjoner som utføres på bunken. I utgangspunktet er bunken tom. For en tom stabel er toppen av stakken satt til -1.
Deretter skyver vi elementet 10 inn i bunken. Vi ser at toppen av stabelen nå peker mot element 10.
Deretter utfører vi en annen skyveoperasjon med element 20, som et resultat av at toppen av stabelen nå peker mot 20. Denne tilstanden er den tredje figuren.
Nå i den siste figuren utfører vi en pop () -operasjon. Som et resultat av popoperasjonen blir elementet som er pekt på toppen av stabelen fjernet fra stabelen. Derfor ser vi på figuren at element 20 er fjernet fra bunken. Dermed peker toppen av stabelen nå mot 10.
På denne måten kan vi enkelt finne ut LIFO-tilnærmingen som brukes av stack.
Gjennomføring
# 1) Bruke matriser
Følgende er C ++ implementering av stack ved hjelp av arrays:
#include using namespace std; #define MAX 1000 //max size for stack class Stack { int top; public: int myStack(MAX); //stack array Stack() { top = -1; } bool push(int x); int pop(); bool isEmpty(); }; //pushes element on to the stack bool Stack::push(int item) { if (top >= (MAX-1)) { cout << 'Stack Overflow!!!'; return false; } else { myStack(++top) = item; cout< Produksjon:
Stack Push
to
4
6
The Stack Pop:
6
4
to
I utgangen kan vi se at elementene skyves inn i stabelen i en rekkefølge og poppes ut av stabelen i motsatt rekkefølge. Dette viser LIFO (Last in, First out) tilnærming for stabelen.
For den ovennevnte arrayimplementeringen av stakken kan vi konkludere med at dette er veldig enkelt å implementere, da det ikke er noen pekere involvert. Men samtidig er størrelsen på stabelen statisk, og stabelen kan ikke vokse eller krympe dynamisk.
Deretter vil vi implementere stabelen ved hjelp av matriser i Java-programmeringsspråk.
class Stack { static final int MAX = 1000; // Maximum Stack size int top; int myStack() = new int(MAX); boolean isEmpty() { return (top = (MAX-1)) { System.out.println('Stack Overflow'); return false; } else { myStack(++top) = item; System.out.println(item); return true; } } int pop() { if (top <0) { System.out.println('Stack Underflow'); return 0; } else { int item = myStack(top--); return item; } } } //Main class code class Main { public static void main(String args()) { Stack stack = new Stack(); System.out.println('Stack Push:'); stack.push(1); stack.push(3); stack.push(5); System.out.println('Stack Pop:'); while(!stack.isEmpty()) { System.out.println(stack.pop()); } } } Produksjon:
Stack Push:
en
3
5
Stack Pop:
5
3
en
Implementeringslogikken er den samme som i C ++ implementering. Utgangen viser LIFO-teknikken for å skyve inn og poppe ut av elementene til / fra bunken.
Som allerede nevnt er stakkimplementering ved hjelp av arrays den enkleste implementeringen, men er av statisk karakter, ettersom vi ikke dynamisk kan vokse eller krympe stakken.
# 2) Bruke en koblet liste
Deretter implementerer vi stabeloperasjoner ved hjelp av en koblet liste i både C ++ og Java. Først vil vi demonstrere C ++ implementeringen.
#include using namespace std; // class to represent a stack node class StackNode { public: int data; StackNode* next; }; StackNode* newNode(int data) { StackNode* stackNode = new StackNode(); stackNode->data = data; stackNode->next = NULL; return stackNode; } int isEmpty(StackNode *root) { return !root; } void push(StackNode** root, int new_data){ StackNode* stackNode = newNode(new_data); stackNode->next = *root; *root = stackNode; cout<data; free(temp); return popped; } int peek(StackNode* root) { if (isEmpty(root)) return -1; return root->data; } int main() { StackNode* root = NULL; cout<<'Stack Push:'< Produksjon:
Stack Push:
100
200
300
Toppelementet er 300
Stack Pop:
300
200
100
Toppelementet er -1
Deretter presenterer vi Java-implementeringen av stakken ved hjelp av en koblet liste.
class LinkedListStack { StackNode root; static class StackNode { int data; StackNode next; StackNode(int data) { this.data = data; } } public boolean isEmpty() { if (root == null) { return true; } else return false; } public void push(int new_data) { StackNode newNode = new StackNode(new_data); if (root == null) { root = newNode; } else { StackNode temp = root; root = newNode; newNode.next = temp; } System.out.println(new_data); } public int pop() { int popped = Integer.MIN_VALUE; if (root == null) { System.out.println('Stack is Empty'); } else { popped = root.data; root = root.next; } return popped; } public int peek() { if (root == null) { System.out.println('Stack is empty'); return Integer.MIN_VALUE; } else { return root.data; } } } class Main{ public static void main(String() args) { LinkedListStack stack = new LinkedListStack(); System.out.println('Stack Push:'); stack.push(100); stack.push(200); stack.push(300); System.out.println('Top element is ' + stack.peek()); System.out.println('Stack Pop:'); while(!stack.isEmpty()){ System.out.println(stack.pop()); } System.out.println('Top element is ' + stack.peek()); } } Produksjon:
Stack Push:
100
200
hvordan man tester for SQL-injeksjon
300
Toppelementet er 300
Stack Pop:
300
200
100
Bunken er tom
Toppelement er -2147483648
Vi har nettopp sett C ++ og Java-implementeringer for en stabel ved hjelp av koblede lister. Vi representerer hver stabeloppføring som en node på den koblede listen. Den viktigste fordelen med denne implementeringen er at den er dynamisk. Dette betyr at vi kan vokse eller krympe stabelstørrelsen i henhold til vårt krav.
Dette er i motsetning til tilfellet med stackimplementering ved hjelp av arrays der vi må erklære størrelsen på forhånd og ikke kan endre den dynamisk.
Ulempen med denne implementeringen er at når vi bruker pekepinner overalt, tar det litt for mye plass sammenlignet med arrayimplementering.
Anvendelser av Stack
La oss diskutere noen av applikasjonene til stabeldatastrukturen. Stakkedatastrukturen brukes i en rekke applikasjoner i programvareprogrammering, hovedsakelig på grunn av sin enkelhet og enkel implementering.
Vi vil kort beskrive noen av applikasjonene i stakken nedenfor:
# 1) Infix To Postfix Expressions
Ethvert generelt aritmetisk uttrykk er av formen operand1 OP operand 2 .
Basert på stillingen til operatør OP, har vi følgende typer uttrykk:
- Infix - Den generelle formen for infiksuttrykk er “ operand1 OP operand 2 ”. Dette er uttrykkets grunnform og vi bruker i matematikk hele tiden.
- Prefiks - Når en operatør blir plassert før operandene, er det et prefiksuttrykk. Den generelle formen for infiksuttrykk er “ OP operand1 operand2 ”.
- Postfix - I postfix-uttrykk skrives operander først etterfulgt av operatøren. Den har skjemaet “operand1 operand2 OP”.
Tenk på uttrykket “a + b * c ' . Kompilatoren skanner uttrykket enten fra venstre til høyre eller høyre mot venstre. Ved å ta vare på operatørens prioritet og assosiativitet, vil den først skanne uttrykket for å evaluere uttrykket b * c. Deretter må den igjen skanne uttrykket for å legge til resultatet av b * c til a.
Etter hvert som uttrykkene blir mer og mer komplekse, blir denne typen tilnærming til å skanne uttrykket igjen og igjen ineffektivt.
For å overvinne denne ineffektiviteten konverterer vi uttrykket til postfiks eller prefiks slik at de enkelt kan evalueres ved hjelp av en stabeldatastruktur.
# 2) Uttrykksparsing / evaluering
Ved hjelp av stack kan vi også utføre faktisk uttrykk evaluering. I dette blir uttrykket skannet fra venstre til høyre, og operander skyves videre til bunken.
Hver gang en operatør blir møtt, poppes operandene ut og operasjonen utføres. Resultatet av operasjonen skyves igjen inn i bunken. Denne måten uttrykket blir evaluert på ved hjelp av stabelen og det endelige resultatet av uttrykket, er vanligvis den gjeldende toppen av stabelen.
# 3) Tree Traversals
Tredatastrukturen kan krysses for å besøke hver node på mange måter, og avhengig av når rotnoden vi har besøkt.
- i Bestill traversal
- forhåndsbestill Traversal
- postOrder traversal
For å effektivt krysse treet bruker vi stabeldatastruktur for å skyve mellomnoder på stabelen slik at vi opprettholder rekkefølgen for traversal.
# 4) Sorteringsalgoritmer
Sorteringsalgoritmer som quicksort kan gjøres mer effektive ved hjelp av stabeldatastrukturene.
# 5) Towers of Hanoi
Dette er et klassisk problem som involverer n antall skiver og tre tårn, og problemet innebærer å flytte skivene fra ett tårn til et annet med det tredje tårnet brukt som mellomliggende.
Dette problemet kan håndteres effektivt ved hjelp av stabelen når vi skyver platene som skal flyttes til stabelen, da stabelen i utgangspunktet fungerer som et tårn som brukes til å flytte platene.
Konklusjon
Stakken er den enkleste datastrukturen og lettere å implementere som et program. Den brukte LIFO (siste inn, første ut) tilnærmingen, noe som betyr at elementet som ble angitt sist er det som fjernes først. Dette er fordi stack bare bruker den ene enden til å legge til (push) og fjerne (pop) elementer.
Stakkedatastrukturen har mange bruksområder i programvare programmering. Den fremtredende blant dem er uttrykksevalueringer. Ekspresjonsevaluering inkluderer også konvertering av uttrykket fra infiks til postfiks eller prefiks. Det innebærer også å evaluere uttrykket for å gi det endelige resultatet.
I denne veiledningen har vi sett illustrasjonen og implementeringen av stakken, samt dens forskjellige operasjoner.
I vår kommende opplæring vil vi lære om kødatastrukturen i detalj.
=> Besøk her for hele C ++ kurset fra eksperter.
Anbefalt lesing
- Kødatastruktur i C ++ med illustrasjon
- Sirkulær sammenkoblet liste Datastruktur i C ++ med illustrasjon
- Koblet liste Datastruktur i C ++ med illustrasjon
- Prioritert kødatastruktur i C ++ med illustrasjon
- Dobbeltkoblet listedatastruktur i C ++ med illustrasjon
- Introduksjon til datastrukturer i C ++
- JMeter-dataparameterisering ved bruk av brukerdefinerte variabler
- 10+ beste datainnsamlingsverktøy med strategier for datainnsamling