3 – Pilhas

É uma estrutura de dados linear que possui uma ordem particular em que as operações são executadas. A ordem pode ser:

1. LIFO (Last In First Out)
2. FILO (First In Last Out)

Existem basicamente 3 operações que podem ser feitas em uma pilha:

1. Push – Adiciona um elemento à pilha
2. Pop – Remove um da pilha. A operação POP resulta em um erro de stack underflow caso a pilha esteja vazia.
3. Peek ou Top – Retorna o primeiro item da pilha, sem removê-lo

Exemplo:

Exemplo de implementação:

using System;
using System.Collections.Generic;

public class StackExample<T>
{
    private List<T> _stack;

    public StackExample()
    {
        _stack = new List<T>();
    }

    // Adiciona um item no topo da pilha
    public void Push(T item)
    {
        _stack.Add(item);
    }

    // Remove o item do topo da pilha e o retorna
    public T Pop()
    {
        if (_stack.Count == 0)
        {
            throw new InvalidOperationException("Stack underflow: Pilha vazia.");
        }

        // Pega o item no topo da pilha
        T topItem = _stack[_stack.Count - 1];

        // Remove o item no topo
        _stack.RemoveAt(_stack.Count - 1);

        return topItem;
    }

    // Retorna o item do topo sem removê-lo
    public T Peek()
    {
        if (_stack.Count == 0)
        {
            throw new InvalidOperationException("Stack underflow: Pilha vazia.");
        }

        return _stack[_stack.Count - 1];
    }

    // Retorna o número de itens na pilha
    public int Count()
    {
        return _stack.Count;
    }
}

class Program
{
    static void Main()
    {
        // Criando uma pilha de inteiros
        StackExample<int> stack = new StackExample<int>();

        // Adicionando itens à pilha
        stack.Push(10);
        stack.Push(20);
        stack.Push(30);

        Console.WriteLine("Top item (Peek): " + stack.Peek()); // Exibe 30

        // Removendo itens da pilha
        Console.WriteLine("Popped item: " + stack.Pop()); // Exibe 30
        Console.WriteLine("Popped item: " + stack.Pop()); // Exibe 20

        Console.WriteLine("Top item (Peek) now: " + stack.Peek()); // Exibe 10

        // Verificando o número de itens na pilha
        Console.WriteLine("Items left in the stack: " + stack.Count()); // Exibe 1

        // Remover o último item
        Console.WriteLine("Popped item: " + stack.Pop()); // Exibe 10

        // Tentando acessar um item em uma pilha vazia
        try
        {
            Console.WriteLine(stack.Pop()); // Isso lançará uma exceção
        }
        catch (InvalidOperationException e)
        {
            Console.WriteLine(e.Message); // Exibe "Stack underflow: Pilha vazia."
        }
    }
}

[]’s
Otávio

Item Anterior:

2 – Listas encadeadas

Próximo Item:

4 – Filas