Estrutura de dados em Java - Pilhas

Prof. Adriano Teixeira de Souza

 É 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.

 Verificação de parênteses.

 Retirada de vagões de um trem.

 Retirada de mercadorias em um caminhão de
entregas.

 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

push(b)
push(a)

b

a

topo
x

m

k

topo
b
topo
a a
topo
x x x

m m m

k push(a) k push(b) k

pop(b)
pop(a)

topo
b

a

x

m

k

topo
b

a topo
a
topo
x x x

m m m

k pop(b) k pop(a) k

 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]

public class Pilha {

static final int MAX = 50;

int n;//Elementos adicionados
float vet[] = new float[MAX];

} Pilha;

Pilha cria()
{
Pilha p;
p = new Pilha();
p.n = 0;/*Inicializa com zero elementos*/
return p;
}


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++;
}

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;
}

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

void imprime (Pilha p) {

int i;

for (i=p.n-1; i>=0; i--)
System.out.println(p.vet[i]);

}


public static void main(String[] args) {
ManipuladorPilha maninula = new ManipuladorPilha();

Pilha p = maninula.cria();
maninula.push(p,20.0f);
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;
}


 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.

public class No {

float info;
No anterior;
}

public class Pilha {
No topo;
}

 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

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

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

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;
}

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

void imprime (Pilha p) {

for (No q=p.topo; q!=null; q=q.anterior)
System.out.println(q.info);

}


public static void main(String[] args) {
ManipulaPilha manipula = new ManipulaPilha();
Pilha p = manipula.cria();
manipula.push(p,20.0f);
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;
}


 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.


Estrutura de dados em Java - Pilhas

Mais conteúdo relacionado

Mais procurados (20)

Destaque (16)

Semelhante a Estrutura de dados em Java - Pilhas (11)

Mais de Adriano Teixeira de Souza (17)

Último (11)

Estrutura de dados em Java - Pilhas