STL stack fournit la fonctionnalité d’une structure de données de pile en C++.

La structure de données de la pile suit LIFO (Last In First Out) principe. C’est-à-dire que l’élément ajouté en dernier sera supprimé en premier.

Structure des données de la pile

Pour en savoir plus sur les piles, visitez notre tutoriel sur Stack Data Structure.

Créer Stack

Afin de créer une pile en C++, nous devons d’abord inclure stack En tête de fichier.

#include <stack>

Une fois que nous avons importé ce fichier, nous pouvons créer stack en utilisant la syntaxe suivante :

stack<type> st;

Ici, type indique le type de données cette commande cette commande que nous voulons stocker dans la pile. Par exemple,

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

Exemple : Pile STL C++

#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

Dans l’exemple ci-dessus, nous avons créé stack de chaînes nommées langues .

Ici, nous avons utilisé push pour ajouter des éléments à la pile. Nous avons alors utilisé top pour afficher l’élément supérieur.

Nous en apprendrons plus sur push et top plus tard dans le tutoriel.

Méthodes de pile

En C++, stack La classe fournit diverses méthodes pour effectuer différentes opérations sur une pile.

Opération La description
push ajoute un élément dans la pile
pop supprime un élément de la pile
top renvoie l’élément en haut de la pile
size renvoie le nombre d’éléments dans la pile
empty Retour true si la pile est vide

Ajouter un élément dans la pile

Nous utilisons push pour ajouter un élément dans une pile. Par exemple,

#include <iostream>

#include <stack>

using namespace std;

int main {

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

// pousse les éléments dans la pile 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, 

Dans l’exemple ci-dessus, nous avons créé une pile de chaînes appelées couleurs. Ensuite, nous avons utilisé push pour ajouter des éléments à la pile.

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

Au lieu d’imprimer directement le contenu de la pile, nous avons utilisé while boucle et diverses méthodes de pile.

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

Pour imprimer tous les éléments de la pile, nous imprimons son top element et alors pop(supprimer) à l’intérieur de la boucle. Ce processus se poursuit à plusieurs reprises jusqu’à ce que la pile soit vide.

Nous allons apprendre sur pop, top et empty dans les rubriques à venir.

Notez également que nous avons inséré les éléments dans cet ordre : {« Red », « Orange »}.

Mais lors de l’impression des éléments, on obtient {« Orange », « Red »}.

En effet, la pile est une structure de données LIFO, ce qui signifie que l’élément inséré en dernier est récupéré en premier.

Remarque : Contrairement aux vecteurs ou autres conteneurs, nous ne pouvons pas utiliser une plage for boucle pour parcourir une pile. En effet, la pile STL est un adaptateur de conteneur STL, qui fournit un accès restrictif pour qu’elle se comporte comme une structure de données de pile standard.

Supprimer des éléments de Stack

Nous pouvons supprimer un élément de la pile en utilisant pop. Par exemple,

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

// supprime « Blue” tel qu’il a été inséré last 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,

Dans l’exemple ci-dessus, nous avons utilisé pop pour supprimer un élément de la pile.

Initialement, le contenu de la pile est {« Blue », « Orange », « Red »}.

Ensuite, nous avons utilisé pop pour supprimer l’élément.

// removes top element
colors.pop 

Cela supprime l’élément en haut de stack c’est-à-dire l’élément inséré en dernier, qui est « Blue ».

Par conséquent, la pile finale devient {« Orange », « Red »}.

Accéder aux éléments depuis Stack

On accède à l’élément en haut de la pile en utilisant top. Par exemple,

#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

Dans l’exemple ci-dessus, nous avons créé une pile de chaînes appelées couleurs et ajouté les éléments suivants : « Red », « Orange » et « Blue ».

Nous avons alors utilisé top pour accéder à l’élément supérieur :

string top = colors.top; 

Ici, « Blue » a été inséré en dernier, il est donc top element.

Obtenir la taille de la pile

Nous utilisons size pour obtenir le nombre d’éléments dans stack. Par exemple,

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

// récupère la taille de la pile int size = prime_nums.size;

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

  return 0;
}

Output

Size of the stack: 3

Dans l’exemple ci-dessus, nous avons créé une pile d’entiers appelée prime_nums et y avons ajouté trois éléments.

Ensuite, nous avons utilisé size pour trouver le nombre d’éléments dans la pile :

prime_nums.size;

Puisque nous avons ajouté 3 éléments à la pile, prime_nums.size Retour 3.

Vérifier si la pile est vide

Nous utilisons empty pour vérifier si la pile est vide. Cette méthode renvoie :

  • 1(true)– si la pile est vide
  • 0(false)– si la pile n’est pas vide

Par exemple,

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

int main {

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

// vérifie si la pile est vide 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? ";

// vérifie si la pile est vide if (nums.empty) {

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

  return 0;
}

Output

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

Dans l’exemple ci-dessus, nous avons utilisé empty pour déterminer si stack est vide,

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

Initialement, la pile ne contient aucun élément. Alors nums.empty Retour true.

Nous avons ensuite ajouté des éléments à la pile.

Encore une fois, nous utilisons nums.empty pour déterminer si la pile est vide. Cette fois, ça revient false.

Ci-dessus, des informations sur Comment utiliser la pile C++ Pour en savoir plus sur les piles [Detailed Guide]. Si vous avez des questions, n’hésitez pas à demander fixsy.org dans un commentaire ci-dessous. Je suis heureux de vous aider.