You are on page 1of 17

Tipos abstratos de dados (TADs)

Um TAD uma Exemplo: TAD que modela


abstrao de uma um sistema de controle de
estrutura de dados estoque
Um TAD  Os dados so os pedidos de
especifica: compra/venda
 Dados  As operaes suportadas so:
armazenados  comprar(produto, preo)
 vender(produto, preo)
 Operaes sobre os
 cancelar(pedido)
dados
 Condies de erro:
 Condies de erros
 Comprar/vender um produto
associadas opers no existente
 Cancelar um pedido no
existente
O TAD Pilha
O TAD Pilha armazena Operaes auxiliares:
objetos arbitrrios  object top(): retorna o
Inseres e remoes ltimo elemento inserido
sem remov-lo
segue o esquema LIFO
 integer size(): retorna o
Exemplo: uma pilha de nmero de lementos
pratos armazenados
Principais operaes:  boolean isEmpty(): indica
se h ou no elementos
 push(object): insere um
na Pilha
elemento
 object pop(): remove e
returna o ltimo elemento
inserido
Excees
Ao executar uma No TAD Pilha, as
operao em um TAD, operaes pop e top
pode-se causar uma no podem ser
condio de erro, que realizadas se a pilha
chamamos exceo est vazia
Execes podem ser Executar pop ou top
levantadas (thrown) numa pilha vazia
por uma operao que causa a exceo
no pode execut-la EPilhaVazia
Aplicaes de pilhas
Aplicaes diretas
 Histrico de pginas visitadas num navegador
 Sequncia de desfazer em um editor de textos
 Cadeia de chamada de mtodos num programa
Aplicaes indiretas
 Estrutura de dados auxiliares para algoritmos
 Componentes de outras estruturas de dados
Pilhas baseadas em Arrays
Uma forma simples de Algoritmo size()
implementar uma retorne t + 1
pilha usa arrays
Adicionamos Algoritmo pop()
elementos da
esquerda para a Se (estaVazia())
direita throw EPilhaVazia
Uma varivel mantm seno
o ndice do elemento tt1
no topo da pilha retorne S[t + 1]


S
0 1 2 t
Pilhas baseadas em Arrays
O array pode ficar
cheio
Algoritmo push(o)
A operao push pode Se (t = S.length 1)
ento levantar a
throw EPilhaCheia
exceo EPilhaCheia
 Est uma limitao da
seno
implementgao tt+1
baseada em arrays S[t] o
 No intrnsico do TAD
Pilha


S
0 1 2 t
Desempenho e limitaes
Desempenho
 Seja n o nmero de elemento na pilha
 O espao usado O(n)
 Cada operao roda em tempo O(1)
Limitaes
 O tamanho mximo deve ser definido a priori e
no pode ser mudado
 Tentando colocar um novo elemento numa pilha
cheia causa uma exceo especfica da
implementao (array)
Alcance (span)
7
Veremos a apliao da Pilha 6
como estrutura de dados 5
auxiliar em um algoritmo
4
Dado um array X, o alcance
S[i] de X[i] o nmero 3
mximo de elementos 2
consecutivos X[j] 1
imediatamente precedendo 0
X[i] e X[j] X[i]
0 1 2 3 4
Alcances tm aplicaes em
anlise financeira
X 6 3 4 5 2
 Estoque em 52 semanas
S 1 1 2 3 1
Algoritmo quadrdico
Algoritmo alcance1(X, n)
Entrada array X de n inteiros
Sada array S dos alcances de X #
S novo array de n inteiros n
para i 0 at n 1 faa n
s1 n
enquanto ( s i X[i s] X[i]) 1 + 2 + + (n 1)
ss+1 1 + 2 + + (n 1)
S[i] s n
retorne S 1

Algoritmo alcance1 roda em tempo O(n2)


Alcances com Pilhas
Ns mantemos em uma
Pilha os ndices dos 7
elementos visveis quando 6
olhamos para trs 5
Ns percorremos o array 4
da esquerda para a direita 3
 Seja i o ndice atual
2
 Pega-se os ndices da pilha
at encontrar j tal que X[i] 1
< X[j] 0
 Realiza-se a atribuio
S[i] i j 0 1 2 3 4 5 6 7
 Coloca-se x na pilha
Algoritmo Linear
Algoritmo alcance2(X, n) #
Cada ndice do S novo array de n inteiros n
array A nova pilha vazia 1
 colocado na para i 0 at n 1 faa n
pilha exatamente enquanto (
uma vez A.estaVazia()
 retirado uma X[A. topo()] X[i] )
vez faa n
Comandos no j A.retirar() n
lao while so Se (A.estaVazia()) ento n
executados n S[i] i + 1 n
seno
vezes j A.topo(); n
Algoritmo S[i] i j n
alcence2 roda em A.colocar(i) n
tempo O(n) retorne S 1
Pilha crescente baseada em array
Em uma operao push(), Algoritmo colocar(o)
quando o array est cheio, Se (t = S.length1)
ao invs de levantar uma ento
exceo, substitumos o A novo array
array por um maior para i 0 at t faa
Qual o tamanho do array? A[i] S[i]
 Estratgia incremental: SA
aumentar o array usando tt+1
uma constante c S[t] o
 Estratgia de duplicao:
duplicar o tamanho do array
Comparao de estratgias
Comparamos a estratgia incremental e de
duplicao analisando o tempo total T(n)
necessrio para realizar uma srie de n
operaes push
Assumimos que comeamos com uma pilha
vazia representada por um array de tamanho 1
Chamamos tempo de amortizao de uma
operao push o tempo mdio de uma
operao sobre uma srie de operaes-T(n)/n
Anlise da estratgia incremental
Substitumos o array k = n/c vezes
O nmero toral T(n) de uma srie de n
operaes push proporcional a
n + c + 2c + 3c + 4c + + kc =
n + c(1 + 2 + 3 + + k) =
n + ck(k + 1)/2
Como c uma constante, T(n) O(n + k2), i.e.,
O(n2)
O tempo amortizado de uma operao push O(n)
Anlise da estratgia de duplicao
Substitumos o array k = log2 n
vezes
O tempo total T(n) de uma srie Srie geomtrica
n de operaes push 2
proporcional a 4
n + 1 + 2 + 4 + 8 + + 2k = 1 1
n + 2k + 1 2 = 3n 2
8
T(n) O(n)
O tempo amortizado de uma
operao push O(1)
A interface Pilha em JAVA
public interface Pilha {
Interface JAVA
correspondente ao public int size();
nosso TAD Pilha public boolean isEmpty();
Requer a definio
da classe public Object top()
throws EPilhaVazia;
EPilhaVazia
Diferente da classe public void push(Object o);
interna JAVA public Object pop()
java.util.Stack throws EPilhaVazia;
}
Pilha baseada em array - JAVA
public class PilhaArray public Object pop()
implements Pilha { throws EPilhaVazia {
// Armazena elementos da pilha if isEmpty()
private Object S[ ]; throw new EPilhaVazia
(Pilha vazia);
// ndice do elemento do topo Object temp = S[topo];
private int t = -1; // facilita coleta de lixo
// construtor S[topo] = null;
public PilhaArray(int tam) { t = t 1;
S = new Object[tam]); return temp;
} }