Pilhas

/**
 * Pilha Sequencial (baseada em um vetor) de números inteiros com capacidade
 * fixa.
 *
 * A pilha segue a política LIFO (Last-In, First-Out), onde o último
 * elemento a ser inserido é o primeiro a ser removido.
 */
public class PilhaSequencial {

    /**
     * Vetor interno para armazenar os elementos da pilha.
     */
    private final int[] vetor;

    /**
     * Indica a primeira posição livre no topo da pilha. Também representa a
     * quantidade de elementos na pilha.
     */
    private int topo;

    /**
     * Constrói uma nova pilha com a capacidade máxima especificada.
     *
     * @param capacidade O número máximo de elementos que a pilha pode conter.
     */
    public PilhaSequencial(int capacidade) {
        vetor = new int[capacidade];
        topo = 0;
    }

    /**
     * Adiciona (empilha) um elemento no topo da pilha.
     *
     * @param elemento O número inteiro a ser inserido.
     * @throws Exception se a pilha já estiver cheia.
     */
    public void empilhar(int elemento) throws Exception {
        if (topo == vetor.length) {
            throw new Exception("Erro ao empilhar, pilha cheia.");
        }

        vetor[topo] = elemento;
        topo++;
    }

    /**
     * Remove (desempilha) e retorna o elemento do topo da pilha.
     *
     * @return O elemento que foi removido.
     * @throws Exception se a pilha estiver vazia.
     */
    public int desempilhar() throws Exception {
        if (topo == 0) {
            throw new Exception("Erro ao desempilhar, pilha vazia.");
        }

        topo--; // Diminue antes de retornar para acessar a posição correta.
        return vetor[topo];
    }
}