STL stack proporciona la funcionalidad de una estructura de datos de pila en C++.

La estructura de datos de la pila sigue LIFO (Last In First Out) principio. Es decir, el último elemento agregado se eliminará primero.

Estructura de datos de pila

Para obtener más información sobre las pilas, visite nuestro tutorial sobre Stack Data Structure.

Crear Stack

Para crear una pila en C++, primero debemos incluir stack archivo de cabecera.

#include <stack>

Una vez que importamos este archivo, podemos crear stack usando la siguiente sintaxis:

stack<type> st;

Aquí, type indica el tipo de datos este comando este comando que queremos almacenar en la pila. Por ejemplo,

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

Ejemplo: pila STL de 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

En el ejemplo anterior, hemos creado stack de cadenas llamadas idiomas .

Aquí, hemos utilizado push para agregar elementos a la pila. Entonces hemos usado top para mostrar el elemento superior.

Aprenderemos más sobre push y top más adelante en el tutorial.

métodos de pila

En C++, stack La clase proporciona varios métodos para realizar diferentes operaciones en una pila.

Operación Descripción
push añade un elemento a la pila
pop elimina un elemento de la pila
top devuelve el elemento en la parte superior de la pila
size devuelve el número de elementos en la pila
empty devoluciones true si la pila está vacía

Agregar elemento a la pila

Usamos push para agregar un elemento a una pila. Por ejemplo,

#include <iostream>

#include <stack>

using namespace std;

int main {

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

// inserta elementos en la pila 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, 

En el ejemplo anterior, hemos creado una pila de cadenas llamadas colores. Entonces, hemos usado push para agregar elementos a la pila.

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

En lugar de imprimir directamente el contenido de la pila, hemos usado while bucle y varios métodos de pila.

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

Para imprimir todos los elementos de la pila, imprimimos su top element y entonces pop(quitarlo) dentro del bucle. Este proceso continúa repetidamente hasta que la pila está vacía.

aprenderemos sobre pop, top y empty en las próximas secciones.

Observe también que hemos insertado los elementos en este orden: {«Red», «Orange»}.

Pero al imprimir los elementos, obtenemos {«Orange», «Red»}.

Esto se debe a que la pila es una estructura de datos LIFO, lo que significa que el último elemento insertado se recupera primero.

Nota: a diferencia de los vectores u otros contenedores, no podemos usar un rango for bucle para iterar a través de una pila. Esto se debe a que la pila STL es un adaptador de contenedor STL, que proporciona acceso restrictivo para que se comporte como una estructura de datos de pila estándar.

Eliminar elementos de Stack

Podemos eliminar un elemento de la pila usando pop. Por ejemplo,

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

// elimina «Blue” como se insertó el último 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,

En el ejemplo anterior, hemos utilizado pop para eliminar un elemento de la pila.

Inicialmente, el contenido de la pila es {«Blue», «Orange», «Red»}.

Entonces hemos usado pop para eliminar el elemento.

// removes top element
colors.pop 

Esto elimina el elemento en la parte superior de stack es decir, el último elemento insertado, que es «Blue».

Por lo tanto, la pila final se convierte en {«Orange», «Red»}.

Acceder a elementos desde Stack

Accedemos al elemento en la parte superior de la pila usando top. Por ejemplo,

#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

En el ejemplo anterior, hemos creado una pila de cadenas llamadas colores y hemos agregado los siguientes elementos: «Red», «Orange» y «Blue».

Entonces hemos usado top para acceder al elemento superior:

string top = colors.top; 

Aquí, «Blue» se insertó en último lugar, por lo que es top element.

Obtenga el tamaño de la pila

Usamos size para obtener el número de elementos en stack. Por ejemplo,

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

// obtener el tamaño de la pila int size = prime_nums.size;

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

  return 0;
}

Output

Size of the stack: 3

En el ejemplo anterior, hemos creado una pila de enteros llamada prime_nums y le hemos agregado tres elementos.

Entonces hemos usado size para encontrar el número de elementos en la pila:

prime_nums.size;

Como hemos agregado 3 elementos a la pila, prime_nums.size devoluciones 3.

Comprobar si la pila está vacía

Usamos empty para comprobar si la pila está vacía. Este método devuelve:

  • 1(true)– si la pila está vacía
  • 0(false)– si la pila no está vacía

Por ejemplo,

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

int main {

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

// comprobar si la pila está vacía 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? ";

// comprobar si la pila está vacía if (nums.empty) {

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

  return 0;
}

Output

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

En el ejemplo anterior, hemos utilizado empty para determinar si stack esta vacio,

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

Inicialmente, la pila no tiene elementos en ella. Asi que nums.empty devoluciones true.

Luego hemos agregado elementos a la pila.

Nuevamente, usamos nums.empty para determinar si la pila está vacía. Esta vez vuelve false.

Arriba hay información sobre Cómo usar la pila de C++ Para obtener más información sobre las pilas [Detailed Guide]. Si tiene alguna pregunta, por favor pregunte fixsy.org en un comentario a continuación. Estoy feliz de ayudarte.