STL stack giver funktionaliteten af ​​en stak datastruktur i C++.

Stakdatastrukturen følger LIFO (Last In First Out) princip. Det vil sige, at elementet, der tilføjes sidst, fjernes først.

stak datastruktur

For at lære mere om stakke, besøg vores tutorial om Stack Data Structure.

skab Stack

For at oprette en stak i C++ skal vi først inkludere stack header-fil.

#include <stack>

Når vi har importeret denne fil, kan vi oprette stack ved hjælp af følgende syntaks:

stack<type> st;

Her, type angiver datatypen denne kommando denne kommando vil vi gemme i stakken. 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 ovenstående eksempel har vi lavet stack af strenge navngivne sprog .

Her har vi brugt push for at tilføje elementer til stakken. Vi har så brugt top for at vise det øverste element.

Vi vil lære mere om push og top senere i selvstudiet.

Stakmetoder

I C++, stack klasse giver forskellige metoder til at udføre forskellige operationer på en stak.

Operation Beskrivelse
push tilføjer et element til stakken
pop fjerner et element fra stakken
top returnerer elementet øverst i stakken
size returnerer antallet af elementer i stakken
empty vender tilbage true hvis stakken er tom

Tilføj element til stakken

Vi bruger push at tilføje et element til en stak. F.eks.

#include <iostream>

#include <stack>

using namespace std;

int main {

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

// skubbe elementer ind i stakken 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 ovenstående eksempel har vi lavet en stak strenge kaldet farver. Så har vi brugt push for at tilføje elementer til stakken.

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

I stedet for direkte at printe indholdet af stakken, har vi brugt while loop og forskellige stakmetoder.

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

For at udskrive alle elementer i stakken, udskriver vi dens top element og så pop(fjern) den inde i løkken. Denne proces fortsætter gentagne gange, indtil stakken er tom.

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

Bemærk også, at vi har indsat elementerne i denne rækkefølge: {“Red”, “Orange”}.

Men når vi udskriver elementerne, får vi {“Orange”, “Red”}.

Dette skyldes, at stakken er en LIFO-datastruktur, hvilket betyder, at element, der er indsat sidst, hentes først.

Bemærk: I modsætning til vektorer eller andre beholdere kan vi ikke bruge et område for loop for at iterere gennem en stak. Dette skyldes, at STL-stakken er en STL Container Adapter, som giver restriktiv adgang til at få den til at opføre sig som en standard stakdatastruktur.

Fjern elementer fra Stack

Vi kan fjerne et element fra stakken vha pop. F.eks.

#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 blev indsat sidste 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 ovenstående eksempel har vi brugt pop at fjerne et element fra stakken.

Indledningsvis er indholdet af stakken {“Blue”, “Orange”, “Red”}.

Så har vi brugt pop for at fjerne elementet.

// removes top element
colors.pop 

Dette fjerner elementet øverst på stack dvs. elementet indsat sidst, dvs “Blue”.

Derfor bliver den sidste stak {“Orange”, “Red”}.

Få adgang til elementer fra Stack

Vi får adgang til elementet i toppen af ​​stakken vha top. F.eks.

#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 ovenstående eksempel har vi lavet en stak strenge kaldet farver og tilføjet følgende elementer: “Red”, “Orange” og “Blue”.

Vi har så brugt top for at få adgang til det øverste element:

string top = colors.top; 

Her, “Blue” blev indsat sidst, så det er top element.

Få stakkens størrelse

Vi bruger size for at få antallet af elementer ind stack. F.eks.

#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å stakken int size = prime_nums.size;

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

  return 0;
}

Output

Size of the stack: 3

I ovenstående eksempel har vi lavet en stak heltal kaldet prime_nums og tilføjet tre elementer til den.

Så har vi brugt size for at finde antallet af elementer i stakken:

prime_nums.size;

Da vi har tilføjet 3 elementer til stakken, prime_nums.size vender tilbage 3.

Tjek, om stakken er tom

Vi bruger empty for at kontrollere, om stakken er tom. Denne metode returnerer:

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

F.eks.

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

int main {

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

// tjek om stakken 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? ";

// tjek om stakken 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 ovenstående eksempel har vi brugt empty at afgøre om stack er tom,

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

I starten har stakken ingen elementer i sig. Så nums.empty vender tilbage true.

Vi har derefter tilføjet elementer til stakken.

Igen bruger vi nums.empty for at afgøre, om stakken er tom. Denne gang vender det tilbage false.

Ovenstående er information vedr Sådan bruger du C++ Stack For at lære mere om stakke [Detailed Guide]. Spørg venligst, hvis du har spørgsmål fixsy.org i en kommentar nedenfor. Jeg hjælper dig gerne.