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
implements Pilha {
// Armazena elementos da pilha
private Object S[ ];
// ndice do elemento do topo
private int t = -1;
// construtor
public PilhaArray(int tam) {
S = new Object[tam]);
} }
public Object pop()
throws EPilhaVazia {
if isEmpty()
throw new EPilhaVazia
(Pilha vazia);
Object temp = S[topo];
// facilita coleta de lixo
S[topo] = null;
t = t 1;
return temp;