STL stack a verem adatstruktúra funkcióit biztosítja C++ nyelven.

A verem adatszerkezete következik LIFO (Last In First Out) elv. Vagyis az utoljára hozzáadott elem törlődik először.

Stack adatstruktúra

Ha többet szeretne megtudni a veremekről, keresse fel oktatóanyagunkat a következő címen: Stack Data Structure.

Teremt Stack

Ahhoz, hogy C++-ban vermet hozzunk létre, először bele kell foglalnunk stack fejléc fájl.

#include <stack>

Miután importáltuk ezt a fájlt, létrehozhatjuk stack a következő szintaxis használatával:

stack<type> st;

Itt, type jelzi az adattípust, ezt a parancsot, amelyet a veremben szeretnénk tárolni. Például

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

Példa: 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

A fenti példában létrehoztuk stack nyelveknek nevezett karakterláncok közül .

Itt használtuk push elemek hozzáadásához a veremhez. Akkor használtuk top a felső elem megjelenítéséhez.

többet megtudunk róla push és top később az oktatóanyagban.

Stack módszerek

C++ nyelven, stack osztály különféle módszereket biztosít különböző műveletek végrehajtásához egy veremen.

Művelet Leírás
push hozzáad egy elemet a veremhez
pop eltávolít egy elemet a veremből
top visszaadja a verem tetején lévő elemet
size a veremben lévő elemek számát adja vissza
empty visszatér true ha a verem üres

Adjon hozzá elemet a veremhez

Mi használjuk push elemet hozzáadni a veremhez. Például

#include <iostream>

#include <stack>

using namespace std;

int main {

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

// elemeket tol a verembe 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, 

A fenti példában színeknek nevezett karakterláncokat hoztunk létre. Akkor mi használtuk push elemek hozzáadásához a veremhez.

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

A verem tartalmának közvetlen kinyomtatása helyett használtuk while hurok és különféle veremmódszerek.

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

A verem összes elemének kinyomtatásához kinyomtatjuk top element és akkor pop(távolítsa el) a hurkon belül. Ez a folyamat addig folytatódik, amíg a verem ki nem ürül.

meg fogjuk tanulni pop, top és empty a következő részekben.

Figyeljük meg azt is, hogy az elemeket ebben a sorrendben illesztettük be: {“Red”, “Orange”}.

De az elemek nyomtatásakor azt kapjuk {“Orange”, “Red”}.

Ennek az az oka, hogy a verem egy LIFO adatstruktúra, ami azt jelenti, hogy az utoljára beillesztett elem kerül lekérésre először.

Megjegyzés: A vektorokkal és más tárolókkal ellentétben nem használhatunk tartományt for Ennek az az oka, hogy az STL-verem egy STL-tároló-adapter, amely korlátozó hozzáférést biztosít ahhoz, hogy szabványos verem-adatstruktúraként viselkedjen.

Elemek eltávolítása innen Stack

A segítségével távolíthatunk el egy elemet a veremből pop. Például

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

// eltávolítja a “Blue” ahogy az utolsó színekben került beillesztésre.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,

A fenti példában használtuk pop elem eltávolításához a veremből.

Kezdetben a verem tartalma az {“Blue”, “Orange”, “Red”}.

Aztán használtuk pop az elem eltávolításához.

// removes top element
colors.pop 

Ezzel eltávolítja a tetején lévő elemet stack azaz az utoljára beszúrt elem, ami van “Blue”.

Így a végső verem lesz {“Orange”, “Red”}.

Elemek elérése innen Stack

A verem tetején lévő elemet a segítségével érjük el top. Például

#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

A fenti példában színeknek nevezett sztringek halmát hoztuk létre, és hozzáadtuk a következő elemeket: “Red”, “Orange” és “Blue”.

Akkor használtuk top a felső elem eléréséhez:

string top = colors.top; 

Itt, “Blue” utoljára került be, tehát az top element.

Szerezze meg a halom méretét

Mi használjuk size hogy az elemek száma bekerüljön stack. Például

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

// a verem méretének lekérése int size = prime_nums.size;

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

  return 0;
}

Output

Size of the stack: 3

A fenti példában létrehoztunk egy prím_számok nevű egész számokat, és három elemet adtunk hozzá.

Aztán használtuk size a veremben lévő elemek számának megkereséséhez:

prime_nums.size;

Mivel 3 elemet adtunk a veremhez, prime_nums.size visszatér 3.

Ellenőrizze, hogy a köteg üres-e

Mi használjuk empty hogy ellenőrizze, üres-e a köteg. Ez a módszer a következőket adja vissza:

  • 1(true)– ha a köteg üres
  • 0(false)– ha a köteg nem üres

Például

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

int main {

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

// ellenőrizze, hogy a verem üres-e 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? ";

// ellenőrizze, hogy a verem üres-e if (nums.empty) {

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

  return 0;
}

Output

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

A fenti példában használtuk empty annak megállapítására, hogy stack üres,

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

Kezdetben a veremben nincsenek elemek. Így nums.empty visszatér true.

Ezután hozzáadtunk elemeket a veremhez.

Ismét használjuk nums.empty annak megállapítására, hogy a verem üres-e. Ezúttal visszatér false.

A fenti információk találhatók A C++ Stack használata Ha többet szeretne megtudni a veremekről [Detailed Guide]. Ha kérdése van, kérdezzen fixsy.org lenti kommentben. Örömmel segítek neked.