Pilhas (Stack)

Na computação, pilhas (stacks) são estruturas de dados que seguem o princípio FILO (First In, Last Out), ou seja, o último elemento inserido é o primeiro a ser removido.

Elas funcionam como uma pilha de objetos físicos, como uma pilha de livros: você adiciona um livro sempre no topo e remove apenas do topo.

Terminologia Básica em Pilhas:

• Push (Empilhar): Insere um elemento no topo.

• Pop (Desempilhar): Remove o elemento do topo.

• Peek (ou Top): Consulta o elemento do topo sem removê-lo.

• Overflow (Estouros): Condição que ocorre ao tentar inserir elementos em uma pilha cheia (caso implementada com limitação de tamanho).

• Underflow: Condição que ocorre ao tentar remover elementos de uma pilha já vazia.

Veja abaixo uma demonstração animada de como uma Pilha (estrutura de dados) funciona:

Estrutura de Pilha Implementada em Python

class Stack:
    def __init__(self):
        self.items = []

    def is_empty(self):
        return len(self.items) == 0

    def push(self, item):
        self.items.append(item)

    def pop(self):
        if self.is_empty():
            raise Exception("Underflow: Empty stack!")
        return self.items.pop()

    def peek(self):
        if self.is_empty():
            raise Exception("Empty Stack!")
        return self.items[-1]

    def size(self):
        return len(self.items)

Ao trabalhar com pilhas, é essencial considerar alguns cenários que podem causar problemas durante as operações. Se tentarmos remover um elemento de uma pilha vazia, ocorrerá um erro conhecido como underflow. Da mesma forma, ao utilizar um array de tamanho fixo como pilha, tentar adicionar um novo elemento quando ele já estiver cheio resultará em um erro de overflow.

Para evitar underflow, basta garantir que a pilha não esteja vazia antes de remover um item. Normalmente, um programa não tentaria acessar uma pilha sem elementos, mas caso precise lidar com essa situação, ele deve implementar um comportamento alternativo. O overflow, por outro lado, pode ser mais complicado, pois há casos em que o programa realmente precisa adicionar mais elementos, mesmo quando a pilha atinge seu limite.

Atualmente, muitas linguagens de programação oferecem estruturas de dados dinâmicas que podem funcionar como pilhas. Essas estruturas ajustam automaticamente o espaço disponível, eliminando a preocupação com o tamanho máximo. Além disso, inserções e remoções nessas estruturas geralmente possuem uma complexidade de tempo O(1) na média, garantindo eficiência no processamento.

No Python, por exemplo, as listas (list) podem ser usadas como pilhas, pois seu tamanho cresce dinamicamente conforme necessário. Já no Java, a ArrayList pode desempenhar esse papel de forma eficiente, sendo uma alternativa mais leve à classe Stack, que foi projetada para ambientes com sincronização e pode ter um desempenho inferior em alguns cenários.