Pilhas java

' $
ESTRUTURAS DE DADOS B´ASICAS EM
JAVA
Jos´e de Siqueira
UFMG - ICEx - DCC
1o
semestre de 2005
& %

' $
Estruturas de Dados Básicas em Java
O Tipo Abstrato de Dados Pilha
• O TAD pilha tem quase as mesmas opera¸cões
apresentadas anteriormente:
1. empilha(o): insere o objeto o no topo da
pilha.
Entrada: objeto. Sa´ıda: nenhuma.
2. desempilha(): retira o objeto no topo da
pilha e o roetorna; ocorre erro se a pilha
estiver vazia.
Entrada: nenhuma. Sa´ıda: objeto.
3. tamanho(): retorna o número de objetos na
pilha.
Entrada: nenhuma. Sa´ıda: inteiro.
4. vazia(): Retorna um booleano indicando se a
pilha está vazia.
Entrada: nenhuma. Sa´ıda: booleano.
5. topo(): Retorna o objeto no topo da pilha,
sem retirá-lo; ocorre um erro se a pilha estiver
vazia.
José de Siqueira 1
& %

' $
Uma interface para pilhas em Java
• Em Java, já existe a classe para o TAD pilha:
java.util.Stack.
• Os métodos dispon´ıveis nesta classe, entre outros,
são: push(obj), pop(), equivalentes a
empilha(o) e desempilha() e peek(), equivalente
a topo(), tamanho() e vazia().
• Os métodos pop() e peek() lan¸cam a exce¸cão
StackEmptyException se a pilha estiver vazia
quando eles são chamados.
• Apesar de já existir esta classe em Java, aqui
estamos interessados em aprender como projetar e
implementar uma pilha e uma fila em Java.
• A implementa¸cão de um TAD em Java envolve
dois passos:
1. a defini¸cão de uma API (Application
Programming Interface) que descreve os
nomes dos métodos que o TAD oferece, como
eles são declarados e como são usados.
2. uma ou mais implementa¸cões concretas dos
métodos descritos na interface (API)
associada com o TAD.
& %

' $
public interface Pilha {
/* retorna o número de itens na pilha */
public int tamanho();
/* retorna true se a pilha está vazia, false senão */
public boolean vazia();
/*retorna, sem removê-lo, o item do topo da pilha;
lan¸ca StackEmptyException se a pilha estiver vazia*/
public Object topo()
throws StackEmptyException;
/* insere um item, passado em parâmetro, no topo
da pilha */
public void empilha(Object element);
/* remove e retorna o item no topo da pilha; lan¸ca
StackEmptyException se a pilha estiver vazia*/
public Object desempilha()
throws StackEmptyException;
}
/* Exce¸cões lan¸cadas quando se tenta usar as opera¸cões
em uma pilha vazia são tratadas aqui*/
public class StackEmptyException extends
RuntimeException {
public StackEmptyException (String erro) {
super(erro);
}
}
& %

' $
Uma implementa¸cão baseada em vetores
• Nesta implementa¸cão baseada em vetores, como o
vetor é alocado estaticamente, ao tentar empilhar
um objeto em uma pilha cheia, devemos lan¸car
uma exce¸cão StackFullExcpetion.
• Esta exce¸cão não foi definida no TAD Pilha por
ser espec´ıfica desta implementa¸cão.
/* Implementa¸cão da interface Pilha usando um
vetor de tamanho fixo. Uma exce¸cão é lan¸cada ao
tentar empilhar um objeto em uma pilha cheia. */
public class PilhaComVetor implements Pilha
{
/* Tamanho máximo fixo do vetor usado como
pilha */
public static final int CapacidadeMax =
1000;
/* Capacidade da pilha */
private int Capacidade;
/* Vetor usado como pilha */
private Object P[ ];
/* ´ındice do elemento do topo da pilha */
private int topo = -1;
& %

' $
/* inicia a pilha para usar um vetor com tamanho
máximo CapacidadeMax */
public PilhaComVetor() {
this(CapacidadeMax);
}
/* inicia a pilha para um arranjo com o tamanho
fornecido; o parâmetro é o tamanho do vetor */
public PilhaComVetor(int tam) {
Capacidade = tam;
P = new Object[Capacidade];
}
public int tamanho() {
return(topo + 1);
}
public boolean vazia() {
return(topo < 0);
}
public void empilha(Object obj) throws
StackFullException {
if (tamanho() == Capacidade)
throw new StackFullException(‘‘Pilha
cheia!’’);
P[++topo] = obj;
}
& %

' $
public Object desempilha() throws
StackEmptyException {
Object elemento;
if (vazia())
throw new StackEmptyException(‘‘Pilha
vazia!’’);
elemento = P[topo];
P[topo] = null; // Libera P[topo] para a
// coleta de lixo
topo--;
return elemento;
}
}
• A pilha declarada acima é genérica, pois os
elementos são instâncias da classe Object de Java.
• Pode-se armazenar qualquer objeto na pilha, pois
todas as classes Java herdam da classe Object.
• Assim, podemos empilhar objetos das classes
Integer, Estudante ou até mesmo Planetas.
• No entanto, ao desempilhar, é preciso fazer uma
conversão para a classe espec´ıfica a que o objeto
realmente pertence, como mostra o trecho de
programa abaixo:
& %

' $
public static Integer[]
inverte(Integer[] a) {
PilhaComVetor P = new
PilhaComVetor(a.length);
Integer[] b = new Integer[a.length];
for (int i = 0; i < a.length; i++)
P.empilha(a[i]);
for (int i = 0; i < a.length; i++)
b[i] = (Integer) (P.desempilha());
return b;
}
O TAD fila em Java
• As opera¸cões do TAD fila são:
1. insere(o): insere o obejto o no fim da fila.
Entrada: objeto. Sa´ıda: nenhuma.
2. retira(o): retira e retorna o objeto do in´ıcio da
fila. Lan¸ca uma exce¸cão se a fila estiver vazia.
3. tamanho(): retorna o número de objetos na
fila.
Entrada: nenhuma. Sa´ıda: inteiro.
& %

' $
4. vazia(): retorna um booleano indicando se a
fila está vaiza ou não.
Entrada: nenhuma. Sa´ıda: booleano.
5. frente(): retorna o objeto no in´ıcio da fila,
sem retirá-lo.Lan¸ca uma exce¸cão se a fila
estiver vazia.
public interface Fila {
/* retorna o número de itens na fila */
prublic int tamanho();
/* retorna true se a fila estiver vazia, false senão */
public boolean vazia();
/* retorna o item à frente na fila; lan¸ca
QueueEmptyException se a fila estiver vazia */
public Object frente() throws
QueueEmptyException;
/* insere elemento no final da fila */
public void insere(Object item);
/* remove e retorna o item à frente da fila; lan¸ca
QueueEmptyException se a fila estiver vazia */
public Object retira() throws
& %

' $
Implementa¸cão de filas com arranjos
• Para implementar uma fila em um arranjo de
tamanho N, é melhor utilizar uma fila circular.
• Para isso, temos dois apontadores i e f que
indicam o in´ıcio e o fim da fila.
• A fila está vazia quando i = f e f indica a
próxima posi¸cão livre.
• Problema: O que acontece quando f = N? O
que fazer neste caso?
• A implementa¸cão da circularidade é simples se o
incremento for feito como (i + 1) mod N ou
(f + 1) mod N.
• Problema: como distinguir que a fila está cheia?
• Por exemplo, deixando sempre uma casa vazia
entre o fim e o in´ıcio.
• Ou inserindo, no máximo, N − 1 elementos.
& %

' $
Algoritmo tamanho();
retorna (N-i+f) mod N;
Algoritmo vazia();
retorna (i=f);
Algoritmo frente();
se vazia() ent~ao lan¸car uma
retorna F[i];
Algoritmo retira();
se vazia() ent~ao lan¸car uma
QueueEmptyException ;
aux ← F[i];
F[i] ← null;
i ← (i+1) mod N;
retorna aux;
Algoritmo insere(o);
se tamanho() = N - 1 ent~ao lan¸car uma
QueueFullException;
F[f] ← o;
f ← (f+1) mod N;
& %

' $
Listas encadeadas em Java
public class Nó {
// Variáveis de instância
private Object item;
private Nó prox;
// Construtores simples
public Nó() {
this(null,null);
}
public Nó(Object i, Nó n) {
item = i;
prox = n;
}
// Métodos de acesso
Object retItem() {
return item;
}
Nó retProx() {
return prox;
}
// Modificadores
void posItem(Object novoItem) {
item = novoItem;
}
void posProx(Nó novoNó) {
prox = novoNó;
}
}
& %

' $
Implementa¸cão de uma pilha com
listas encadeadas
public class PilhaEncadeada implements Pilha {
private Nó topo; // referência para o nó do
// topo
private int tam; // número de itens na pilha
public PilhaEncadeada() {
topo = null;
tam = 0;
}
public int tamanho() {
return tam;
}
public boolean vazia() {
return (topo == null);
}
public void empilha(Object item) {
Nó v = new Nó(); // cria um novo nó
v.posItem(item);
v.posProx(topo); // encadeia o novo nó
topo = v;
tam++;
}
& %

' $
public Object topo() throws
if (vazia())
está vazia.’’);
return topo.retItem();
}
public Object desempilha() throws
if (vazia())
está vazia.’’);
Object aux = topo.retItem();
topo = topo.retProx; // aponta para o
// próximo nó
tam--;
return aux;
}
}
& %

' $
Implementa¸cão de uma fila com
listas encadeadas
• Apresentamos apenas a implementa¸cão de dois
métodos principais.
• As declara¸cões de classe e os outros métodos para
a implementa¸cão de filas com listas encadeadas
são deixadas como exerc´ıcio.
public void insere(Object obj) {
Nó nó = new Nó();
nó.posItem(obj);
nó.posProx(null); // o nó inserido será o do
// final da lista
if (tam == 0) //inser¸c~ao em uma fila vazia
primeiro = nó
else
último.posProx(nó); // insere nó no final
// da fila
último = nó; // aponta para o nó inserido
tam++;
}
& %

' $
public Object retira() throws
QueueEmptyException {
Object obj;
if (tam == 0)
throw new QueueEmptyException
(‘‘Fila est´a vazia.);
obj = primeiro.retItem();
primeiro = primeiro.retProx();
tam--;
if (tam == 0)
´ultimo = null // a fila ficou
// vazia
return obj;
}
& %

Pilhas java

Mais conteúdo relacionado

Mais procurados (20)

Semelhante a Pilhas java (20)

Último (20)

Pilhas java