STL stack bietet die Funktionalität einer Stack-Datenstruktur in C++.

Es folgt die Stapeldatenstruktur LIFO (Last In First Out) Prinzip. Das heißt, das zuletzt hinzugefügte Element wird zuerst entfernt.

Stack-Datenstruktur

Um mehr über Stacks zu erfahren, besuchen Sie unser Tutorial auf Stack Data Structure.

Schaffen Stack

Um einen Stack in C++ zu erstellen, müssen wir zuerst include stack Header-Datei.

#include <stack>

Sobald wir diese Datei importiert haben, können wir sie erstellen stack unter Verwendung der folgenden Syntax:

stack<type> st;

Hier, type gibt den Datentyp dieses Befehls an, den wir im Stack speichern möchten. Zum Beispiel,

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

Beispiel: 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

Im obigen Beispiel haben wir erstellt stack von Zeichenfolgen mit dem Namen Sprachen .

Hier haben wir verwendet push um Elemente zum Stack hinzuzufügen. Wir haben dann verwendet top um das oberste Element anzuzeigen.

Wir werden mehr darüber erfahren push und top später im Tutorial.

Stack-Methoden

In C++, stack -Klasse stellt verschiedene Methoden bereit, um verschiedene Operationen auf einem Stack auszuführen.

Betrieb Beschreibung
push fügt dem Stack ein Element hinzu
pop entfernt ein Element vom Stack
top gibt das Element an der Spitze des Stapels zurück
size gibt die Anzahl der Elemente im Stack zurück
empty kehrt zurück true wenn der Stack leer ist

Element zum Stapel hinzufügen

Wir gebrauchen push um ein Element in einen Stapel hinzuzufügen. Am Beispiel,

#include <iostream>

#include <stack>

using namespace std;

int main {

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

// Elemente in den Stack schieben 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, 

Im obigen Beispiel haben wir einen Stapel von Zeichenfolgen namens Farben erstellt. Dann haben wir verwendet push um Elemente zum Stack hinzuzufügen.

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

Anstatt den Inhalt des Stacks direkt auszudrucken, haben wir verwendet while Schleife und verschiedene Stack-Methoden.

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

Um alle Elemente des Stapels zu drucken, drucken wir seine top element und dann pop(entfernen) es innerhalb der Schleife. Dieser Vorgang wird wiederholt fortgesetzt, bis der Stapel leer ist.

Wir werden darüber erfahren pop, top und empty in den kommenden Abschnitten.

Beachten Sie auch, dass wir die Elemente in dieser Reihenfolge eingefügt haben: {„Red“, „Orange“}.

Aber wenn wir die Elemente drucken, bekommen wir {„Orange“, „Red“}.

Dies liegt daran, dass der Stack eine LIFO-Datenstruktur ist, was bedeutet, dass das zuletzt eingefügte Element zuerst abgerufen wird.

Hinweis: Im Gegensatz zu Vektoren oder anderen Containern können wir keinen Bereich verwenden for Schleife, um einen Stack zu durchlaufen. Dies liegt daran, dass der STL-Stack ein STL-Container-Adapter ist, der einen restriktiven Zugriff bietet, damit er sich wie eine Standard-Stack-Datenstruktur verhält.

Elemente entfernen aus Stack

Mit können wir ein Element aus dem Stack entfernen pop. Am Beispiel,

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

// entfernt „Blue” wie zuletzt eingefügt 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,

Im obigen Beispiel haben wir verwendet pop um ein Element aus dem Stapel zu entfernen.

Anfangs sind die Inhalte des Stacks {„Blue“, „Orange“, „Red“}.

Dann haben wir verwendet pop um das Element zu entfernen.

// removes top element
colors.pop 

Dadurch wird das oberste Element entfernt stack dh das zuletzt eingefügte Element, das ist „Blue“.

Daher wird der letzte Stapel {„Orange“, „Red“}.

Greifen Sie auf Elemente von zu Stack

Wir greifen mit auf das oberste Element des Stacks zu top. Am Beispiel,

#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

Im obigen Beispiel haben wir einen Stapel von Zeichenfolgen namens Farben erstellt und die folgenden Elemente hinzugefügt: „Red“, „Orange“ und „Blue“.

Wir haben dann verwendet top um auf das oberste Element zuzugreifen:

string top = colors.top; 

Hier, „Blue“ wurde zuletzt eingefügt, so ist es top element.

Holen Sie sich die Größe des Stapels

Wir gebrauchen size um die Anzahl der Elemente zu erhalten stack. Am Beispiel,

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

// die Größe des Stacks erhalten int size = prime_nums.size;

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

  return 0;
}

Output

Size of the stack: 3

Im obigen Beispiel haben wir einen Stapel von ganzen Zahlen mit dem Namen prime_nums erstellt und ihm drei Elemente hinzugefügt.

Dann haben wir verwendet size So finden Sie die Anzahl der Elemente im Stapel:

prime_nums.size;

Da wir dem Stapel 3 Elemente hinzugefügt haben, prime_nums.size kehrt zurück 3.

Überprüfen Sie, ob der Stapel leer ist

Wir gebrauchen empty prüfen, ob der Stack leer ist. Diese Methode gibt Folgendes zurück:

  • 1(true)– wenn der Stapel leer ist
  • 0(false)– wenn der Stack nicht leer ist

Am Beispiel,

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

int main {

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

// prüfen, ob der Stack leer ist 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? ";

// prüfen, ob der Stack leer ist if (nums.empty) {

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

  return 0;
}

Output

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

Im obigen Beispiel haben wir verwendet empty festzustellen, ob stack ist leer,

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

Anfänglich enthält der Stapel keine Elemente. So nums.empty kehrt zurück true.

Wir haben dann Elemente zum Stack hinzugefügt.

Wieder verwenden wir nums.empty um festzustellen, ob der Stack leer ist. Diesmal kehrt es zurück false.

Oben sind Informationen über How to Use C++ Stack Um mehr über Stacks zu erfahren [Detailed Guide]. Wenn Sie Fragen haben, fragen Sie bitte fixsy.org in einem Kommentar unten. Ich helfe Ihnen gerne weiter.