STL stack gir funksjonaliteten til en stabeldatastruktur i C++.

Stabeldatastrukturen følger LIFO (Last In First Out) prinsipp. Det vil si at elementet som ble lagt til sist, fjernes først.

Stabel datastruktur

For å lære mer om stabler, besøk vår veiledning på Stack Data Structure.

Skape Stack

For å lage en stabel i C++, må vi først inkludere stack header-fil.

#include <stack>

Når vi har importert denne filen, kan vi opprette stack ved å bruke følgende syntaks:

stack<type> st;

Her, type indikerer datatypen denne kommandoen denne kommandoen vi ønsker å lagre i stabelen. For eksempel

// create a stack of integers
 stack<int> integer_stack; 
// create a stack of strings
stack<string> string_stack;

Eksempel: C++ STL Stack

#include <iostream>

#include <stack>

using namespace std;

int main {
    // create a stack of strings

stack<string> languages;

    
    // add element to the Stack
    languages.push("C++");
    languages.push("Java");
    languages.push("Python");
    
    // print top element
    cout << languages.top;

    return 0;
}

Output

Python

I eksemplet ovenfor har vi laget stack av strenger navngitte språk .

Her har vi brukt push for å legge til elementer i stabelen. Vi har da brukt top for å vise det øverste elementet.

Vi vil lære mer om push og top senere i opplæringen.

Stablemetoder

I C++, stack klasse gir forskjellige metoder for å utføre forskjellige operasjoner på en stabel.

Operasjon Beskrivelse
push legger til et element i stabelen
pop fjerner et element fra stabelen
top returnerer elementet øverst i stabelen
size returnerer antall elementer i stabelen
empty returnerer true hvis stabelen er tom

Legg til element i stabelen

Vi bruker push for å legge til et element i en stabel. For eksempel,

#include <iostream>

#include <stack>

using namespace std;

int main {

  // create a stack of strings
  stack<string> colors;

// skyv elementer inn i stabelen colors.push(«Red»); colors.push(«Orange»);

  
  cout << "Stack: ";

  // print elements of stack
   while(!colors.empty) {
    cout << colors.top << ", ";
    colors.pop;
  }
 
  return 0;
}

Output

Stack: Orange, Red, 

I eksemplet ovenfor har vi laget en stabel med strenger kalt farger. Da har vi brukt push for å legge til elementer i stabelen.

colors.push("Red");
colors.push("Orange");

I stedet for direkte å skrive ut innholdet i stabelen, har vi brukt while loop og ulike stabelmetoder.

while(!colors.empty) {
  cout << colors.top << ", ";
  colors.pop;
}

For å skrive ut alle elementene i stabelen, skriver vi ut den top element og så pop(fjern) den inne i løkken. Denne prosessen fortsetter gjentatte ganger til stabelen er tom.

Vi vil lære om pop, top og empty i de kommende avsnittene.

Legg også merke til at vi har satt inn elementene i denne rekkefølgen: {«Red», «Orange»}.

Men ved utskrift av elementene får vi {«Orange», «Red»}.

Dette er fordi stabelen er en LIFO-datastruktur, som betyr at element som er satt inn sist, hentes først.

Merk: I motsetning til vektorer eller andre beholdere kan vi ikke bruke et område for løkke for å iterere gjennom en stabel. Dette er fordi STL-stakken er en STL-beholderadapter, som gir restriktiv tilgang for å få den til å oppføre seg som en standard stabeldatastruktur.

Fjern elementer fra Stack

Vi kan fjerne et element fra stabelen ved å bruke pop. For eksempel,

#include <iostream>
#include <stack>
using namespace std;

// function prototype this command this command for display_stack utility
void display_stack(stack<string> st);

int main {

  // create a stack of strings
  stack<string> colors;

  // push elements into the stack
  colors.push("Red");
  colors.push("Orange");
  colors.push("Blue");
  
  cout << "Initial Stack: ";
  // print elements of stack
  display_stack(colors);

// fjerner «Blue” som det ble satt inn sist colors.pop;

  
  cout << "Final Stack: ";

  // print elements of stack
  display_stack(colors);
  
  return 0;
}

// utility function to display stack elements
void display_stack(stack<string> st) {

  while(!st.empty) {
    cout << st.top << ", ";
    st.pop;
  }

  cout << endl;
}

Output

Initial Stack: Blue, Orange, Red, 
Final Stack: Orange, Red,

I eksemplet ovenfor har vi brukt pop for å fjerne et element fra stabelen.

I utgangspunktet er innholdet i stabelen {«Blue», «Orange», «Red»}.

Da har vi brukt pop for å fjerne elementet.

// removes top element
colors.pop 

Dette fjerner elementet på toppen av stack dvs. elementet satt inn sist, som er «Blue».

Derfor blir den siste stabelen {«Orange», «Red»}.

Få tilgang til elementer fra Stack

Vi får tilgang til elementet på toppen av stabelen ved hjelp av top. For eksempel,

#include <iostream>
#include <stack>
using namespace std;

int main {

  // create a stack of strings
  stack<string> colors;

  // push element into the stack
  colors.push("Red");
  colors.push("Orange");
  colors.push("Blue");
  
  // get top element

string top = colors.top;

  cout << "Top Element: " << top;
  
  return 0;
}

Output

Top Element: Blue

I eksemplet ovenfor har vi laget en stabel med strenger kalt farger og lagt til følgende elementer: «Red», «Orange» og «Blue».

Vi har da brukt top for å få tilgang til det øverste elementet:

string top = colors.top; 

Her, «Blue» ble satt inn sist, så det er top element.

Få størrelsen på stakken

Vi bruker size for å få inn antall elementer stack. For eksempel,

#include <iostream>
#include <stack>
using namespace std;

int main {

  // create a stack of int
  stack<int> prime_nums;

  // push elements into the stack
  prime_nums.push(2);
  prime_nums.push(3);
  prime_nums.push(5);

// få størrelsen på stabelen int size = prime_nums.size;

  cout << "Size of the stack: " << size;

  return 0;
}

Output

Size of the stack: 3

I eksemplet ovenfor har vi laget en stabel med heltall kalt prime_nums og lagt til tre elementer til den.

Da har vi brukt size for å finne antall elementer i stabelen:

prime_nums.size;

Siden vi har lagt til 3 elementer i stabelen, prime_nums.size returnerer 3.

Sjekk om stabelen er tom

Vi bruker empty for å sjekke om stabelen er tom. Denne metoden returnerer:

  • 1(true)– hvis stabelen er tom
  • 0(false)– hvis stabelen ikke er tom

For eksempel,

#include <iostream>
#include <stack>
using namespace std;

int main {

  // create a stack of double
  stack<double> nums;
  
  cout << "Is the stack empty? ";

// sjekk om stabelen er tom if (nums.empty) {

    cout << "Yes" << endl;
  }
  else {
    cout << "No" << endl;
  }

  cout << "Pushing elements..." << endl;

  // push element into the stack
  nums.push(2.3);
  nums.push(9.7);
 
  cout << "Is the stack empty? ";

// sjekk om stabelen er tom if (nums.empty) {

    cout << "Yes";
  }
  else {
    cout << "No";
  }

  return 0;
}

Output

Is the stack empty? Yes
Pushing elements...
Is the stack empty? No

I eksemplet ovenfor har vi brukt empty å avgjøre om stack er tom,

if(nums.empty) { // returns false
  cout << "Yes" << end;;
}
else {
  cout << "No" << endl; 
}

I utgangspunktet har stabelen ingen elementer i seg. Så nums.empty returnerer true.

Vi har så lagt til elementer i stabelen.

Igjen bruker vi nums.empty for å finne ut om stabelen er tom. Denne gangen kommer den tilbake false.

Ovenfor er informasjon om Hvordan bruke C++ Stack For å lære mer om stabler [Detailed Guide]. Hvis du har spørsmål, vennligst spør fixsy.org i en kommentar nedenfor. Jeg hjelper deg gjerne.