STL stack fornece a funcionalidade de uma estrutura de dados de pilha em C++.

A estrutura de dados da pilha segue LIFO (Last In First Out) princípio. Ou seja, o elemento adicionado por último será removido primeiro.

Estrutura de dados de pilha

Para saber mais sobre pilhas, visite nosso tutorial em Stack Data Structure.

Crio Stack

Para criar uma pilha em C++, primeiro precisamos incluir stack arquivo de cabeçalho.

#include <stack>

Uma vez que importamos este arquivo, podemos criar stack usando a seguinte sintaxe:

stack<type> st;

Aqui, type indica o tipo de dado este comando este comando que queremos armazenar na pilha. Por exemplo,

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

Exemplo: pilha 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

No exemplo acima, criamos stack de strings com nomes de linguagens .

Aqui, usamos push para adicionar elementos à pilha. Usamos então top para exibir o elemento superior.

Vamos aprender mais sobre push e top mais tarde no tutorial.

Métodos de pilha

Em C++, stack A classe fornece vários métodos para realizar diferentes operações em uma pilha.

Operação Descrição
push adiciona um elemento na pilha
pop remove um elemento da pilha
top retorna o elemento no topo da pilha
size retorna o número de elementos na pilha
empty retorna true se a pilha estiver vazia

Adicionar elemento à pilha

Nós usamos push para adicionar um elemento em uma pilha. Por exemplo,

#include <iostream>

#include <stack>

using namespace std;

int main {

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

// coloca os elementos na pilha 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, 

No exemplo acima, criamos uma pilha de strings chamada colors. Em seguida, usamos push para adicionar elementos à pilha.

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

Em vez de imprimir diretamente o conteúdo da pilha, usamos while loop e vários métodos de pilha.

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

Para imprimir todos os elementos da pilha, imprimimos seu top element e depois pop(remova) dentro do loop. Este processo continua repetidamente até que a pilha esteja vazia.

Vamos aprender sobre pop, top e empty nas próximas seções.

Observe também que inserimos os elementos nesta ordem: {“Red”, “Orange”}.

Mas ao imprimir os elementos, obtemos {“Orange”, “Red”}.

Isso ocorre porque a pilha é uma estrutura de dados LIFO, o que significa que o elemento inserido por último é recuperado primeiro.

Nota: Ao contrário de vetores ou outros contêineres, não podemos usar um ranged for loop para iterar através de uma pilha. Isso ocorre porque a pilha STL é um Adaptador de Contêiner STL, que fornece acesso restritivo para fazê-la se comportar como uma estrutura de dados de pilha padrão.

Remover elementos de Stack

Podemos remover um elemento da pilha usando pop. Por exemplo,

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

// remove “Blue” como foi inserido por ú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,

No exemplo acima, usamos pop para remover um elemento da pilha.

Inicialmente, o conteúdo da pilha é {“Blue”, “Orange”, “Red”}.

Então nós usamos pop para remover o elemento.

// removes top element
colors.pop 

Isso remove o elemento no topo da stack ou seja, o elemento inserido por último, que é “Blue”.

Assim, a pilha final torna-se {“Orange”, “Red”}.

Acessar elementos de Stack

Acessamos o elemento no topo da pilha usando top. Por exemplo,

#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

No exemplo acima, criamos uma pilha de strings chamada colors e adicionamos os seguintes elementos: “Red”, “Orange” e “Blue”.

Usamos então top para acessar o elemento superior:

string top = colors.top; 

Aqui, “Blue” foi inserido por último, então é top element.

Obtenha o tamanho da pilha

Nós usamos size para obter o número de elementos em stack. Por exemplo,

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

// obtém o tamanho da pilha int size = prime_nums.size;

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

  return 0;
}

Output

Size of the stack: 3

No exemplo acima, criamos uma pilha de inteiros chamada prime_nums e adicionamos três elementos a ela.

Então nós usamos size para encontrar o número de elementos na pilha:

prime_nums.size;

Como adicionamos 3 elementos à pilha, prime_nums.size retorna 3.

Verifique se a pilha está vazia

Nós usamos empty para verificar se a pilha está vazia. Este método retorna:

  • 1(true)– se a pilha estiver vazia
  • 0(false)– se a pilha não estiver vazia

Por exemplo,

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

int main {

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

// verifica se a pilha está vazia 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? ";

// verifica se a pilha está vazia if (nums.empty) {

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

  return 0;
}

Output

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

No exemplo acima, usamos empty para determinar se stack está vazia,

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

Inicialmente, a pilha não possui elementos. Então nums.empty retorna true.

Em seguida, adicionamos elementos à pilha.

Novamente, usamos nums.empty para determinar se a pilha está vazia. Desta vez, ele retorna false.

Acima estão as informações sobre Como usar a pilha C++ Para saber mais sobre pilhas [Detailed Guide]. Se você tem alguma dúvida, por favor, pergunte fixsy.org em um comentário abaixo. Estou feliz em ajudá-lo.