1.1 O que é uma Pilha?

A pilha é uma estrutura de dados linear e restrita que opera sob o protocolo de acesso LIFO (Last-In, First-Out) — o último elemento a entrar na estrutura deve ser obrigatoriamente o primeiro a sair.

1.2 Analogias e Funcionamento

Pense em uma pilha de pratos: se você empilhar três pratos, o último colocado no topo é o primeiro a ser retirado para lavagem. No mundo do software, esse conceito é crucial e está presente em:

• Mecanismo de desfazer/refazer (Undo/Redo - Ctrl+Z): Cada modificação de estado é empilhada para que a última ação possa ser revertida rapidamente.
• Histórico do Navegador: O botão "voltar" nos leva para a última página acessada.
• Pilha de Execução de Funções (Call Stack): A JVM gerencia a execução de métodos em cada thread empilhando frames (quadros de pilha) que contêm variáveis locais e operandos.

Esquema das operações fundamentais: PUSH (Inserir) e POP (Remover) no Topo da Pilha

2.1 O Modelo de Armazenamento Estático

Implementar uma pilha utilizando vetores primitivos (arrays estáticos de tamanho fixo) nos dá total controle sobre o uso de recursos de hardware. Abaixo, analisamos as vantagens e desvantagens dessa escolha arquitetural:

3.1 O que é Overflow (Estouro)?

Em uma implementação de pilha com capacidade fixa, o erro de Overflow (Estouro) ocorre quando tentamos inserir um elemento e a pilha já está cheia.

3.2 O que é Underflow (Esvaziamento)?

O erro de Underflow ocorre no sentido oposto: quando tentamos remover (pop) ou consultar (top) dados em uma pilha que não possui nenhum elemento guardado (quando o índice topo == -1).

Dica de Projeto Defensivo

Sempre verifique as condições limites antes de alterar o índice do topo. Nunca permita que o índice topo ultrapasse as bordas -1 e tamanho - 1 do array.

Para operar uma pilha de maneira segura e encapsulada, definimos 5 métodos fundamentais que formam a sua interface pública:

Confira o código de referência estruturado com as validações adequadas para evitar problemas de Overflow e Underflow:

public class Pilha {
    private int topo;       // Controla o índice do elemento que está no topo
    private int[] itens;    // Vetor que armazena os elementos fisicamente

    // Construtor que inicializa a pilha com um tamanho estático
    public Pilha(int tamanho) {
        this.topo = -1;                 // -1 indica pilha vazia
        this.itens = new int[tamanho];  // Cria o array que armazenará os elementos
    }

    // Verifica se a pilha está vazia
    public boolean verificarPilhaVazia() {
        return this.topo == -1;
    }

    // Verifica se a pilha está cheia
    public boolean verificarPilhaCheia() {
        return this.topo == this.itens.length - 1;
    }

    // Adiciona um valor no topo (PUSH) com tratamento preventivo contra Overflow
    public void empilhar(int valor) {
        if (verificarPilhaCheia()) {
            System.out.println("[Erro] Overflow! A pilha está cheia. Não foi possível inserir " + valor);
            return;
        }
        this.topo++;
        this.itens[this.topo] = valor;
    }

    // Remove o elemento do topo (POP) com tratamento contra Underflow
    public void desempilhar() {
        if (verificarPilhaVazia()) {
            System.out.println("[Erro] Underflow! A pilha está vazia. Não é possível remover.");
            return;
        }
        this.topo--; // O decremento descarta logicamente o elemento
    }

    // Retorna o valor do topo (PEEK) sem removê-lo
    public int retornarTopo() {
        if (verificarPilhaVazia()) {
            throw new RuntimeException("A pilha está vazia. Não há elemento no topo.");
        }
        return this.itens[this.topo];
    }
}

public class AppInversor {
    public static void main(String[] args) {
        String textoOriginal = "ESTRUTURA DE DADOS";
        System.out.println("Original: " + textoOriginal);

        // Instanciamos uma pilha com capacidade suficiente
        Pilha pilhaLetras = new Pilha(textoOriginal.length());

        // Passo 1: Empilhar cada caractere
        for (int i = 0; i < textoOriginal.length(); i++) {
            char letra = textoOriginal.charAt(i);
            pilhaLetras.empilhar((int) letra); // Fazemos cast para int
        }

        // Passo 2: Desempilhar reconstruindo o texto invertido
        StringBuilder textoInvertido = new StringBuilder();
        while (!pilhaLetras.verificarPilhaVazia()) {
            char letraTopo = (char) pilhaLetras.retornarTopo();
            textoInvertido.append(letraTopo);
            pilhaLetras.desempilhar();
        }

        System.out.println("Invertido: " + textoInvertido.toString());
    }
}