A pilha é uma estrutura de dados simples onde os elementos são inseridos e removidos sempre do topo. O documento descreve as operações básicas de empilhar (push) e desempilhar (pop) e apresenta implementações de pilhas usando vetores e listas encadeadas.

1. Prof. Adriano Teixeira de Souza

2.  É uma das estruturas de dados mais simples
 A idéia fundamental da pilha é que todo o acesso a
seus elementos é feito através do seu topo.
 Assim, quando um elemento novo é introduzido na
pilha, passa a ser o elemento do topo, e o único
elemento que pode ser removido da pilha é o do
topo.

3.  Verificação de parênteses.
 Retirada de vagões de um trem.
 Retirada de mercadorias em um caminhão de
entregas.

4.  Os elementos da pilha são retirados na ordem
inversa à ordem em que foram introduzidos:
o primeiro que sai é o último que entrou
(LIFO – last in, first out).
 Existem duas operações básicas que devem
ser implementadas numa estrutura de pilha:
◦ operação para empilhar (push) um novo elemento,
inserindo-o no topo,
◦ operação para desempilhar (pop) um elemento,
removendo-o do topo

5. push(b)
push(a)
b
a
topo
x
m
k

6. topo
b
topo
a a
topo
x x x
m m m
k push(a) k push(b) k

7. pop(b)
pop(a)
topo
b
a
x
m
k

8. topo
b
a topo
a
topo
x x x
m m m
k pop(b) k pop(a) k

9.  Supondo a pilha está armazenada em um
vetor pilha[0..n-1].
 A parte do vetor ocupada pela pilha será:
0 t n-1
pilha[0..n-1]

10. public class Pilha {
static final int MAX = 50;
int n;//Elementos adicionados
float vet[] = new float[MAX];
} Pilha;

11. Pilha cria()
{
Pilha p;
p = new Pilha();
p.n = 0;/*Inicializa com zero elementos*/
return p;
}
Prof. Adriano Teixeira de Souza

12. void push(Pilha p, float v)
{
if(p.n == Pilha.MAX){
System.out.println("Capacidade da pilha
estourou.");
System.exit(1); /*aborta programa*/
}
/* insere elemento na próxima posição livre */
p.vet[p.n] = v;
p.n++;
}

13. float pop(Pilha p)
{
float v;
if (vazia(p)) {
System.out.println("Pilha vazia.");
System.exit(1); /*aborta programa*/
}
/*retira elemento do topo*/
v = p.vet[p.n-1];
p.n--;
return v;
}

14. boolean vazia(Pilha p)
{
return (p.n == 0);
}

15. void imprime (Pilha p) {
int i;
for (i=p.n-1; i>=0; i--)
System.out.println(p.vet[i]);
}
Prof. Adriano Teixeira de Souza

16. public static void main(String[] args) {
ManipuladorPilha maninula = new ManipuladorPilha();
Pilha p = maninula.cria();
maninula.push(p,20.0f);
maninula.push(p,20.8f);
maninula.push(p,20.3f);
maninula.push(p,44.5f);
maninula.push(p,33.3f);
maninula.push(p,20.9f);
maninula.imprime (p);
System.out.println("Retirado: "+ maninula.pop(p));
System.out.println("Retirado: "+maninula.pop(p));
System.out.println("Configuracao da fila:");
maninula.imprime (p);
p = null;
}
Prof. Adriano Teixeira de Souza

17.  Quando o número máximo de elementos que
serão armazenados na pilha não é conhecido,
devemos implementar a pilha usando uma
estrutura de dados dinâmica, no caso,
empregando uma lista encadeada.
 Os elementos são armazenados na lista e a
pilha pode ser representada simplesmente por
um ponteiro para o primeiro nó da lista.

18. public class No {
float info;
No anterior;
}
public class Pilha {
No topo;
}

19.  Criar uma estrutura de pilha;
 Inserir um elemento no topo (push);
 Remover o elemento do topo (pop);
 Verificar se a pilha está vazia;
 Liberar a estrutura de pilha

20. Pilha cria()
{
Pilha p = new Pilha();
p.topo = null;
return p;
}

21. void push(Pilha p, float v)
{
No aux = new No();
aux.info = v;
aux.anterior = p.topo;
p.topo = aux;
}

22. float pop(Pilha p)
{
float v;
if (vazia(p))
{
System.out.println("Pilha vazia.");
System.exit(1); /*aborta o programa*/
}
v = p.topo.info;
No aux = p.topo;
p.topo = aux.anterior;
return v;
}

23. boolean vazia(Pilha p)
{
return (p.topo == null);
}

24. void imprime (Pilha p) {
for (No q=p.topo; q!=null; q=q.anterior)
System.out.println(q.info);
}
Prof. Adriano Teixeira de Souza

25. public static void main(String[] args) {
ManipulaPilha manipula = new ManipulaPilha();
Pilha p = manipula.cria();
manipula.push(p,20.0f);
manipula.push(p,20.8f);
manipula.push(p,20.3f);
manipula.push(p,44.5f);
manipula.push(p,33.3f);
manipula.push(p,20.9f);
manipula.imprime (p);
System.out.println("Retirado: "+ manipula.pop(p));
System.out.println("Retirado: "+ manipula.pop(p));
System.out.println("Configuracao da fila:n");
manipula.imprime (p);
p = null;
}
Prof. Adriano Teixeira de Souza

26.  Utilizando o algoritmo anteriormente
apresentado implemente um programa que
insira dados em uma pilha A e em seguida
remova-os elementos da pilha A e insira-os
na pilha B com sua ordem invertida.
Prof. Adriano Teixeira de Souza