Pilha C# com exemplos Push e Pop

O que é pilha em C#?

A pilha é uma coleção de casos especiais que representa o conceito LIFO (último a entrar, primeiro a sair). Para entender primeiro o LIFO, vamos dar um exemplo. Imagine uma pilha de livros com cada livro colocado um em cima do outro.

O conceito de último a entrar, primeiro a sair, no caso de livros, significa que apenas o livro que está no topo pode ser removido da pilha de livros. Não é possível retirar um livro do meio, pois isso atrapalharia a configuração da pilha.

Daqui em C#, a pilha também funciona da mesma maneira. Os elementos são adicionados à pilha, um em cima do outro. O processo de adicionar um elemento à pilha é chamado de operação push. Para remover um elemento de uma pilha, você também pode remover o elemento mais alto da pilha. Esta operação é conhecida como pop.

Vejamos as operações disponíveis para a coleção Stack com mais detalhes.

Declaração da pilha

Uma pilha é criada com a ajuda do tipo Stack Data. A palavra-chave “novo” é usada para criar um objeto de uma pilha. O objeto é então atribuído à variável st.

Stack st = new Stack()

Adicionando elementos à pilha

O método push é usado para adicionar um elemento à pilha. A sintaxe geral da instrução é fornecida abaixo.

Stack.push(element)

Removendo elementos da pilha

O método pop é usado para remover um elemento da pilha. A operação pop retornará o elemento mais alto da pilha. A sintaxe geral da instrução é fornecida abaixo

 Stack.pop()

Contar

Esta propriedade é usada para obter o número de itens na pilha. Abaixo está a sintaxe geral desta instrução.

Stack.Count

contém

Este método é usado para verificar se um elemento está presente na pilha. Abaixo está a sintaxe geral desta instrução. A instrução retornará verdadeiro se o elemento existir, caso contrário, retornará o valor falso.

Stack.Contains(element)

Agora vamos ver isso funcionando no nível do código. Todo o código mencionado abaixo será escrito em nosso Aplicação da consola. O código será gravado em nosso arquivo Program.cs.

No programa abaixo, escreveremos o código para ver como podemos usar os métodos mencionados acima.

Exemplo 1: Método Stack.Push()

Neste exemplo, veremos

• Como uma pilha é criada.
• Como exibir os elementos da pilha e usar os métodos Count e Contain.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DemoApplication
{
 class Program
 {
  static void Main(string[] args)
  {
   Stack st = new Stack();
   st.Push(1);
   st.Push(2);
   st.Push(3);

   foreach (Object obj in st)
   {
    Console.WriteLine(obj);
   }
    Console.WriteLine(); Console.WriteLine();
    Console.WriteLine("The number of elements in the stack " +st.Count);
    Console.WriteLine("Does the stack contain the elements 3 "+st.Contains(3));
    Console.ReadKey();
  }
 }
}

Code Explicação:-

1. A primeira etapa é usada para declarar a pilha. Aqui estamos declarando “st” como uma variável para armazenar os elementos de nossa pilha.
2. A seguir, adicionamos 3 elementos à nossa pilha. Cada elemento é adicionado através do método Push.
3. Agora, como os elementos da pilha não podem ser acessados ​​através da posição do índice como o lista de matrizes, precisamos usar uma abordagem diferente para exibir os elementos da pilha. O Objeto (obj) é uma variável temporária, que é declarada para conter cada elemento da pilha. Em seguida, usamos a instrução foreach para percorrer cada elemento da pilha. Para cada elemento da pilha, o valor é atribuído à variável obj. Em seguida, usamos o comando Console.Writeline para exibir o valor no console.
4. Estamos usando a propriedade Count (st.contar) para obter o número de itens na pilha. Esta propriedade retornará um número. Em seguida, exibimos esse valor no console.
5. Em seguida, usamos o método Contains para ver se o valor 3 está presente em nossa pilha. Isso retornará um valor verdadeiro ou falso. Em seguida, exibimos esse valor de retorno no console.

Se o código acima for inserido corretamente e o programa for executado, a seguinte saída será exibida.

Saída:

Na saída, podemos ver que os elementos da pilha são exibidos. Além disso, o valor True é exibido para indicar que o valor 3 está definido na pilha.

Observação: você notou que o último elemento colocado na pilha é exibido primeiro. Este é o elemento mais alto da pilha. A contagem de elementos da pilha também é mostrada na saída.

Exemplo 2: Método Stack.Pop()

Agora vamos dar uma olhada na funcionalidade “remover”. Veremos o código necessário para remover o elemento superior da pilha.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DemoApplication
{
 class Program
 {
  static void Main(string[] args)
  {
   Stack st = new Stack();
   st.Push(1);
   st.Push(2);
   st.Push(3);
   
   st.Pop();

   foreach (Object obj in st)
   {
    Console.WriteLine(obj);
   }
    Console.ReadKey();
  }
 }
}

Code Explicação:-

1. Aqui apenas emitimos o método pop que é usado para remover um elemento da pilha.

Se o código acima for inserido corretamente e o programa for executado, a seguinte saída será exibida.

Saída:

Podemos ver que o elemento 3 foi removido da pilha.

Método Stack Peek() em C#

Os métodos Push e Pop funcionam com o elemento do topo da pilha, mas às vezes você só precisa observar o elemento do topo sem removê-lo. O método Peek faz exatamente isso. Ele retorna o valor mais alto da pilha, deixando a coleção inalterada, o que é útil quando você quer testar o próximo item antes de decidir removê-lo.

Passo 1) Crie uma pilha e adicione três elementos a ela, de forma que o valor 3 fique no topo.

Passo 2) Chame o método Peek para ler o elemento superior e, em seguida, verifique a propriedade Count para confirmar que nada foi removido.

using System;
using System.Collections;

namespace DemoApplication
{
 class Program
 {
  static void Main(string[] args)
  {
   Stack st = new Stack();
   st.Push(1);
   st.Push(2);
   st.Push(3);
   Console.WriteLine(st.Peek());
   Console.WriteLine(st.Count);
   Console.ReadKey();
  }
 }
}

Code Explicação:-

1. Uma pilha chamada st é declarada, e os valores 1, 2 e 3 são adicionados com o método Push, de modo que 3 se torna o elemento do topo.
2. O método Peek retorna o elemento do topo sem removê-lo, e a propriedade Count ainda reporta o número total de itens na pilha.

Quando o programa é executado, ele imprime o valor. 3 de Peek e depois a contagem 3, o que prova que o elemento permanece na pilha. Se a pilha estiver vazia, Peek lança uma exceção Invalid.OperationException, portanto, é seguro verificar Count antes de chamá-la.

Pilha Genérica em C#

Os exemplos acima usam a classe não genérica `Stack` do pacote `System.Collections`, que armazena cada elemento como um objeto. O código C# moderno geralmente prefere a classe genérica `Stack`. Classe do namespace System.Collections.Generic. Ela vincula a pilha a um único tipo declarado, de modo que o compilador verifica cada operação de Push e Pop, sem necessidade de conversão de tipo ou boxing.

Os principais benefícios do Stack genérico Estão listados abaixo.

• Segurança do tipo: O tipo é fixado na declaração, portanto, apenas valores desse tipo podem ser inseridos, e os erros são detectados em tempo de compilação.
• Proibido boxe: Tipos de valor como int são armazenados diretamente, o que evita o custo de boxing que a pilha não genérica paga.
• O texto do produto de limpeza diz: Pop e Peek retornam o tipo declarado diretamente, portanto você não precisa converter o resultado de volta de objeto.

using System;
using System.Collections.Generic;

namespace DemoApplication
{
 class Program
 {
  static void Main(string[] args)
  {
   Stack<string> st = new Stack<string>();
   st.Push("Java");
   st.Push("Python");
   Console.WriteLine(st.Pop());
   Console.ReadKey();
  }
 }
}

Neste exemplo, a pilha é declarada como Stack. , portanto, aceita apenas valores de string. O método Pop retorna uma string diretamente e imprime Python, o último valor inserido. Para qualquer novo projeto, a pilha genérica é a opção recomendada.

Diferença entre pilha e fila em C#

Uma pilha e um fila Ambas são coleções que controlam a ordem em que os elementos são removidos, mas usam regras opostas. Uma pilha segue a ordem de entrada (último a entrar, primeiro a sair), enquanto uma fila segue a ordem de entrada (primeiro a entrar, primeiro a sair). Escolher a correta torna a intenção do seu código clara para outros desenvolvedores.

As principais diferenças estão listadas abaixo:

• Ordem: Uma pilha remove primeiro o elemento adicionado mais recentemente (LIFO), enquanto uma fila remove primeiro o elemento mais antigo (FIFO).
• Métodos: Uma pilha usa Push e Pop, enquanto uma fila usa Enqueue para adicionar e Dequeue para remover.
• Acesso ao elemento principal: Uma pilha lê seu próximo item com Peek, e uma fila lê seu próximo item com Peek da frente para trás.
• Usos típicos: Pilhas suportam recursos de desfazer, avaliação de expressões e recursão. tracrei, enquanto filas se encaixam em agendamento, buffer e busca em largura.

Ambos os tipos estão disponíveis em formato genérico como Pilha e fila em System.Collections.Generic, portanto, você obtém segurança de tipo com qualquer uma das opções.

Perguntas Frequentes