STL stack ger funktionen hos en stackdatastruktur i C++.

Stackdatastrukturen följer LIFO (Last In First Out) princip. Det vill säga att elementet som läggs till sist tas bort först.

Stack datastruktur

För att lära dig mer om stackar, besök vår handledning om Stack Data Structure.

Skapa Stack

För att skapa en stack i C++ måste vi först inkludera stack header-fil.

#include <stack>

När vi har importerat den här filen kan vi skapa stack använder följande syntax:

stack<type> st;

Här, type indikerar datatypen detta kommando detta kommando vi vill lagra i stacken. Till exempel,

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

Exempel: 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 exemplet ovan har vi skapat stack av strängar namngivna språk .

Här har vi använt push för att lägga till element i stacken. Vi har då använt top för att visa det översta elementet.

Vi kommer att lära oss mer om push och top senare i handledningen.

Stackmetoder

I C++, stack klass tillhandahåller olika metoder för att utföra olika operationer på en stack.

Drift Beskrivning
push lägger till ett element i stacken
pop tar bort ett element från stapeln
top returnerar elementet överst i stacken
size returnerar antalet element i stacken
empty returnerar true om stapeln är tom

Lägg till element i stapeln

Vi använder push för att lägga till ett element i en stack. Till exempel,

#include <iostream>

#include <stack>

using namespace std;

int main {

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

// tryck in element i stapeln 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 exemplet ovan har vi skapat en stapel med strängar som kallas färger. Då har vi använt push för att lägga till element i stacken.

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

Istället för att direkt skriva ut innehållet i högen har vi använt while loop och olika stackmetoder.

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

För att skriva ut alla delar av stapeln skriver vi ut dess top element och då pop(ta bort) den inuti öglan. Denna process fortsätter upprepade gånger tills stacken är tom.

Vi kommer att lära oss om pop, top och empty i de kommande avsnitten.

Observera också att vi har infogat elementen i denna ordning: {”Red”, ”Orange”}.

Men vid utskrift av elementen får vi {”Orange”, ”Red”}.

Detta beror på att stacken är en LIFO-datastruktur, vilket innebär att det sist infogade elementet hämtas först.

Obs: Till skillnad från vektorer eller andra behållare kan vi inte använda ett område for loop för att iterera genom en stack. Detta beror på att STL-stacken är en STL Container Adapter, som ger restriktiv åtkomst för att få den att bete sig som en standard stackdatastruktur.

Ta bort element från Stack

Vi kan ta bort ett element från stacken med hjälp av pop. Till exempel,

#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);

// tar bort ”Blue” som det infogades senast 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 exemplet ovan har vi använt pop för att ta bort ett element från stapeln.

Inledningsvis är innehållet i högen {”Blue”, ”Orange”, ”Red”}.

Då har vi använt pop för att ta bort elementet.

// removes top element
colors.pop 

Detta tar bort elementet överst på stack dvs elementet som infogades sist, dvs ”Blue”.

Därför blir den sista stapeln {”Orange”, ”Red”}.

Få åtkomst till element från Stack

Vi kommer åt elementet överst i stapeln med hjälp av top. Till exempel,

#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 exemplet ovan har vi skapat en hög med strängar som kallas färger och lagt till följande element: ”Red”, ”Orange” och ”Blue”.

Vi har då använt top för att komma åt det översta elementet:

string top = colors.top; 

Här, ”Blue” lades in sist, så är det top element.

Få storleken på stapeln

Vi använder size för att få in antalet element stack. Till exempel,

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

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

  return 0;
}

Output

Size of the stack: 3

I exemplet ovan har vi skapat en stack med heltal som kallas prime_nums och lagt till tre element till den.

Då har vi använt size för att hitta antalet element i stacken:

prime_nums.size;

Eftersom vi har lagt till 3 element till stacken, prime_nums.size returnerar 3.

Kontrollera om stapeln är tom

Vi använder empty för att kontrollera om stacken är tom. Denna metod returnerar:

  • 1(true)– om högen är tom
  • 0(false)– om stapeln inte är tom

Till exempel,

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

int main {

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

// kontrollera om stacken är 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? ";

// kontrollera om stacken är 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 exemplet ovan har vi använt empty att avgöra om stack är tom,

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

Till en början har stacken inga element i sig. Så nums.empty returnerar true.

Vi har sedan lagt till element i stacken.

Återigen använder vi nums.empty för att avgöra om stacken är tom. Den här gången kommer den tillbaka false.

Ovan finns information om Hur man använder C++ Stack För att lära dig mer om stackar [Detailed Guide]. Om du har några frågor, vänligen fråga fixsy.org i en kommentar nedan. Jag hjälper dig gärna.