STL stack zapewnia funkcjonalność struktury danych stosu w C++.

Struktura danych stosu jest następująca LIFO (Last In First Out) zasada. Oznacza to, że element dodany jako ostatni zostanie usunięty jako pierwszy.

Struktura danych stosu

Aby dowiedzieć się więcej o stosach, odwiedź nasz samouczek na Stack Data Structure.

Tworzyć Stack

Aby utworzyć stos w C++, najpierw musimy uwzględnić stack plik nagłówkowy.

#include <stack>

Po zaimportowaniu tego pliku możemy stworzyć stack używając następującej składni:

stack<type> st;

Tutaj, type wskazuje typ danych to polecenie to polecenie, które chcemy przechowywać na stosie. Na przykład

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

Przykład: stos C++ STL

#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

W powyższym przykładzie stworzyliśmy stack ciągów nazwanych językami .

Tutaj użyliśmy push aby dodać elementy do stosu. Użyliśmy wtedy top aby wyświetlić górny element.

Dowiemy się więcej push oraz top później w samouczku.

Metody stosu

w C++, stack class udostępnia różne metody wykonywania różnych operacji na stosie.

Operacja Opis
push dodaje element do stosu
pop usuwa element ze stosu
top zwraca element ze szczytu stosu
size zwraca liczbę elementów na stosie
empty zwroty true jeśli stos jest pusty

Dodaj element do stosu

Używamy push aby dodać element do stosu. Na przykład

#include <iostream>

#include <stack>

using namespace std;

int main {

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

// wstawiaj elementy do stosu 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, 

W powyższym przykładzie utworzyliśmy stos ciągów zwanych kolorami. Następnie użyliśmy push aby dodać elementy do stosu.

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

Zamiast bezpośrednio drukować zawartość stosu, użyliśmy while pętla i różne metody stosu.

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

Aby wydrukować wszystkie elementy stosu, wypisujemy jego top element i wtedy pop(usuń) go wewnątrz pętli. Ten proces jest powtarzany wielokrotnie, aż stos jest pusty.

Dowiemy się o pop, top oraz empty w kolejnych sekcjach.

Zauważ również, że wstawiliśmy elementy w tej kolejności: {„Red”, „Orange”}.

Ale drukując elementy, otrzymujemy {„Orange”, „Red”}.

Dzieje się tak, ponieważ stos jest strukturą danych LIFO, co oznacza, że ​​element wstawiony jako ostatni jest pobierany jako pierwszy.

Uwaga: W przeciwieństwie do wektorów lub innych pojemników, nie możemy użyć odległości for pętla do iteracji przez stos. Dzieje się tak, ponieważ stos STL jest adapterem kontenera STL, który zapewnia restrykcyjny dostęp, aby zachowywał się jak standardowa struktura danych stosu.

Usuń elementy z Stack

Możemy usunąć element ze stosu za pomocą pop. Na przykład

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

// usuwa „Blue” jak został wstawiony ostatnio 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,

W powyższym przykładzie użyliśmy pop aby usunąć element ze stosu.

Początkowo zawartość stosu to {„Blue”, „Orange”, „Red”}.

Następnie użyliśmy pop aby usunąć element.

// removes top element
colors.pop 

Spowoduje to usunięcie elementu na górze stack tzn. element wstawiony jako ostatni, czyli „Blue”.

Stąd ostateczny stos staje się {„Orange”, „Red”}.

Dostęp do elementów z Stack

Dostęp do elementu na szczycie stosu uzyskujemy za pomocą top. Na przykład

#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

W powyższym przykładzie utworzyliśmy stos ciągów nazwanych kolorami i dodaliśmy następujące elementy: „Red”, „Orange” oraz „Blue”.

Użyliśmy wtedy top aby uzyskać dostęp do górnego elementu:

string top = colors.top; 

Tutaj, „Blue” został wstawiony jako ostatni, więc jest top element.

Uzyskaj rozmiar stosu

Używamy size aby uzyskać liczbę elementów w stack. Na przykład

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

// pobierz rozmiar stosu int size = prime_nums.size;

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

  return 0;
}

Output

Size of the stack: 3

W powyższym przykładzie stworzyliśmy stos liczb całkowitych o nazwie prime_nums i dodaliśmy do niego trzy elementy.

Następnie użyliśmy size aby znaleźć liczbę elementów w stosie:

prime_nums.size;

Ponieważ dodaliśmy 3 elementy do stosu, prime_nums.size zwroty 3.

Sprawdź, czy stos jest pusty

Używamy empty aby sprawdzić, czy stos jest pusty. Ta metoda zwraca:

  • 1(true)– jeśli stos jest pusty
  • 0(false)– jeśli stos nie jest pusty

Na przykład

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

int main {

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

// sprawdź, czy stos jest pusty 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? ";

// sprawdź, czy stos jest pusty if (nums.empty) {

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

  return 0;
}

Output

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

W powyższym przykładzie użyliśmy empty aby ustalić, czy stack jest pusty,

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

Początkowo stos nie zawiera żadnych elementów. Więc nums.empty zwroty true.

Następnie dodaliśmy elementy do stosu.

Ponownie używamy nums.empty aby określić, czy stos jest pusty. Tym razem powraca false.

Powyżej znajdują się informacje o Jak używać stosu C++ Aby dowiedzieć się więcej o stosach [Detailed Guide]. Jeśli masz jakieś pytania, zapytaj fixsy.org w komentarzu poniżej. Chętnie Ci pomogę.