Uma pilha (stack) é uma estrutura de dados do tipo LIFO (Last In, First Out), ou seja, o último elemento inserido é o primeiro a ser removido. Imagine uma pilha de pratos: você sempre coloca ou remove pratos do topo.

Operações Básicas

Uma pilha normalmente possui três operações principais:

Exemplo em Linguagem C

Exemplo da implementação de uma pilha com Vetores (Array).

#include <stdio.h>
#define MAX 5

typedef struct {
	int itens[MAX];
	int topo;
} Pilha;

// Funcao para inicializar a Pilha
void inicializar(Pilha *p) {

	// comeca no indice -1 pois sera incrementada pela funcao empilhar
	// antes de ocorrer o empilhamento
	p->topo = -1;
}

int estaCheia(Pilha *p) {
	return p->topo == MAX - 1;	 // MAX - 1 pois a pilha comeca no indice 0
}

int estaVazia(Pilha *p) {
	return p->topo == -1;
}

void empilhar(Pilha *p, int valor) {
	
	if (estaCheia(p)) {
		printf("Pilha cheia! \n");
		return;
	}
	
	p->topo++; // incremente o topo para nao sobreescrever o valor
	
	p->itens[p->topo] = valor; // No indice do topo adicione o valor
	
	printf("Empilhado: %d \n", valor);
}

void des_empilhar(Pilha *p) {
	
	if (estaVazia(p)) {
		printf("Pilha vazia! \n");
		return;
	}
	
	printf("Desmpilhado: %d \n", p->itens[p->topo]);
	
	//diminua 1 do topo para desonsiderar o ultimo valor da pilha e
	// sobreescreve-lo em um proximo empilhamento
	p->topo--; 
}

void mostrar(Pilha *p) {
	
	if (estaVazia(p)) {
		printf("Pilha vazia! \n");
		return;
	}
	
	printf("Itens na pilha:");
	int i;
	for(i= 0; i <= p->topo; i++) {
		printf("%d ", p->itens[i]);
	}
	printf("\n");
}

int main() {
	
	Pilha minhaPilha;
	
	inicializar(&minhaPilha);
	
	empilhar(&minhaPilha, 1);
	empilhar(&minhaPilha, 2);
	empilhar(&minhaPilha, 3);
	empilhar(&minhaPilha, 4);
	
	des_empilhar(&minhaPilha);
	des_empilhar(&minhaPilha);
	
	mostrar(&minhaPilha);
	
	return 0;
}

Saída

O resultado no prompt de comando do código de exemplo acima seria:

Empilhado: 1 
Empilhado: 2 
Empilhado: 3 
Empilhado: 4 
Desempilhado: 4 
Desempilhado: 3 
Itens na pilha: 1 2 

Exemplo em Java

public class Stack<K> {
    
    private class Node<K> {
        private K value;
        private Node<K> next;
    }

    private Node<K> top = null;

    public void push(K value) {
        Node<K> oldTop = top;

        Node<K> newNode = new Node<>();
        newNode.value = value;
        newNode.next = oldTop;

        top = newNode;
    }

    public K pop() {

        if (top == null) {
            return null;
        }

        K value = top.value;
        top = top.next;

        return value;
    }

    public K peek() {
        return top.value;
    }
}