Escolar Documentos
Profissional Documentos
Cultura Documentos
Transparncias
Estruturas de dados
Estruturas de dados e algoritmos esto
intimamente ligados:
no se pode estudar estruturas de dados
sem considerar os algoritmos associados
a elas,
assim como a escolha dos algoritmos em
geral depende da representao e da
estrutura dos dados.
Para resolver um problema necessrio
escolher uma abstrao da realidade, em
geral mediante a definio de um conjunto de
dados que representa a situao real.
A seguir, deve ser escolhida a forma de
representar esses dados.
Programas
Programar basicamente estruturar dados e
construir algoritmos.
Programas so formulaes concretas de
algoritmos abstratos, baseados em
representaes e estruturas especficas de
dados.
Programas representam uma classe especial
de algoritmos capazes de serem seguidos por
computadores.
Um computador s capaz de seguir
programas em linguagem de mquina
(seqncia de instrues obscuras e
desconfortveis).
necessrio construir linguagens mais
adequadas, que facilitem a tarefa de
programar um computador.
Uma linguagem de programao uma
tcnica de notao para programar, com a
inteno de servir de veculo tanto para a
expresso do raciocnio algortmico quanto
para a execuo automtica de um algoritmo
por um computador.
Tipos de Dados
Caracteriza o conjunto de valores a que uma
constante pertence, ou que podem ser
assumidos por uma varivel ou expresso, ou
que podem ser gerados por uma funo.
Tipos simples de dados so grupos de
valores indivisveis (como os tipos bsicos int,
boolean, char e float de Java).
Exemplo: uma varivel do tipo boolean
pode assumir o valor verdadeiro ou o valor
falso, e nenhum outro valor.
Os tipos estruturados em geral definem uma
coleo de valores simples, ou um agregado
de valores de tipos diferentes.
Implementao de TADs
Considere uma aplicao que utilize uma lista
de inteiros. Poderamos definir TAD Lista,
com as seguintes operaes:
1. faa a lista vazia;
2. obtenha o primeiro elemento da lista; se a lista
estiver vazia, ento retorne nulo;
3. insira um elemento na lista.
Custo de um Algoritmo
Determinando o menor custo possvel para
resolver problemas de uma dada classe,
temos a medida da dificuldade inerente para
resolver o problema.
Quando o custo de um algoritmo igual ao
menor custo possvel, o algoritmo timo
para a medida de custo considerada.
Podem existir vrios algoritmos para resolver
o mesmo problema.
Se a mesma medida de custo aplicada a
diferentes algoritmos, ento possvel
compar-los e escolher o mais adequado.
10
11
12
Funo de Complexidade
Para medir o custo de execuo de um
algoritmo comum definir uma funo de
custo ou funo de complexidade f .
f (n) a medida do tempo necessrio para
executar um algoritmo para um problema de
tamanho n.
Funo de complexidade de tempo: f (n)
mede o tempo necessrio para executar um
algoritmo em um problema de tamanho n.
Funo de complexidade de espao: f (n)
mede a memria necessria para executar
um algoritmo em um problema de tamanho n.
Utilizaremos f para denotar uma funo de
complexidade de tempo daqui para a frente.
A complexidade de tempo na realidade no
representa tempo diretamente, mas o nmero
de vezes que determinada operao
considerada relevante executada.
13
14
15
16
17
18
19
1
n
n(n+1)
2
n+1
20
21
22
n1
2
3n
2
32 , para n > 0.
23
Contm o mximo
Contm o mnimo
24
25
26
Os trs
algoritmos
Melhor caso
Pior caso
Caso mdio
MaxMin1
2(n 1)
2(n 1)
2(n 1)
MaxMin2
n1
2(n 1)
3n/2 3/2
MaxMin3
3n/2 2
3n/2 2
3n/2 2
27
28
29
30
Comportamento Assinttico de
Funes
O parmetro n fornece uma medida da
dificuldade para se resolver o problema.
Para valores suficientemente pequenos de n,
qualquer algoritmo custa pouco para ser
executado, mesmo os ineficientes.
A escolha do algoritmo no um problema
crtico para problemas de tamanho pequeno.
Logo, a anlise de algoritmos realizada para
valores grandes de n.
Estuda-se o comportamento assinttico das
funes de custo (comportamento de suas
funes de custo para valores grandes de n)
O comportamento assinttico de f (n)
representa o limite do comportamento do
custo quando n cresce.
31
32
Dominao assinttica
A anlise de um algoritmo geralmente conta
com apenas algumas operaes elementares.
A medida de custo ou medida de
complexidade relata o crescimento assinttico
da operao considerada.
Definio: Uma funo f (n) domina
assintoticamente outra funo g(n) se
existem duas constantes positivas c e m tais
que, para n m, temos |g(n)| c |f (n)|.
f,g
c f (n)
g(n)
Exemplo:
Sejam g(n) = (n + 1)2 e f (n) = n2 .
As funes g(n) e f (n) dominam
assintoticamente uma a outra, desde que
|(n + 1)2 | 4|n2 | para n 1 e |n2 | |(n + 1)2 |
para n 0.
33
Notao O
Escrevemos g(n) = O(f (n)) para expressar
que f (n) domina assintoticamente g(n). L-se
g(n) da ordem no mximo f (n).
Exemplo: quando dizemos que o tempo de
execuo T (n) de um programa O(n2 ),
significa que existem constantes c e m tais
que, para valores de n m, T (n) cn2 .
Exemplo grfico de dominao assinttica
que ilustra a notao O.
f,g
c f (n)
g(n)
Exemplos de Notao O
Exemplo: g(n) = (n + 1)2 .
34
Exemplos de Notao O
Exemplo: g(n) = 3n3 + 2n2 + n O(n3 ).
35
36
c = constante
37
Notao
Especifica um limite inferior para g(n).
Definio: Uma funo g(n) (f (n)) se
existirem duas constantes c e m tais que
g(n) cf (n), para todo n m.
Exemplo: Para mostrar que g(n) = 3n3 + 2n2
(n3 ) basta fazer c = 1, e ento
3n3 + 2n2 n3 para n 0.
Exemplo: Seja g(n) = n para n mpar (n 1)
e g(n) = n2 /10 para n par (n 0).
Neste caso g(n) (n2 ), bastando
considerar c = 1/10 e n = 0, 2, 4, 6, . . .
g(n)
c f (n)
38
Notao
Definio: Uma funo g(n) (f (n)) se
existirem constantes positivas c1 , c2 e m tais
que 0 c1 f (n) g(n) c2 f (n), para todo
n m.
Exemplo grfico para a notao
f,g
c2 f ( n )
g(n)
c1 f ( n )
m
39
Exemplo de Notao
Seja g(n) = n2 /3 2n.
Vamos mostrar que g(n) = (n2 ).
Temos de obter constantes c1 , c2 e m tais que
c1 n2 31 n2 2n c2 n2 para todo n m.
Dividindo por n2 leva a c1
1
3
2
n
c2 .
40
Notao o
Usada para definir um limite superior que no
assintoticamente firme.
Definio: Uma funo g(n) o(f (n)) se,
para qualquer constante c > 0, ento
0 g(n) < cf (n) para todo n m.
Exemplo: 2n = o(n2 ), mas 2n2 6= o(n2 ).
Em g(n) = O(f (n)), a expresso
0 g(n) cf (n) vlida para alguma
constante c > 0, mas em g(n) = o(f (n)), a
expresso 0 g(n) < cf (n) vlida para
todas as constantes c > 0.
Na notao o, a funo g(n) tem um
crescimento muito menor que f (n) quando n
tende para infinito.
Alguns autores usam limn
definio da notao o.
g(n)
f (n)
= 0 para a
41
Notao
Por analogia, a notao est relacionada
com a notao da mesma forma que a
notao o est relacionada com a notao O.
Definio: Uma funo g(n) (f (n)) se,
para qualquer constante c > 0, ento
0 cf (n) < g(n) para todo n m.
Exemplo:
n2
2
= (n), mas
n2
2
6= (n2 ).
Classes de Comportamento
Assinttico
Se f uma funo de complexidade para
um algoritmo F , ento O(f ) considerada a
complexidade assinttica ou o
comportamento assinttico do algoritmo F .
A relao de dominao assinttica permite
comparar funes de complexidade.
Entretanto, se as funes f e g dominam
assintoticamente uma a outra, ento os
algoritmos associados so equivalentes.
Nestes casos, o comportamento assinttico
no serve para comparar os algoritmos.
Por exemplo, considere dois algoritmos F e G
aplicados mesma classe de problemas,
sendo que F leva trs vezes o tempo de G ao
serem executados, isto , f (n) = 3g(n), sendo
que O(f (n)) = O(g(n)).
Logo, o comportamento assinttico no serve
para comparar os algoritmos F e G, porque
eles diferem apenas por uma constante.
42
Comparao de Programas
Podemos avaliar programas comparando as
funes de complexidade, negligenciando as
constantes de proporcionalidade.
Um programa com tempo de execuo O(n)
melhor que outro com tempo O(n2 ).
Porm, as constantes de proporcionalidade
podem alterar esta considerao.
Exemplo: um programa leva 100n unidades
de tempo para ser executado e outro leva 2n2 .
Qual dos dois programas melhor?
depende do tamanho do problema.
Para n < 50, o programa com tempo 2n2
melhor do que o que possi tempo 100n.
Para problemas com entrada de dados
pequena prefervel usar o programa cujo
tempo de execuo O(n2 ).
Entretanto, quando n cresce, o programa
com tempo de execuo O(n2 ) leva muito
mais tempo que o programa O(n).
43
44
45
f (n) = O(n3 ).
46
f (n) = O(n!).
47
48
Comparao de Funes de
Complexidade
Funo
Tamanho n
de custo
10
20
30
40
50
60
0,00001
s
0,00002
s
0,00003
s
0,00004
s
0,00005
s
0,00006
s
n2
0,0001
s
0,0004
s
0,0009
s
0,0016
s
0,0.35
s
0,0036
s
n3
0,001
s
0,008
s
0,027
s
0,64
s
0,125
s
0.316
s
n5
0,1
s
3,2
s
24,3
s
1,7
min
5,2
min
13
min
2n
0,001
s
1
s
17,9
min
12,7
dias
35,7
anos
366
sc.
3n
0,059
s
58
min
6,5
anos
3855
sc.
108
sc.
1013
sc.
Funo de
Computador
Computador
Computador
custo
atual
100 vezes
1.000 vezes
mais rpido
mais rpido
de tempo
n
t1
100 t1
1000 t1
n2
t2
10 t2
31, 6 t2
n3
t3
4, 6 t3
10 t3
2n
t4
t4 + 6, 6
t4 + 10
Algoritmos Polinomiais
Algoritmo exponencial no tempo de
execuo tem funo de complexidade
O(cn ), c > 1.
Algoritmo polinomial no tempo de execuo
tem funo de complexidade O(p(n)), onde
p(n) um polinmio.
A distino entre estes dois tipos de
algoritmos torna-se significativa quando o
tamanho do problema a ser resolvido cresce.
Por isso, os algoritmos polinomiais so muito
mais teis na prtica do que os exponenciais.
Algoritmos exponenciais so geralmente
simples variaes de pesquisa exaustiva.
Algoritmos polinomiais so geralmente
obtidos mediante entendimento mais
profundo da estrutura do problema.
Um problema considerado:
49
50
51
5 c3
c2
8
3
c4
52
53
54
Procedimento no Recursivo
Algoritmo para ordenar os n elementos de um
conjunto A em ordem ascendente.
package cap1;
public class Ordenacao {
public static void ordena ( int v [ ] , int n) {
(1) for ( int i = 0; i < n 1; i ++) {
(2)
int min = i ;
(3)
(4)
i f ( v [ j ] < v [min] )
(5)
min = j ;
/ Troca v[min] e v[i] /
(6)
int x = v [min ] ;
(7)
v [min] = v [ i ] ;
(8)
v[ i ] = x;
}
}
}
55
Anlise do Procedimento no
Recursivo
Anel Interno
Contm um comando de deciso, com um
comando apenas de atribuio. Ambos levam
tempo constante para serem executados.
Quanto ao corpo do comando de deciso,
devemos considerar o pior caso, assumindo
que serSS sempre executado.
O tempo para incrementar o ndice do anel e
avaliar sua condio de terminao O(1).
O tempo combinado para executar uma vez o
anel O(max(1, 1, 1)) = O(1), conforme regra
da soma para a notao O.
Como o nmero de iteraes n i, o tempo
gasto no anel O((n i) 1) = O(n i),
conforme regra do produto para a notao O.
56
Anlise do Procedimento no
Recursivo
Anel Externo
Contm, alm do anel interno, quatro
comandos de atribuio.
O(max(1, (n i), 1, 1, 1)) = O(n i).
A linha (1) executada n 1 vezes, e o
tempo total para executar o programa est
limitado ao produto de uma constante pelo
somatrio de (n i):
Pn1
n(n1)
n2
n
2
=
=
O(n
)
(n
i)
=
1
2
2
2
Considerarmos o nmero de comparaes
como a medida de custo relevante, o
programa faz (n2 )/2 n/2 comparaes para
ordenar n elementos.
Considerarmos o nmero de trocas, o
programa realiza exatamente n 1 trocas.
57
58
Procedimento Recursivo
void pesquisa(n) {
(1)
i f (n <= 1)
(2)
(3)
(4)
pesquisa(n/ 3 ) ;
}
}
59
60
61
i
i=0 (1/3)
=n
1
1 31
3n
+1=
3n
2
12
62
63
Principais Componentes de um
Programa Java
Em Java, as funes e os procedimentos so
chamados de mtodos.
Um objeto contm mtodos e variveis que
representam seus campos de dados
(atributos).
Ex: um objeto painelDeControle deveria
conter no somente os mtodos ligaForno
e desligaForno, mas tambm as variveis
temperaturaCorrente e
temperaturaDese-jada.
O conceito de objeto resolve bem os
problemas apontados anteriormente.
Os mtodos ligaForno e desligaForno
podem acessar as variveis
temperaturaCorrente e
temperaturaDesejada, mas elas ficam
escondidas de outros mtodos que no
fazem parte do objeto painelDeControle.
64
Principais Componentes de um
Programa Java
O conceito de classe nasceu da necessidade
de se criar diversos objetos de um mesmo
tipo.
Dizemos que um objeto pertence a uma
classe ou, mais comumente, que uma
instncia
package cap1;
class PainelDeControle {
private float temperaturaCorrente ;
private float temperaturaDesejada;
public void ligaForno ( ) {
/ / cdigo do mtodo
}
public void desligaForno ( ) {
/ / cdigo do mtodo
}
}
65
Principais Componentes de um
Programa Java
Um objeto em Java criado usando a palavra
chave new
necessrio armazenar uma referncia para
ele em uma varivel do mesmo tipo da classe,
como abaixo:
PainelDeControle painel1, painel2;
Posteriormente, cria-se os objetos, como a
seguir:
painel1 = new PainelDeControle ();
painel2 = new PainelDeControle ();
Outras partes do programa interagem com os
mtodos dos objetos por meio do operador
(.), o qual associa um objeto com um de seus
mtodos, como a seguir:
painel1.ligaForno ();
66
Herana e Polimorfismo
Herana: criao de uma classe a partir de
uma outra classe.
A classe estendida a partir da classe base
usando a palavra chave extends.
A classe estendida (subclasse) tem todas as
caractersticas da classe base (superclasse)
mais alguma caracterstica adicional.
Polimorfismo: tratamento de objetos de
classes diferentes de uma mesma forma.
As classes diferentes devem ser derivadas da
mesma classe base.
67
68
Herana e Polimorfismo
package cap1;
class Empregado {
protected float salario ;
public float salarioMensal ( ) { return salario ; }
public void imprime ( ) { System. out . println ( "Empregado" ) ; }
}
class Secretaria extends Empregado {
private int velocidadeDeDigitacao ;
public void imprime ( ) { System. out . println ( "Secretaria" ) ; }
}
class Gerente extends Empregado {
private float bonus;
public float salarioMensal ( ) { return salario + bonus; }
public void imprime ( ) { System. out . println ( "Gerente" ) ; }
}
public class Polimorfismo {
public static void main ( String [ ] args ) {
Empregado empregado = new Empregado ( ) ;
Empregado secretaria = new Secretaria ( ) ;
Empregado gerente = new Gerente ( ) ;
empregado.imprime ( ) ; secretaria .imprime ( ) ;
gerente .imprime ( ) ;
}
}
69
70
Sobrecarga
A sobrecarga acontece quando determinado
objeto se comporta de diferentes formas.
um tipo de polimorfismo ad hoc, no qual um
identificador representa vrios mtodos com
computaes distintas.
public float salarioMensal ( float desconto ) {
}
71
Sobrescrita
A ocultao de um mtodo de uma classe
mais genrica em uma classe mais especfica
chamada de sobrescrita
Por exemplo, o mtodo imprime da classe
Empregado apresentada nas parte de
Herana e Polimorfismo, foi sobrescrito nas
classes Gerente e Secretaria.
Para sobrescrever um mtodo em uma
subclasse preciso que ele tenha a mesma
assinatura na superclasse.
72
Programa Principal
package cap1;
class ContaBancaria {
private double saldo ;
public ContaBancaria (double saldoInicial ) {
saldo = saldoInicial ;
}
public void deposito (double valor ) {
saldo = saldo + valor ;
}
public void saque (double valor ) {
}
73
Programa Principal
Programa anterior modela uma conta
bancria tpica com as operaes: cria uma
conta com um saldo inicial; imprime o saldo;
realiza um depsito; realiza um saque e
imprime o novo saldo;
A classe Contabancaria tem um campo de
dados chamado saldo e trs mtodos
chamados deposito, saque e imprime.
Para compilar o Programa acima a partir de
uma linha de comando em MS-DOS ou Linux,
fazemos:
javac -d ./ AplicacaoBancaria.java
e para execut-lo, fazemos:
java cap1 .AplicacaoBancaria
A classe ContaBancaria tem um mtodo
especial denominado construtor, que
chamado automaticamente sempre que um
novo objeto criado com o comando new e
tem sempre o mesmo nome da classe.
74
Modificadores de Acesso
Modificadores de acesso: determinam
quais outros mtodos podem acessar um
campo de dados ou um mtodo.
Um campo de dados ou um mtodo que seja
precedido pelo modificador private pode ser
acessado somente por mtodos que fazem
parte da mesma classe.
Um campo de dados ou um mtodo que seja
precedido pelo modificador public pode ser
acessado por mtodos de outras classes.
Classe modificada com o modificador
public indica que a classe visvel
externamente ao pacote em que ela foi
definida (classe AplicacaoBancaria,
package cap1).
Em cada arquivo de um programa Java s
pode existir uma classe modificada por
public, e o nome do arquivo deve ser o
mesmo dado classe.
Os campos de dados de uma classe so
geralmente feitos private e os mtodos so
tornados public.
75
Modificadores de Acesso
Modificador protected: utilizado para permitir
que somente subclasses de uma classe mais
genrica possam acessar os campos de
dados precedidos com protected.
Um campo de dados ou um mtodo de uma
classe declarado como static pertence
classe e no s suas instncias, ou seja,
somente um campo de dados ou um mtodo
ser criado pelo compilador para todas as
instncias.
Os mtodos de uma classe que foram
declarados static operam somente sobre os
campos da classe que tambm foram
declarados static.
Se alm de static o mtodo for declarado
public ser possvel acess-lo com o nome
da classe e o operador (.).
76
Modificadores de Acesso
package cap1;
class A {
public static int total ;
public int media;
}
public class B {
public static void main ( String [ ] args ) {
A a = new A( ) ; a. total = 5; a.media = 5;
A b = new A( ) ; b. total = 7; b.media = 7;
}
}
77
Interfaces
Uma interface em Java uma classe
abstrata que no pode ser instanciada, cujos
os mtodos devem ser public e somente suas
assinaturas so definidas
Uma interface sempre implementada por
outras classes.
Utilizada para prover a especificao de um
comportamento que seja comum a um
conjunto de objetos.
package cap1;
import java . io . ;
78
79
Interfaces
Para permitir a generalizao do tipo de
dados da chave necessrio criar a interface
Item que apresenta a assinatura do mtodo
abstrato compara.
package cap1;
public interface Item {
public int compara ( Item i t ) ;
}
80
Interfaces
package cap1;
public class EncontraMax {
public static void main ( String [ ] args ) {
MeuItem v [ ] = new MeuItem[ 2 ] ;
v[0] = new MeuItem ( 3 ) ; v[1] = new MeuItem (10);
MeuItem max = (MeuItem) Max.max ( v , 2 ) ;
System. out . println ( "Maior chave : " + max.chave) ;
}
}
Pacotes
A linguagem Java permite agrupar as classes
e as interfaces em pacotes(do ingls,
package.
Convenientes para organizar e separar as
classes de um conjunto de programas de
outras bibliotecas de classes, evitando
colises entre nomes de classes
desenvolvidas por uma equipe composta por
muitos programadores.
Deve ser realizada sempre na primeira linha
do arquivo fonte, da seguinte forma por
exemplo:
package cap1;
possvel definir subpacotes separados por
".", por exemplo, para definir o subpacote
arranjo do pacote cap3 fazemos:
package cap3.arranjo;
A utilizao de uma classe definida em outro
pacote realizada atravs da palavra chave
import. O comando abaixo possibilita a
utilizao de todas as classes de um pacote:
import cap3.arranjo.*;
81
Pacotes
possvel utilizar determinada classe de um
pacote sem import-la, para isso basta
prefixar o nome da classe com o nome do
pacote durante a declarao de uma varivel.
Exemplo:
cap3.arranjo.Lista lista;
Para que uma classe possa ser importada em
um pacote diferente do que ela foi definida
preciso declar-la como pblica por meio do
modificador public.
Se o comando package no colocado no
cdigo fonte, ento Java adiciona as classes
daquele cdigo fonte no que chamado de
pacote default
Quando o modificador de um campo ou
mtodo no estabelecido, diz-se que o
campo ou mtodo possui visibilidade default,
ou seja, qualquer objeto de uma classe do
pacote pode acessar diretamente aquele
campo (ou mtodo).
82
Classes Internas
Java permite realizar aninhamento de classes
como abaixo:
package cap1;
public class Lista {
/ / Cdigo da classe Lista
private class Celula {
/ / Cdigo da classe Celula
}
}
83
O Objeto this
Toda instncia de uma classe possui uma
varivel especial chamada this, que contm
uma referncia para a prpria instncia.
Em algumas situaes resolve questes de
ambigidade.
package cap1;
public class Conta {
private double saldo ;
public void alteraSaldo (double saldo ) {
this . saldo = saldo ;
}
}
84
85
Excees
As excees so erros ou anomalias que
podem ocorrer durante a execuo de um
programa.
Deve ser obrigatoriamente representada por
um objeto de uma subclasse da classe
Throwable, que possui duas subclasses
diretas: (i) Exception e (ii) Error
Uma abordagem simples para tratar uma
exceo exibir uma mensagem relatando o
erro ocorrido e retornar para quem chamou
ou finalizar o programa, como no exemplo
abaixo:
int divisao ( int a, int b) {
try {
i f (b == 0) throw new Exception ( "Divisao por zero" ) ;
return (a/b) ;
}
catch ( Exception objeto ) {
System. out . println ( "Erro : " + objeto .getMessage( ) ) ;
return ( 0 ) ;
}
}
Excees
O comando try trata uma exceo que tenha
sido disparada em seu interior por um
comando throw
O comando throw instancia o objeto que
representa a exceo e o envia para ser
capturado pelo trecho de cdigo que vai tratar
a exceo.
O comando catch captura a exceo e
fornece o tratamento adequado.
Uma abordagem mais elaborada para tratar
uma exceo separar o local onde a
exceo tratada do local onde ela ocorreu.
Importante pelo fato de que um trecho de
cdigo em um nvel mais alto pode possuir
mais informao para decidir como melhor
tratar a exceo.
86
87
Excees
No exemplo abaixo a exceo no tratada
no local onde ela ocorreu, e esse fato
explicitamente indicado pelo comando throws
int divisao ( int a, int b) throws {
i f (b == 0) throw new Exception ( "Divisao por zero" ) ;
return (a/b) ;
}
Sada de Dados
Os tipos primitivos e objetos do tipo String
podem ser impressos com os comandos
System.out.print (var);
System.out.println (var);
O mtodo print deixa o cursor na mesma
linha e o mtodo println move o cursor para a
prxima linha de sada.
88
89
Entrada de Dados
Todo programa em Java que tenha leitura de
dados tem de incluir o comando no incio do
programa
import java.io.*;
Mtodo para ler do teclado uma cadeia de
caracteres terminada com a tecla Enter:
public static String getString () throws
IOException {
InputStreamReader inputString = new
InputStreamReader (System.in);
BufferedReader buffer = new BufferedReader
(inputString);
String s = buffer.readLine (); return s;
}
Mtodo para realizar a entrada de um
caractere a partir do teclado:
public static char getChar () throws IOException {
String s = getString ();
return s.charAt (0);
}
Se o que est sendo lido de outro tipo,
ento necessrio realizar uma converso.
90
91
92
93
94
Paradigmas de Projeto
de Algoritmos
Transparncias
Induo Matemtica
til para provar asseres sobre a correo
e a eficincia de algoritmos.
Consiste em inferir uma lei geral a partir de
instncias particulares.
Seja T um teorema que que tenha como
parmetro um nmero natural n. Para provar
que T vlido para todos os valores de n,
basta provarmos que:
1. T vlido para n = 1;
2. Para todo n > 1, se T vlido para n 1,
ento T vlido para n.
A condio 1 chamada de passo base.
Provar a condio 2 geralmente mais fcil
que provar o teorema diretamente, uma vez
que podemos usar a assero de que T
vlido para n 1.
Esta afirmativa chamada de hiptese de
induo ou passo indutivo
As condies 1 e 2 implicam T vlido para
n = 2, o que junto com a condio 2 implica T
tambm vlido para n = 3, e assim por diante.
(hiptese de induo)
< (2n)2 ,
(hiptese de induo)
> c2n.
(def. da recorrncia)
Recursividade
Um mtodo que chama a si mesmo, direta ou
indiretamente, dito recursivo.
Recursividade permite descrever algoritmos
de forma mais clara e concisa, especialmente
problemas recursivos por natureza ou que
utilizam estruturas recursivas.
Ex.: rvore binria de pesquisa:
7
4
package cap2;
public class ArvoreBinaria {
private static class No {
Object reg ;
No esq, dir ;
}
private No raiz ;
}
Recursividade
Algoritmo para percorrer todos os registros
em ordem de caminhamento central:
1. caminha na subrvore esquerda na ordem
central;
2. visita a raiz;
3. caminha na subrvore direita na ordem
central.
No caminhamento central, os ns so
visitados em ordem lexicogrfica das chaves.
private void central (No p) {
i f (p ! = null ) {
central (p.esq) ;
System. out . println (p. reg . toString ( ) ) ;
central (p. dir ) ;
}
}
Implementao de Recursividade
Usa-se uma pilha para armazenar os dados
usados em cada chamada de um
procedimento que ainda no terminou.
Todos os dados no globais vo para a pilha,
registrando o estado corrente da computao.
Quando uma ativao anterior prossegue, os
dados da pilha so recuperados.
No caso do caminhamento central:
para cada chamada recursiva, o valor de p
e o endereo de retorno da chamada
recursiva so armazenados na pilha.
Quando encontra p=null o procedimento
retorna para quem chamou utilizando o
endereo de retorno que est no topo da
pilha.
10
Problema de Terminao em
Procedimentos Recursivos
Procedimentos recursivos introduzem a
possibilidade de iteraes que podem no
terminar: existe a necessidade de considerar
o problema de terminao.
fundamental que a chamada recursiva a um
procedimento P esteja sujeita a uma
condio B, a qual se torna no-satisfeita em
algum momento da computao.
Esquema para procedimentos recursivos:
composio C de comandos Si e P .
P if B then C[Si , P ]
Para demonstrar que uma repetio termina,
define-se uma funo f (x), sendo x o
conjunto de variveis do programa, tal que:
1. f (x) 0 implica na condio de
terminao;
2. f (x) decrementada a cada iterao.
11
Problema de Terminao em
Procedimentos Recursivos
Uma forma simples de garantir terminao
associar um parmetro n para P (no caso por
valor) e chamar P recursivamente com n 1.
A substituio da condio B por n > 0
garante terminao.
P if n > 0 then P[Si , P (n 1)]
necessrio mostrar que o nvel mais
profundo de recurso finito, e tambm
possa ser mantido pequeno, pois cada
ativao recursiva usa uma parcela de
memria para acomodar as variveis.
12
13
14
15
i = f i;
return f ;
}
}
10
20
30
50
100
fibRec
8 ms
1s
2 min
21 dias
109 anos
fibIter
1/6 ms
1/3 ms
1/2 ms
3/4 ms
1,5 ms
16
17
8
6
18
19
20
do {
k = k + 1; q = false ;
u = x + a[ k ] ; v = y + b[ k ] ;
/ Teste para verificar se os limites do tabuleiro
sero respeitados. /
anterior
}
else q = true ;
}
} while ( ! q && (k ! = 7 ) ) ; / / no h casas a visitar a partir de x,y
return q;
}
21
Diviso e Conquista
Consiste em dividir o problema em partes
menores, encontrar solues para as partes,
e combin-las em uma soluo global.
Exemplo: encontrar o maior e o menor
elemento de um vetor de inteiros, v [0..n 1],
n 1,. Algoritmo na prxima pgina.
Cada chamada de maxMin4 atribui
maxMin[0] e maxMin[1] o maior e o menor
elemento em v [linf ], v [linf + 1], . . . , v [lsup],
respectivamente.
22
23
Diviso e Conquista
package cap2;
public class MaxMin4 {
public static int [ ] maxMin4( int v [ ] , int l i n f , int lsup ) {
int maxMin[ ] = new int [ 2 ] ;
i f ( lsup l i n f <= 1) {
i f ( v [ l i n f ] < v [ lsup ] ) {
maxMin[0] = v [ lsup ] ; maxMin[1] = v [ l i n f ] ;
}
else {
maxMin[0] = v [ l i n f ] ; maxMin[1] = v [ lsup ] ;
}
}
else {
int meio = ( l i n f + lsup ) / 2 ;
maxMin = maxMin4 ( v , l i n f , meio) ;
int max1 = maxMin[ 0 ] , min1 = maxMin[ 1 ] ;
maxMin = maxMin4 ( v , meio + 1 , lsup ) ;
int max2 = maxMin[ 0 ] , min2 = maxMin[ 1 ] ;
i f (max1 > max2) maxMin[0] = max1;
else maxMin[0] = max2;
i f (min1 < min2) maxMin[1] = min1;
else maxMin[1] = min2;
}
return maxMin;
}
}
24
T (n) = 1,
4T (n/4) = 8T (n/8) + 2 2 2
..
..
.
.
2i2 T (n/2i2 ) = 2i1 T (n/2i1 ) + 2i1
Adicionando lado a lado, obtemos:
T (n) = 2i1 T (n/2i1 ) +
Pi1
k
2
=
k=1
3n
2
2.
25
26
27
28
Balanceamento
No projeto de algoritmos, importante
procurar sempre manter o balanceamento
na subdiviso de um problema em partes
menores.
Diviso e conquista no a nica tcnica em
que balanceamento til.
Vamos considerar um exemplo de ordenao
Seleciona o menor elemento do conjunto
v [0..n 1] e ento troca este elemento com o
primeiro elemento v [0].
Repete o processo com os n 1 elementos,
resultando no segundo maior elemento, o
qual trocado com o segundo elemento v [1].
Repetindo para n 2, n 3, . . ., 2 ordena a
seqncia.
29
30
T (n 1) = T (n 2) + n 2
..
..
.
.
T (2) = T (1) + 1
Adicionando lado a lado, obtemos:
T (n) = T (1) + 1 + 2 + + n 1 =
n(n1)
31
32
33
Anlise do Mergesort
Na contagem de comparaes, o
comportamento do Mergesort pode ser
representado por:
T (n) = 2T (n/2) + n 1, T (1) = 0
No caso da equao acima temos:
T (n) = 2T (n/2) + n 1
n
2T (n/2) = 22 T (n/22 ) + 2 2 1
2
..
..
.
.
i1
i1
i
i
i1 n
i1
2 T (n/2 ) = 2 T (n/2 ) + 2
2
2i1
Adicionando lado a lado:
T (n) = 2i T (n/2i ) +
i1
X
k=0
i1
X
2k
k=0
2i1+1 1
= in
21
= n log n n + 1.
Logo, o algoritmo O(n log n).
Para valores grandes de n, o balanceamento
levou a um resultado muito superior, samos
de O(n2 ) para O(n log n).
Programao Dinmica
Quando a soma dos tamanhos dos
subproblemas O(n) ento provvel que o
algoritmo recursivo tenha complexidade
polinomial.
Quando a diviso de um problema de
tamanho n resulta em n subproblemas de
tamanho n 1 ento provvel que o
algoritmo recursivo tenha complexidade
exponencial.
Nesse caso, a tcnica de programao
dinmica pode levar a um algoritmo mais
eficiente.
A programao dinmica calcula a soluo
para todos os subproblemas, partindo dos
subproblemas menores para os maiores,
armazenando os resultados em uma tabela.
A vantagem que uma vez que um
subproblema resolvido, a resposta
armazenada em uma tabela e nunca mais
recalculado.
34
35
36
0,
se i = j,
37
38
39
+ d[ i 1] d[ k ] d[ j ] ;
}
}
System. out . print ( " m[ " + i+" ] [ "+j+" ]= " + m[ i 1][ j 1]);
40
m22 = 0
m33 = 0
m12 = 10.000
m23 = 1.000
m34 = 5.000
m13 = 1.200
m24 = 3.000
m14 = 2.200
m44 = 0
41
42
No Aplicao do Princpio da
Otimalidade
No problema de encontrar o caminho mais
longo entre duas cidades:
Um caminho simples nunca visita uma
mesma cidade duas vezes.
Se o caminho mais longo entre Belo
Horizonte e Curitiba passa por Campinas,
isso no significa que o caminho possa ser
obtido tomando o caminho simples mais
longo entre Belo Horizonte e Campinas e
depois o caminho simples mais longo
entre Campinas e Curitiba.
Quando os dois caminhos simples so
ajuntados pouco provvel que o caminho
resultante tambm seja simples.
Logo, o princpio da otimalidade no se
aplica.
43
Algoritmos Gulosos
Resolve problemas de otimizao.
Exemplo: algoritmo para encontrar o caminho
mais curto entre dois vrtices de um grafo.
Escolhe a aresta que parece mais
promissora em qualquer instante;
Independente do que possa acontecer
mais tarde, nunca reconsidera a deciso.
No necessita avaliar alternativas, ou usar
procedimentos sofisticados para desfazer
decises tomadas previamente.
Problema geral: dado um conjunto C,
determine um subconjunto S C tal que:
S satisfaz uma dada propriedade P , e
S mnimo (ou mximo) em relao a
algum critrio .
O algoritmo guloso para resolver o problema
geral consiste em um processo iterativo em
que S construdo adicionando-se ao mesmo
elementos de C um a um.
44
45
46
C = C x;
i f ( vivel (S + x ) ) S = S + x ;
}
i f ( soluo (S) )
return S else return ( "No existe soluo" ) ;
}
Caractersticas da Implementao de
Algoritmos Gulosos
Quando funciona corretamente, a primeira
soluo encontrada sempre tima.
A funo de seleo geralmente
relacionada com a funo objetivo.
Se o objetivo :
maximizar provavelmente escolher o
candidato restante que proporcione o
maior ganho individual.
minimizar ento ser escolhido o
candidato restante de menor custo.
O algoritmo nunca muda de idia:
Uma vez que um candidato escolhido e
adicionado soluo ele l permanece
para sempre.
Uma vez que um candidato excludo do
conjunto soluo, ele nunca mais
reconsiderado.
47
Algoritmos Aproximados
Problemas que somente possuem algoritmos
exponenciais para resolv-los so
considerados difceis.
Problemas considerados intratveis ou
difceis so muito comuns.
Exemplo: problema do caixeiro viajante
cuja complexidade de tempo O(n!).
Diante de um problema difcil comum
remover a exigncia de que o algoritmo tenha
sempre que obter a soluo tima.
Neste caso procuramos por algoritmos
eficientes que no garantem obter a soluo
tima, mas uma que seja a mais prxima
possvel da soluo tima.
48
49
Estruturas de Dados
Bsicas
Transparncias
Listas Lineares
Uma das formas mais simples de interligar os
elementos de um conjunto.
Estrutura em que as operaes inserir, retirar
e localizar so definidas.
Podem crescer ou diminuir de tamanho
durante a execuo de um programa, de
acordo com a demanda.
Itens podem ser acessados, inseridos ou
retirados de uma lista.
Duas listas podem ser concatenadas para
formar uma lista nica, ou uma pode ser
partida em duas ou mais listas.
Adequadas quando no possvel prever a
demanda por memria, permitindo a
manipulao de quantidades imprevisveis de
dados, de formato tambm imprevisvel.
So teis em aplicaes tais como
manipulao simblica, gerncia de memria,
simulao e compiladores.
Itens
x1
x2
..
.
xn
..
.
10
x1
...
xn
nil
11
12
return item ;
13
return item ;
}
public Object primeiro ( ) {
this .pos = primeiro ; return proximo ( ) ; }
public Object proximo ( ) {
this .pos = this .pos. prox ;
i f ( this .pos == null ) return null ;
else return this .pos. item ;
}
public boolean vazia ( ) {
return ( this . primeiro == this . ultimo ) ; }
public void imprime ( ) {
Celula aux = this . primeiro . prox ;
while (aux ! = null ) {
System. out . println (aux. item . toString ( ) ) ;
aux = aux. prox ; }
}
}
14
/ / arranjo de 3 posies ;
15
16
17
...
7
8
9
10
...
Registro
Registro
nil
Registro
nil
18
Registro
Registro
Registro
...
...
...
19
20
package cap3;
import java . io . ;
import cap3. autoreferencia . Lista ; / / vide programa da transparncia 11
public class Vestibular {
private class Definicoes {
public static final int nOpcoes = 3;
public static final int nCursos = 7;
}
private static class Registro {
short chave ;
byte notaFinal ;
21
22
23
Pilha
uma lista linear em que todas as inseres,
retiradas e, geralmente, todos os acessos so
feitos em apenas um extremo da lista.
Os itens so colocados um sobre o outro. O
item inserido mais recentemente est no topo
e o inserido menos recentemente no fundo.
O modelo intuitivo o de um monte de pratos
em uma prateleira, sendo conveniente retirar
ou adicionar pratos na parte superior.
Esta imagem est freqentemente associada
com a teoria de autmato, na qual o topo de
uma pilha considerado como o receptculo
de uma cabea de leitura/gravao que pode
empilhar e desempilhar itens da pilha.
24
25
TAD Pilhas
Conjunto de operaes:
1. Cria uma pilha Vazia.
2. Verifica se a lista est vazia. Retorna true
se a pilha est vazia; caso contrrio,
retorna false.
3. Empilhar o item x no topo da pilha.
4. Desempilhar o item x no topo da pilha,
retirando-o da pilha.
5. Verificar o tamanho atual da pilha.
Existem vrias opes de estruturas de
dados que podem ser usadas para
representar pilhas.
As duas representaes mais utilizadas so
as implementaes por meio de arranjos e de
estruturas auto-referenciadas.
26
Itens
x1
x2
..
.
xn
..
.
27
topo ;
/ / Operaes
public Pilha ( int maxTam) { / / Cria uma Pilha vazia
this . item = new Object [maxTam] ; this . topo = 0;
}
public void empilha ( Object x ) throws Exception {
i f ( this . topo == this . item . length )
throw new Exception ( "Erro : A pilha esta cheia" ) ;
else this . item [ this . topo++] = x ;
}
/ / Continua na prxima transparncia
28
29
x1
6
..
.
6
xn1
6
topo
xn
30
tam;
/ / Operaes
public Pilha ( ) { / / Cria uma Pilha vazia
this . topo = null ; this .tam = 0;
}
/ / Continua na prxima transparncia
31
32
33
34
35
ET - Implementao
Este programa utiliza um tipo abstrato de
dados sem conhecer detalhes de sua
implementao.
A implementao do TAD Pilha que utiliza
arranjo pode ser substituda pela
implementao que utiliza estruturas
auto-referenciadas sem causar impacto no
programa.
package cap3;
import cap3. arranjo . Pilha ; / /
cia 11
public class ET {
private class Definicoes {
public static final int maxTam
= 70;
= \\ ;
= ;
= ~ ;
}
private static void imprime( Pilha pilha )throws Exception {
Pilha pilhaAux = new Pilha ( Definicoes .maxTam) ;
Character x ;
/ / Continua na prxima transparncia
36
ET - Implementao
while ( ! pilha . vazia ( ) ) {
x = (Character ) pilha .desempilha ( ) ;
pilhaAux .empilha ( x ) ;
}
while ( ! pilhaAux . vazia ( ) ) {
x = (Character ) pilhaAux .desempilha ( ) ;
System. out . print ( x ) ;
}
System. out . print ( \n ) ;
}
public static void main ( String [ ] args ) {
Pilha pilha = new Pilha ( Definicoes .maxTam) ;
try {
char c = (char) System. in .read ( ) ;
Character x = new Character ( c ) ;
i f ( x .charValue () == \n ) x =
new Character ( ) ;
while ( x .charValue ( ) ! = Definicoes .marcaEof) {
i f ( x .charValue () == Definicoes . cancelaCarater ) {
i f ( ! pilha . vazia ( ) ) x =
(Character ) pilha .desempilha ( ) ;
}
else i f ( x .charValue () == Definicoes . cancelaLinha)
pilha = new Pilha ( Definicoes .maxTam) ;
/ / Continua na prxima transparncia
37
ET - Implementao
else i f ( x .charValue () == Definicoes . saltaLinha )
imprime ( pilha ) ;
else {
i f ( pilha .tamanho () == Definicoes .maxTam)
imprime ( pilha ) ;
pilha .empilha ( x ) ;
}
c = (char) System. in .read ( ) ;
x = new Character ( c ) ;
i f ( x .charValue () == \n ) x = new Character ( ) ;
}
i f ( ! pilha . vazia ( ) ) imprime ( pilha ) ;
} catch ( Exception e) {
System. out . println (e.getMessage ( ) ) ; }
}
}
Filas
uma lista linear em que todas as inseres
so realizadas em um extremo da lista, e
todas as retiradas e, geralmente, os acessos
so realizados no outro extremo da lista.
O modelo intuitivo de uma fila o de uma fila
de espera em que as pessoas no incio da fila
so servidas primeiro e as pessoas que
chegam entram no fim da fila.
So chamadas listas fifo (first-in, first-out).
Existe uma ordem linear para filas que a
ordem de chegada.
So utilizadas quando desejamos processar
itens de acordo com a ordem
primeiro-que-chega, primeiro-atendido.
Sistemas operacionais utilizam filas para
regular a ordem na qual tarefas devem
receber processamento e recursos devem ser
alocados a processos.
38
TAD Filas
Conjunto de operaes:
1. Criar uma fila vazia.
2. Enfileirar o item x no final da fila.
3. Desenfileirar. Essa funo retorna o item x
no incio da fila e o retira da fila.
4. Verificar se a fila est vazia. Essa funo
retorna true se a fila est vazia; do
contrrio, retorna false.
39
1
2
Frente
...
3
4
Tras
5
7
40
1
2
Frente
...
3
4
Tras
5
7
41
frente , tras ;
42
43
44
x1
xn
frente
trs
- nil
45
46
Ordenao
Transparncias
elaboradas por Fabiano C. Botelho, Leonardo Rocha, Leonardo Mata e Nivio Ziviani
Ordenao
Introduo - Conceitos Bsicos
Ordenao Interna
Ordenao por Seleo
Ordenao por Insero
Shellsort
Quicksort
Heapsort
Ordenao Parcial
Seleo Parcial
Insero Parcial
Heapsort Parcial
Quicksort Parcial
Ordenao Externa
Intercalao Balanceada de Vrios
Caminhos
Implementao por meio de Seleo por
Substituio
Consideraes Prticas
Intercalao Polifsica
Quicksort Externo
Ordenao Interna
Na escolha de um algoritmo de ordenao
interna deve ser considerado o tempo gasto
pela ordenao.
Sendo n o nmero registros no arquivo, as
medidas de complexidade relevantes so:
Nmero de comparaes C(n) entre
chaves.
Nmero de movimentaes M (n) de itens
do arquivo.
O uso econmico da memria disponvel
um requisito primordial na ordenao interna.
Mtodos de ordenao in situ so os
preferidos.
Mtodos que utilizam listas encadeadas no
so muito utilizados.
Mtodos que fazem cpias dos itens a serem
ordenados possuem menor importncia.
10
Ordenao Interna
Classificao dos mtodos de ordenao
interna:
Mtodos simples:
Adequados para pequenos arquivos.
Requerem O(n2 ) comparaes.
Produzem programas pequenos.
Mtodos eficientes:
11
Ordenao Interna
A classe mostrada a seguir apresenta os
mtodos de ordenao interna que sero
estudados.
Utilizaremos um vetor v de registros do tipo
Item e uma varivel inteira n com o tamanho
de v .
O vetor contm registros nas posies de 1
at n, e a 0 utilizada para sentinelas.
package cap4. ordenacaointerna ;
import cap4. Item ;
/ / vide transparncia 6
12
13
Chaves iniciais:
i=1
i=2
i=3
i=4
i=5
14
Anlise
Comparaes entre chaves e movimentaes
de registros:
C(n) =
n2
2
n
2
M (n) = 3(n 1)
A atribuio min = j executada em mdia
n log n vezes, Knuth (1973).
15
16
Chaves iniciais:
i=2
i=3
i=4
i=5
i=6
17
18
19
: Ci (n) = i
caso medio
: Ci (n) = 1i (1 + 2 + + i) =
i+1
2
: C(n) = (2 + 3 + + n) =
: C(n) =
n
1
2
1
(3 + 4 +
2
n2
3n
+
1
4
4
n2
+
2
+ n + 1) =
20
: M (n) = (4 + 5 + + n + 2) =
: M (n) =
5n
n2
+
3
2
2
1
(5 + 6 +
2
n2
11n
+
3
4
4
+ n + 3) =
21
Shellsort
Proposto por Shell em 1959.
uma extenso do algoritmo de ordenao
por insero.
Problema com o algoritmo de ordenao por
insero:
Troca itens adjacentes para determinar o
ponto de insero.
So efetuadas n 1 comparaes e
movimentaes quando o menor item est
na posio mais direita no vetor.
O mtodo de Shell contorna este problema
permitindo trocas de registros distantes um
do outro.
22
23
Shellsort
Os itens separados de h posies so
rearranjados.
Todo h-simo item leva a uma seqncia
ordenada.
Tal seqncia dita estar h-ordenada.
Exemplo de utilizao:
1
Chaves iniciais:
h=4
h=2
h=1
24
Shellsort
Como escolher o valor de h:
Seqncia para h:
h(s) = 3h(s 1) + 1, para s > 1
h(s) = 1,
para s = 1.
Shellsort
public static void shellsort ( Item v [ ] , int n) {
int h = 1;
do h = h 3 + 1; while (h < n) ;
do {
h /= 3;
for ( int i = h + 1; i <= n ; i ++) {
Item x = v [ i ] ; int j = i ;
while ( v [ j h ] .compara ( x) > 0) {
v [ j ] = v [ j h ] ; j = h;
i f ( j <= h) break;
}
v[ j ] = x;
}
} while (h ! = 1 ) ;
}
25
Shellsort
Anlise
A razo da eficincia do algoritmo ainda no
conhecida.
Ningum ainda foi capaz de analisar o
algoritmo.
A sua anlise contm alguns problemas
matemticos muito difceis.
A comear pela prpria seqncia de
incrementos.
O que se sabe que cada incremento no
deve ser mltiplo do anterior.
Conjecturas referente ao nmero de
comparaes para a seqncia de Knuth:
Conjetura 1 : C(n) = O(n1,25 )
Conjetura 2 : C(n) = O(n(ln n)2 )
26
Shellsort
Vantagens:
Shellsort uma tima opo para arquivos
de tamanho moderado.
Sua implementao simples e requer
uma quantidade de cdigo pequena.
Desvantagens:
O tempo de execuo do algoritmo
sensvel ordem inicial do arquivo.
O mtodo no estvel,
27
Quicksort
Proposto por Hoare em 1960 e publiccado em
1962.
o algoritmo de ordenao interna mais
rpido que se conhece para uma ampla
variedade de situaes.
Provavelmente o mais utilizado.
A idia bsica dividir o problema de ordenar
um conjunto com n itens em dois problemas
menores.
Os problemas menores so ordenados
independentemente.
Os resultados so combinados para produzir
a soluo final.
28
Quicksort
A parte mais delicada do mtodo relativa ao
mtodo particao.
O vetor v [esq..dir ] rearranjado por meio da
escolha arbitrria de um piv x.
O vetor v particionado em duas partes:
A parte esquerda com chaves menores ou
iguais a x.
A parte direita com chaves maiores ou
iguais a x.
29
Quicksort
Algoritmo para o particionamento:
1. Escolha arbitrariamente um piv x.
2. Percorra o vetor a partir da esquerda at
que v [i] x.
3. Percorra o vetor a partir da direita at que
v [j] x.
4. Troque v [i] com v [j].
5. Continue este processo at os
apontadores i e j se cruzarem.
Ao final, o vetor v [esq..dir ] est particionado
de tal forma que:
Os itens em v [esq], v [esq + 1], . . . , v [j] so
menores ou iguais a x.
Os itens em v [i], v [i + 1], . . . , v [dir ] so
maiores ou iguais a x.
30
31
Quicksort
Ilustrao do processo de partio:
1
Quicksort
Mtodo Partio:
private static class LimiteParticoes { int i ; int j ; }
private static LimiteParticoes particao
(Item v [ ] , int esq, int dir ) {
LimiteParticoes p = new LimiteParticoes ( ) ;
p. i = esq ;
p. j = dir ;
32
33
Quicksort
Mtodo ordena e algoritmo Quicksort:
private static void ordena ( Item v [ ] , int esq, int dir ) {
LimiteParticoes p = particao ( v , esq, dir ) ;
i f (esq < p. j ) ordena ( v , esq, p. j ) ;
i f (p. i < dir ) ordena ( v , p. i , dir ) ;
}
public static void quicksort ( Item v [ ] , int n) {
ordena ( v , 1 , n) ;
}
34
Quicksort
Exemplo do estado do vetor em cada
chamada recursiva do procedimento Ordena:
Chaves iniciais:
D
E
3
4
5
A
Quicksort
Anlise
Seja C(n) a funo que conta o nmero de
comparaes.
Pior caso:
C(n) = O(n2 )
O pior caso ocorre quando, sistematicamente,
o piv escolhido como sendo um dos
extremos de um arquivo j ordenado.
Isto faz com que o procedimento Ordena seja
chamado recursivamente n vezes, eliminando
apenas um item em cada chamada.
O pior caso pode ser evitado empregando
pequenas modificaes no algoritmo.
Para isso basta escolher trs itens quaisquer
do vetor e usar a mediana dos trs como
piv.
35
Quicksort
Anlise
Melhor caso:
C(n) = 2C(n/2) + n = n log n n + 1
Esta situao ocorre quando cada partio
divide o arquivo em duas partes iguais.
Caso mdio de acordo com Sedgewick e
Flajolet (1996, p. 17):
C(n) 1, 386n log n 0, 846n,
Isso significa que em mdia o tempo de
execuo do Quicksort O(n log n).
36
Quicksort
Vantagens:
extremamente eficiente para ordenar
arquivos de dados.
Necessita de apenas uma pequena pilha
como memria auxiliar.
Requer cerca de n log n comparaes em
mdia para ordenar n itens.
Desvantagens:
Tem um pior caso O(n2 ) comparaes.
Sua implementao muito delicada e
difcil:
Um pequeno engano pode levar a
efeitos inesperados para algumas
entradas de dados.
O mtodo no estvel.
37
Heapsort
Possui o mesmo princpio de funcionamento
da ordenao por seleo.
Algoritmo:
1. Selecione o menor item do vetor.
2. Troque-o com o item da primeira posio
do vetor.
3. Repita estas operaes com os n 1 itens
restantes, depois com os n 2 itens, e
assim sucessivamente.
O custo para encontrar o menor (ou o maior)
item entre n itens n 1 comparaes.
Isso pode ser reduzido utilizando uma fila de
prioridades.
38
Heapsort
Filas de Prioridades
uma estrutura de dados onde a chave de
cada item reflete sua habilidade relativa de
abandonar o conjunto de itens rapidamente.
Aplicaes:
SOs usam filas de prioridades, nas quais
as chaves representam o tempo em que
eventos devem ocorrer.
Mtodos numricos iterativos so
baseados na seleo repetida de um item
com maior (menor) valor.
Sistemas de gerncia de memria usam a
tcnica de substituir a pgina menos
utilizada na memria principal por uma
nova pgina.
39
Heapsort
Filas de Prioridades - Tipo Abstrato de Dados
Operaes:
1. Constri uma fila de prioridades a partir de
um conjunto com n itens.
2. Informa qual o maior item do conjunto.
3. Retira o item com maior chave.
4. Insere um novo item.
5. Aumenta o valor da chave do item i para
um novo valor que maior que o valor
atual da chave.
6. Substitui o maior item por um novo item, a
no ser que o novo item seja maior.
7. Altera a prioridade de um item.
8. Remove um item qualquer.
9. Ajunta duas filas de prioridades em uma
nica.
40
Heapsort
Filas de Prioridades - Representao
Representao atravs de uma lista linear
ordenada:
Neste caso, Constri leva tempo
O(n log n).
Insere O(n).
Retira O(1).
Ajunta O(n).
Representao atravs de uma lista linear
no ordenada:
Neste caso, Constri tem custo linear.
Insere O(1).
Retira O(n).
Ajunta O(1) para apontadores e O(n)
para arranjos.
41
Heapsort
Filas de Prioridades - Representao
A melhor representao atravs de uma
estruturas de dados chamada heap:
Neste caso, Constri O(n).
Insere, Retira, Substitui e Altera so
O(log n).
Observao:
Para implementar a operao Ajunta de forma
eficiente e ainda preservar um custo
logartmico para as operaes Insere, Retira,
Substitui e Altera necessrio utilizar
estruturas de dados mais sofisticadas, tais
como rvores binomiais (Vuillemin, 1978).
42
Heapsort
Filas de Prioridades - Algoritmos de
Ordenao
As operaes das filas de prioridades podem
ser utilizadas para implementar algoritmos de
ordenao.
Basta utilizar repetidamente a operao
Insere para construir a fila de prioridades.
Em seguida, utilizar repetidamente a
operao Retira para receber os itens na
ordem reversa.
O uso de listas lineares no ordenadas
corresponde ao mtodo da seleo.
O uso de listas lineares ordenadas
corresponde ao mtodo da insero.
O uso de heaps corresponde ao mtodo
Heapsort.
43
44
Heapsort
Heaps
uma seqncia de itens com chaves
c[1], c[2], . . . , c[n], tal que:
c[i] c[2i],
c[i] c[2i + 1],
para todo i = 1, 2, . . . , n/2.
A definio pode ser facilmente visualizada
em uma rvore binria completa:
1
2 R
5 N
45
Heapsort
Heaps
As chaves na rvore satisfazem a condio
do heap.
As chaves em cada n s ao maiores do que
as chaves em seus filhos.
A chave no n raiz a maior chave do
conjunto.
Uma rvore binria completa pode ser
representada por um arranjo:
1
Heapsort
Heaps
Na representao do heap em um arranjo, a
maior chave est sempre na posio 1 do
vetor.
Os algoritmos para implementar as
operaes sobre o heap operam ao longo de
um dos caminhos da rvore.
Um algoritmo elegante para construir o heap
foi proposto por Floyd em 1964.
O algoritmo no necessita de nenhuma
memria auxiliar.
Dado um vetor v [1], v [2], . . . , v [n].
Os itens v [n/2 + 1], v [n/2 + 2], . . . , v [n]
formam um heap:
Neste intervalo no existem dois ndices i
e j tais que j = 2i ou j = 2i + 1.
46
Heapsort
Estrutura de dados fila de prioridades
implementada utilizando um heap
package cap4. ordenacaointerna ;
import cap4. Item ; / / vide transparncia 6
public class FPHeapMax {
private Item v [ ] ;
private int
n;
47
48
Heapsort
Heaps
Algoritmo:
1
Chaves iniciais:
Esq = 3
Esq = 2
Esq = 1
49
Heapsort
Heaps
O Programa que implementa a operao que
informa o item com maior chave:
public Item max ( ) {
return this . v [ 1 ] ;
}
Heapsort
Heaps
Mtodo para construir o heap:
/ / Usa o mtodo refaz da transparncia 49
public void constroi ( ) {
int esq = n / 2 + 1 ;
while (esq > 1) {
esq;
this . refaz (esq, this .n) ;
}
}
50
51
Heapsort
Heaps
Programa que implementa a operao de retirar o
item com maior chave:
/ / Usa o mtodo refaz da transparncia 49
public Item retiraMax ( ) throws Exception {
Item maximo;
i f ( this .n < 1) throw new Exception ( "Erro : heap vazio" ) ;
else {
maximo = this . v [ 1 ] ;
this . v[1] = this . v [ this .n];
refaz ( 1 , this .n) ;
}
return maximo;
}
52
Heapsort
Heaps
Programa que implementa a operao de
aumentar o valor da chave do item i:
public void aumentaChave ( int i , Object chaveNova)
throws Exception {
Item x = this . v [ i ] ;
i f (chaveNova == null )
throw new Exception ( "Erro : chaveNova com valor null " ) ;
x . alteraChave (chaveNova) ;
while ( ( i > 1) && (x .compara ( this . v [ i / 2 ] ) > = 0 ) ) {
this . v [ i ] = this . v [ i / 2 ] ; i /= 2;
}
this . v [ i ] = x ;
}
53
Heapsort
Heaps
Exemplo da operao de aumentar o valor da
chave do item na posio i:
(a)
(b)
i
E
(c)
i
A
(d)
U
U
i
U
Heapsort
Heaps
Programa que implementa a operao de inserir
um novo item no heap:
/ / Usa o mtodo aumentaChave da tranparncia 52
public void insere ( Item x ) throws Exception {
this .n++;
i f ( this .n == this . v . length ) throw new Exception
( "Erro : heap cheio" ) ;
Object chaveNova = x .recuperaChave ( ) ;
this . v [ this .n] = x ;
this . v [ this .n ] . alteraChave (new Integer
( Integer . MIN_VALUE ) ) ; / /
this .aumentaChave ( this .n, chaveNova) ;
}
54
Heapsort
Algoritmo:
1. Construir o heap.
2. Troque o item na posio 1 do vetor (raiz
do heap) com o item da posio n.
3. Use o procedimento Refaz para
reconstituir o heap para os itens v [1],
v [2], . . . , v [n 1].
4. Repita os passos 2 e 3 com os n 1 itens
restantes, depois com os n 2, at que
reste apenas um item.
55
56
Heapsort
Exemplo de aplicao do Heapsort:
1
Heapsort
Programa que mostra a implementao do
Heapsort para um conjunto de n itens
implementado como um vetor do tipo Item:
public static void heapsort ( Item v [ ] , int n) {
/ / Usa a classe FPHeapMax da transparncia 47
FPHeapMax fpHeap = new FPHeapMax ( v ) ;
int dir = n;
fpHeap. constroi ( ) ; / / constroi o heap
while ( dir > 1 ) { / / ordena o vetor
Item x = v [ 1 ] ;
v[1] = v [ dir ] ;
v [ dir ] = x ;
dir;
fpHeap. refaz ( 1 , dir ) ;
}
}
Anlise
O procedimento Refaz gasta cerca de log n
operaes, no pior caso.
Logo, Heapsort gasta um tempo de execuo
proporcional a n log n, no pior caso.
57
Heapsort
Vantagens:
O comportamento do Heapsort sempre
O(n log n), qualquer que seja a entrada.
Desvantagens:
O anel interno do algoritmo bastante
complexo se comparado com o do
Quicksort.
O Heapsort no estvel.
Recomendado:
Para aplicaes que no podem tolerar
eventualmente um caso desfavorvel.
No recomendado para arquivos com
poucos registros, por causa do tempo
necessrio para construir o heap.
58
59
O(n2 )
Seleo
O(n2 )
Shellsort
O(n log n)
Quicksort
O(n log n)
Heapsort
O(n log n)
60
5.000
10.000
30.000
Insero
11,3
87
161
Seleo
16,2
124
228
Shellsort
1,2
1,6
1,7
Quicksort
Heapsort
1,5
1,6
1,6
1,6
5.000
10.000
30.000
Insero
Seleo
128
1.524
3.066
Shellsort
3,9
6,8
7,3
8,1
Quicksort
4,1
6,3
6,8
7,1
Heapsort
12,2
20,8
22,4
24,6
61
5.000
10.000
30.000
Insero
40,3
305
575
Seleo
29,3
221
417
Shellsort
1,5
1,5
1,6
1,6
Quicksort
Heapsort
2,5
2,7
2,7
2,9
62
63
Quicksort
Heapsort
5.000
10.000
30.000
5.000
10.000
30.000
5.000
10.000
30.000
Asc
1,1
1,1
1,1
Des
1,5
1,6
1,5
1,1
1,1
1,1
Ale
2,9
3,1
3,7
1,9
2,0
2,0
1,1
64
65
66
67
68
69
70
Ordenao Parcial
Consiste em obter os k primeiros elementos
de um vetor ordenado com n elementos.
Quando k = 1, o problema se reduz a
encontrar o mnimo (ou o mximo) de um
conjunto de elementos.
Quando k = n camos no problema clssico
de ordenao.
71
Ordenao Parcial
Aplicaes:
Facilitar a busca de informao na Web com
as mquinas de busca:
comum uma consulta na Web retornar
centenas de milhares de documentos
relacionados com a consulta.
O usurio est interessado apenas nos k
documentos mais relevantes.
Em geral k menor do que 200
documentos.
Normalmente so consultados apenas os
dez primeiros.
Assim, so necessrios algoritmos
eficientes de ordenao parcial.
72
73
Ordenao Parcial
Algoritmos considerados:
Seleo parcial.
Insero parcial.
Heapsort parcial.
Quicksort parcial.
A classe OrdenacaoParcial mostrada a
seguir.
package cap4. ordenacaointerna ;
import cap4. Item ;
/ / vide transparncia 5
Seleo Parcial
Um dos algoritmos mais simples.
Princpio de funcionamento:
Selecione o menor item do vetor.
Troque-o com o item que est na primeira
posio do vetor.
Repita estas duas operaes com os itens
n 1, n 2 . . . n k.
74
75
Seleo Parcial
public static void selecaoParcial ( Item v [ ] , int n, int k) {
for ( int i = 1; i <= k ; i ++) {
int min = i ;
for ( int j = i + 1; j <= n ; j ++)
i f ( v [ j ] .compara ( v [min] ) < 0 ) min = j ;
Item x = v [min ] ; v [min] = v [ i ] ; v [ i ] = x ;
}
}
Anlise:
Comparaes entre chaves e movimentaes
de registros:
C(n) = kn
M (n) = 3k
k2
2
k
2
Seleo Parcial
muito simples de ser obtido a partir da
implementao do algoritmo de ordenao
por seleo.
Possui um comportamento espetacular
quanto ao nmero de movimentos de
registros:
Tempo de execuo linear no tamanho
de k.
76
Insero Parcial
Pode ser obtido a partir do algoritmo de
ordenao por Insero por meio de uma
modificao simples:
Tendo sido ordenados os primeiros k itens,
o item da k-sima posio funciona como
um piv.
Quando um item entre os restantes
menor do que o piv, ele inserido na
posio correta entre os k itens de acordo
com o algoritmo original.
77
78
Insero Parcial
public static void insercaoParcial ( Item v [ ] , int n, int k) {
int j ;
for ( int i = 2; i <= n ; i ++) {
Item x = v [ i ] ;
i f ( i > k ) j = k ; else j = i 1;
v[0] = x ; / / sentinela
while ( x .compara ( v [ j ] ) < 0 ) {
v [ j + 1] = v [ j ] ; j ;
}
v [ j + 1] = x ;
}
}
Obs:
1. A modificao realizada verifica o momento
em que i se torna maior do que k e ento
passa a considerar o valor de j igual a k a
partir deste ponto.
2. O algoritmo no preserva o restante do vetor.
79
Insero Parcial
Algoritmo de Insero Parcial que preserva o
restante do vetor:
public static void insercaoParcial2 ( Item v [ ] , int n, int k) {
int j ;
for ( int i = 2; i <= n ; i ++) {
Item x = v [ i ] ;
if ( i > k) {
j = k;
i f ( x .compara ( v [ k] ) < 0 ) v [ i ] = v [ k ] ;
}
else j = i 1;
v[0] = x ; / / sentinela
while ( x .compara ( v [ j ] ) < 0 ) {
i f ( j < k ) v [ j + 1] = v [ j ] ;
j ;
}
i f ( j < k ) v [ j + 1] = x ;
}
}
80
Insero Parcial
Anlise:
No anel mais interno, na i-sima iterao o
valor de Ci :
melhor caso
: Ci (n) = 1
pior caso
: Ci (n) = i
caso m
edio
: Ci (n) =
1
(1
i
+ 2 + + i) =
i+1
2
: C(n)
= (1 + 1 + + 1) = n 1
pior caso
: C(n)
= (2 + 3 + + k + (k + 1)(n k))
= kn + n
caso m
edio
: C(n)
=
=
1
(3 + 4
2
kn
+n
2
2
k2
2
k
2
+ + k + 1 + (k + 1)(n k))
k2
4
k
4
81
Insero Parcial
Anlise:
O nmero de movimentaes na i-sima
iterao :
Mi (n) = Ci (n) 1 + 3 = Ci (n) + 2
: M (n)
= (3 + 3 + + 3) = 3(n 1)
pior caso
: M (n)
= (4 + 5 + + k + 2 + (k + 1)(n k))
= kn + n
caso m
edio
: M (n)
=
=
1
(5 + 6
2
kn
+n
2
2
k2
2
3k
2
+ + k + 3 + (k + 1)(n k))
k2
4
5k
4
Heapsort Parcial
Utiliza um tipo abstrato de dados heap para
informar o menor item do conjunto.
Na primeira iterao, o menor item que est
em v [1]
(raiz do heap) trocado com o item que est
em v [n].
Em seguida o heap refeito.
Novamente, o menor est em A[1], troque-o
com A[n-1].
Repita as duas ltimas operaes at que o
k-simo menor seja trocado com v [n k].
Ao final, os k menores esto nas k ltimas
posies do vetor v .
82
83
Heapsort Parcial
public static void heapsortParcial ( Item v [ ] , int n, int k) {
/ / Coloca menor em v[n], segundo em v[n-1],...,k-esimo em v[n-k]
FPHeapMin fpHeap = new FPHeapMin ( v ) ;
int dir = n, aux = 0;
fpHeap. constroi ( ) ; / / constroi o heap
while (aux < k ) { / / ordena o vetor
Item x = v [ 1 ] ; v[1] = v [ dir ] ; v [ dir ] = x ;
dir ; aux++;
fpHeap. refaz ( 1 , dir ) ;
}
}
84
Heapsort Parcial
Anlise:
O Heapsort Parcial deve construir um heap a
um custo O(n).
O mtodo refaz tem custo O(log n).
O mtodo heapsortParcial chama o mtodo
refaz k vezes.
Logo, o algoritmo apresenta a complexidade:
O(n + k log n) =
O(n)
se k
n
log n
n
log n
Quicksort Parcial
Assim como o Quicksort, o Quicksort Parcial
o algoritmo de ordenao parcial mais
rpido em vrias situaes.
A alterao no algoritmo para que ele ordene
apenas os k primeiros itens dentre n itens
muito simples.
Basta abandonar a partio direita toda vez
que a partio esquerda contiver k ou mais
itens.
Assim, a nica alterao necessria no
Quicksort evitar a chamada recursiva
ordena(i, dir ).
85
86
Quicksort Parcial
Chaves iniciais:
D
E
3
4
5
A
87
Quicksort Parcial
private static void ordena(Item v [ ] , int esq, int dir , int k) {
LimiteParticoes p = particao ( v , esq, dir ) ;
i f (p. j esq >= k 1) {
i f (esq < p. j ) ordena ( v , esq, p. j , k ) ;
return ;
}
i f (esq < p. j ) ordena ( v , esq, p. j , k ) ;
i f (p. i < dir ) ordena ( v , p. i , dir , k ) ;
}
public static void quicksortParcial (Item v [ ] , int n, int k) {
ordena ( v , 1 , n, k ) ;
}
Quicksort Parcial
Anlise:
A anlise do Quicksort difcil.
O comportamento muito sensvel escolha
do piv.
Podendo cair no melhor caso O(k log k).
Ou em algum valor entre o melhor caso e
O(n log n).
88
89
Quicksort
Insero
Insero2
Heapsort
2,5
1,2
1,7
1,2
2,8
1,1
2,8
n, k
1
n : 10
n : 10
k : 10
k : 10
n : 102 k : 100
1,1
1,4
4,5
1,9
2,4
1,2
1,7
1,1
2,3
n : 103 k : 100
n : 10
n : 10
n : 10
n : 10
n : 10
n : 10
n : 10
n : 10
k : 10
k : 10
3,7
1,4
1,6
9,1
4,6
2,9
1,2
6,4
11,2
1,3
1,4
1,9
15,1
3,9
4,2
1,6
2,4
1,1
1,1
5,3
5,9
2,2
4,9
67
2,1
1,1
4,8
304
1,1
1,3
2,3
1445
33,1
43,3
1,7
1,9
k : 10
k : 10
k : 10
k : 10
k : 10
k : 10
n : 105 k : 103
5
n : 10
n : 10
k : 10
k : 10
n : 106 k : 100
6
n : 10
n : 10
n : 10
n : 10
n : 10
n : 10
3,9
1,2
1,3
8,1
6,6
2,7
7,3
83,1
3,2
1,1
6,6
k : 10
k : 10
690
2,2
1,1
5,7
6,4
1,9
1,7
1,8
k : 10
k : 10
k : 10
k : 10
n : 107 k : 100
7
n : 10
3,4
1,1
1,1
7,4
8,6
2,6
1,1
6,7
k : 10
82,1
2,6
1,1
6,8
3,1
1,1
6,6
1,1
1,2
2,6
2,2
1,2
n : 107 k : 107
1,7
n : 10
n : 10
n : 10
n : 10
n : 10
k : 10
k : 10
k : 10
k : 10
k : 10
90
Ordenao Externa
A ordenao externa consiste em ordenar
arquivos de tamanho maior que a memria
interna disponvel.
Os mtodos de ordenao externa so muito
diferentes dos de ordenao interna.
Na ordenao externa os algoritmos devem
diminuir o nmero de acesso as unidades de
memria externa.
Nas memrias externas, os dados so
armazenados como um arquivo seqencial.
Apenas um registro pode ser acessado em
um dado momento.
Esta uma restrio forte se comparada com
as possibilidades de acesso em um vetor.
Logo, os mtodos de ordenao interna so
inadequados para ordenao externa.
Tcnicas de ordenao completamente
diferentes devem ser utilizadas.
91
Ordenao Externa
Fatores que determinam as diferenas das
tcnicas de ordenao externa:
1. Custo para acessar um item algumas
ordens de grandeza maior.
2. O custo principal na ordenao externa
relacionado a transferncia de dados entre a
memria interna e externa.
3. Existem restries severas de acesso aos
dados.
4. O desenvolvimento de mtodos de ordenao
externa muito dependente do estado atual
da tecnologia.
5. A variedade de tipos de unidades de memria
externa torna os mtodos dependentes de
vrios parmetros.
6. Assim, apenas mtodos gerais sero
apresentados.
92
Ordenao Externa
O mtodo mais importante o de ordenao
por intercalao.
Intercalar significa combinar dois ou mais
blocos ordenados em um nico bloco
ordenado.
A intercalao utilizada como uma
operao auxiliar na ordenao.
Estratgia geral dos mtodos de ordenao
externa:
1. Quebre o arquivo em blocos do tamanho
da memria interna disponvel.
2. Ordene cada bloco na memria interna.
3. Intercale os blocos ordenados, fazendo
vrias passadas sobre o arquivo.
4. A cada passada so criados blocos
ordenados cada vez maiores, at que todo
o arquivo esteja ordenado.
93
Ordenao Externa
Os algoritmos para ordenao externa devem
reduzir o nmero de passadas sobre o
arquivo.
Uma boa medida de complexidade de um
algoritmo de ordenao por intercalao o
nmero de vezes que um item lido ou
escrito na memria auxiliar.
Os bons mtodos de ordenao geralmente
envolvem no total menos do que dez
passadas sobre o arquivo.
94
Objetivo:
Ordenar os 22 registros e coloc-los em
uma fita de sada.
Os registros so lidos um aps o outro.
Considere uma memria interna com
capacidade para para trs registros.
Considere que esteja disponvel seis
unidades de fita magntica.
95
96
INT
ACO
ADE
fita 2:
CER
ABL
fita 3:
AAL
ACN
AACEILNRT
fita 5:
AAABCCLNO
fita 6:
AADE
97
n
.
m
No exemplo acima, n=22, m=3 e f=3
temos:
22
P (n) = log3
= 2.
3
P (n) = logf
98
99
100
101
102
E*
E*
E*
C*
A*
E*
C*
C*
E*
L*
E*
L*
L*
A*
A*
A*
A*
A*
N*
A*
A*
N*
C*
C*
N*
E*
E*
N*
N*
103
104
105
Consideraes Prticas
As operaes de entrada e sada de dados
devem ser implementadas eficientemente.
Deve-se procurar realizar a leitura, a escrita e
o processamento interno dos dados de forma
simultnea.
Os computadores de maior porte possuem
uma ou mais unidades independentes para
processamento de entrada e sada.
Assim, pode-se realizar processamento e
operaes de E/S simultaneamente.
106
Consideraes Prticas
Tcnica para obter superposio de E/S e
processamento interno:
Utilize 2f reas de entrada e 2f de sada.
Para cada unidade de entrada ou sada,
utiliza-se duas reas de armazenamento:
1. Uma para uso do processador central
2. Outra para uso do processador de
entrada ou sada.
Para entrada, o processador central usa
uma das duas reas enquanto a unidade
de entrada est preenchendo a outra rea.
Depois a utilizao das reas invertida
entre o processador de entrada e o
processador central.
Para sada, a mesma tcnica utilizada.
107
Consideraes Prticas
Problemas com a tcnica:
Apenas metade da memria disponvel
utilizada.
Isso pode levar a uma ineficincia se o
nmero de reas for grande.
Ex: Intercalao-de-f -caminhos para f
grande.
Todas as f reas de entrada em uma
intercalao-de-f -caminhos se esvaziando
aproximadamente ao mesmo tempo.
108
Consideraes Prticas
Soluo para os problemas:
Tcnica de previso:
Requer a utilizao de uma nica rea
extra de armazenamento durante a
intercalao.
Superpe a entrada da prxima rea
que precisa ser preenchida com a parte
de processamento interno do algoritmo.
fcil saber qual rea ficar vazia
primeiro.
Basta olhar para o ltimo registro de
cada rea.
A rea cujo ltimo registro o menor,
ser a primeira a se esvaziar.
109
Consideraes Prticas
Escolha da ordem de intercalao f :
Para fitas magnticas:
f deve ser igual ao nmero de unidades
de fita disponveis menos um.
A fase de intercalao usa f fitas de
entrada e uma fita de sada.
O nmero de fitas de entrada deve ser
no mnimo dois.
Para discos magnticos:
O mesmo raciocnio acima vlido.
O acesso seqencial mais eficiente.
Sedegwick (1988) sugere considerar f
grande o suficiente para completar a
ordenao em poucos passos.
Porm, a melhor escolha para f depende
de vrios parmetros relacionados com o
sistema de computao disponvel.
110
Intercalao Polifsica
Problema com a intercalao balanceada de
vrios caminhos:
Necessita de um grande nmero de fitas.
Faz vrias leituras e escritas entre as fitas
envolvidas.
Para uma intercalao balanceada de f
caminhos so necessrias 2f fitas.
Alternativamente, pode-se copiar o arquivo
quase todo de uma nica fita de sada
para f fitas de entrada.
Isso reduz o nmero de fitas para f + 1.
Porm, h um custo de uma cpia
adicional do arquivo.
Soluo:
Intercalao polifsica.
111
Intercalao Polifsica
Os blocos ordenados so distribudos de
forma desigual entre as fitas disponveis.
Uma fita deixada livre.
Em seguida, a intercalao de blocos
ordenados executada at que uma das fitas
esvazie.
Neste ponto, uma das fitas de sada troca de
papel com a fita de entrada.
112
113
Intercalao Polifsica
Exemplo:
Blocos ordenados obtidos por meio de
seleo por substituio:
fita 1:
INRT
ACEL
fita 2:
AACEN
AAD
AABCLO
fita 3:
AABCLO
fita 2:
fita 3:
AACEINNRT
AAACDEL
Intercalao Polifsica
Exemplo:
Depois da intercalao-de-2-caminhos das
fitas 1 e 3 para a fita 2:
fita 1:
fita 2:
AAAABCCEILNNORT
fita 3:
AAACDEL
Finalmente:
fita 1:
AAAAAAABCCCDEEILLNNORT
fita 2:
fita 3:
114
115
Intercalao Polifsica
A implementao da intercalao polifsica
simples.
A parte mais delicada est na distribuio
inicial dos blocos ordenados entre as fitas.
Distribuio dos blocos nas diversas etapas
do exemplo:
fita 1
fita 2
fita 3
Total
Intercalao Polifsica
Anlise:
A anlise da intercalao polifsica
complicada.
O que se sabe que ela ligeiramente
melhor do que a intercalao balanceada
para valores pequenos de f .
Para valores de f > 8, a intercalao
balanceada pode ser mais rpida.
116
Quicksort Externo
Foi proposto por Monard em 1980.
Utiliza o paradigma de diviso e conquista.
O algoritmo ordena in situ um arquivo
A = {R1 , . . . , Rn } de n registros.
Os registros esto armazenados
consecutivamente em memria secundria de
acesso randmico.
O algoritmo utiliza somente O(log n) unidades
de memria interna e no necessria
nenhuma memria externa adicional.
117
118
Quicksort Externo
So necessrios quatro mtodos adicionais
para a classe MeuItem (transparncia 6).
O mtodo toString especifica como o objeto
formatado.
Os mtodos leArq e gravaArq so utilizados
para ler e gravar um objeto da classe
MeuItem em um arquivo de acesso aleatrio.
O mtodo tamanho retorna o tamanho em
bytes de um objeto da classe MeuItem.
public String toString ( ) { return " " + this .chave ; }
public void gravaArq (RandomAccessFile arq)
throws IOException {
arq . writeInt ( this .chave) ;
}
public void leArq (RandomAccessFile arq)
throws IOException {
this .chave = arq . readInt ( ) ;
}
public static int tamanho ( ) { return 4 ; / 4 bytes / }
Quicksort Externo
Seja Ri , 1 i n, o registro que se encontra
na i-sima posio de A.
Algoritmo:
1. Particionar A da seguinte forma:
{R1 , . . . , Ri } Ri+1 Ri+2 . . . Rj2
Rj1 {Rj , . . . , Rn },
2. chamar recursivamente o algoritmo em
cada um dos subarquivos
A1 = {R1 , . . . , Ri } e A2 = {Rj , . . . , Rn }.
119
Quicksort Externo
Para o partionamento utilizanda uma rea
de armazenamento na memria interna.
Tamanho da rea: TamArea = j i 1, com
TamArea 3.
Nas chamadas recusivas deve-se considerar
que:
Primeiro deve ser ordenado o subarquivo
de menor tamanho.
Condio para que, na mdia, O(log n)
subarquivos tenham o processamento
adiado.
Subarquivos vazios ou com um nico
registro so ignorados.
Caso o arquivo de entrada A possua no
mximo TamArea registros, ele ordenado
em um nico passo.
120
121
Quicksort Externo
i Li
a)
Ls j
c)
Ls
e)
Ls
d)
j
7
f)
Li
Ls
3 3 10 6 1 7 7
Ei
4 5
h)
Ei
i
Li
Ls
5 3 10 6 1 7 7
i Ls Li
Li Ls
j)
3 3 10 6 1 7 7
3 1 10 6 1 7 7
i Ls Li
l)
Es
3 1 10 6 1 10 7
Ei
j
3
n)
4 5
4 5 6
Es
i Ls Li
4 5
j
3
4 5
Es
Li
Ls
Es
4 5
Ei
m) 3 1 10 6 6 10 7
Ei Es
3 4 5
Es
i
4 5
4 5 7
Ls
Es
3 1 10 6 1 10 7
Ei
Li
Ei
j
3 1 10 6 1 7 7
Es
Es
i Li Ls
Ls
Ei
j
Linf Lsup
5 3 10 6 1 7 4
Es
Li
i
4 5
rea
Es
Ei
5 3 10 6 1 7 7
Ei
k)
i
4 5
5 3 10 6 1 7 4
Es
Li
Ls
Ei
5 3 10 6 1 7 4
Ei
i)
b)
Es
Li
i Li
Linf Lsup
5 3 10 6 1 7 4
Ei
g)
rea
3 1 4 5 6 10 7
Es Ei
122
Quicksort Externo
O programa a seguir apresenta a classe
QuicksortExterno, na qual so definidos as
estruturas de dados e os mtodos utilizados
pelo algoritmo Quicksort Externo.
package cap4.ordenacaoexterna;
import cap3. arranjo .Area;
import cap4.MeuItem;
import java . io . ;
public class QuicksortExterno {
private static class LimiteParticoes { int i ; int j ; }
private RandomAccessFile arqLi ;
private RandomAccessFile arqEi ;
private RandomAccessFile arqLEs;
private boolean
ondeLer;
private MeuItem
ultLido ;
private Area
area;
private int
tamArea;
123
Quicksort Externo
this . arqEi
124
Quicksort Externo
public void quicksortExterno ( int esq, int dir )
throws Exception {
i f ( dir esq < 1) return ;
LimiteParticoes p = particao (esq, dir ) ;
i f (p. i esq < dir p. j ) { / / ordene primeiro o subarquivo menor
quicksortExterno (esq, p. i ) ;
quicksortExterno (p. j , dir ) ;
}
else {
quicksortExterno (p. j , dir ) ;
quicksortExterno (esq, p. i ) ;
}
}
Quicksort Externo
Mtodos auxiliares utilizados pelo mtodo
particao:
private int leSup ( int ls ) throws IOException {
this . ultLido = new MeuItem ( 0 ) ;
arqLEs.seek ( ( ls 1) MeuItem.tamanho ( ) ) ;
this . ultLido . leArq (arqLEs ) ; ondeLer = false ;
return ls ;
}
private int leInf ( int l i ) throws IOException {
this . ultLido = new MeuItem ( 0 ) ;
this . ultLido . leArq ( arqLi ) ; ondeLer = true ;
return ++ l i ;
}
private int inserirArea ( ) throws Exception {
area. insereItem ( this . ultLido ) ;
return area.obterNumCelOcupadas ( ) ;
}
125
Quicksort Externo
Mtodos auxiliares utilizados pelo mtodo
particao:
private int escreveMax ( int es) throws Exception {
arqLEs.seek ( ( es 1) MeuItem.tamanho ( ) ) ;
this . ultLido .gravaArq (arqLEs) ;
return es;
}
private int escreveMin ( int ei ) throws IOException {
this . ultLido .gravaArq ( arqEi ) ;
return ++ei ;
}
private int retiraMax ( ) throws Exception {
this . ultLido = (MeuItem) area. retiraUltimo ( ) ;
return area.obterNumCelOcupadas ( ) ;
}
private int retiraMin ( ) throws Exception {
this . ultLido = (MeuItem) area. retiraPrimeiro ( ) ;
return area.obterNumCelOcupadas ( ) ;
}
126
127
Quicksort Externo
Mtodo Partio:
private LimiteParticoes particao ( int esq, int dir )
throws Exception {
int ls = dir , es = dir , l i = esq, ei = esq, nrArea = 0;
MeuItem l i n f = new MeuItem ( Integer .MIN_VALUE) ; / /
MeuItem lsup = new MeuItem ( Integer .MAX_VALUE) ; / /
this .ondeLer = true ;
LimiteParticoes p = new LimiteParticoes ( ) ;
this .area = new Area ( this .tamArea) ;
arqLi .seek ( ( l i 1) MeuItem.tamanho ( ) ) ;
arqEi .seek ( ( ei 1) MeuItem.tamanho ( ) ) ;
p. i = esq 1; p. j = dir + 1;
while ( ls >= l i ) {
i f ( nrArea < this .tamArea 1) {
i f (ondeLer) ls = this .leSup ( ls ) ;
else l i = leInf ( l i ) ;
nrArea = inserirArea ( ) ;
}
else {
i f ( ls == es) ls = leSup ( ls ) ;
else i f ( l i == ei ) l i = leInf ( l i ) ;
else i f (ondeLer) ls = leSup ( ls ) ;
else l i = leInf ( l i ) ;
/ / Continua na prxima transparncia
Quicksort Externo
Mtodo Partio:
i f ( ultLido .compara ( lsup ) > 0) {
p. j = es ; es = escreveMax (es) ;
}
else i f ( ultLido .compara ( l i n f ) < 0) {
p. i = ei ; ei = escreveMin ( ei ) ;
}
else {
nrArea = inserirArea ( ) ;
i f ( ei esq < dir es ) {
nrArea = retiraMin ( ) ;
l i n f = this . ultLido ; ei=escreveMin ( ei ) ;
}
else {
nrArea = retiraMax ( ) ;
lsup = this . ultLido ; es=escreveMax (es) ;
}
}
}
}
while ( ei <= es ) {
nrArea = retiraMin ( ) ; ei = escreveMin ( ei ) ;
}
return p;
}
128
129
Quicksort Externo
Programa teste:
package cap4;
import java . io .RandomAccessFile;
import cap4.ordenacaoexterna. QuicksortExterno ; / / vide transparncia 122
public class TestaQuicksortExterno {
public static void main ( String [ ] args ) {
try {
RandomAccessFile arq = new RandomAccessFile ( "qe. dat" , "rwd" ) ;
MeuItem item = new MeuItem ( 5 ) ; item .gravaArq ( arq ) ;
item = new MeuItem ( 3 ) ; item .gravaArq ( arq ) ;
item = new MeuItem ( 1 0 ) ; item .gravaArq ( arq ) ;
item = new MeuItem ( 6 ) ; item .gravaArq ( arq ) ;
item = new MeuItem ( 1 ) ; item .gravaArq ( arq ) ;
item = new MeuItem ( 7 ) ; item .gravaArq ( arq ) ;
item = new MeuItem ( 4 ) ; item .gravaArq ( arq ) ;
arq . close ( ) ;
QuicksortExterno quicksortExterno=new QuicksortExterno( "qe. dat" ,3);
quicksortExterno . quicksortExterno ( 1 , 7 ) ;
quicksortExterno . fechaArquivos ( ) ;
arq = new RandomAccessFile ( "qe. dat" , " r " ) ;
item . leArq ( arq ) ;
while ( arq . getFilePointer ( ) < arq . length ( ) ) {
System. out . println ( "Registro=" + item . toString ( ) ) ;
item . leArq ( arq ) ;
}
System. out . println ( "Registro=" + item . toString ( ) ) ; arq . close ( ) ;
} catch ( Exception e ) { System. out . println (e.getMessage ( ) ) ; }
}
}
Quicksort Externo
Anlise:
Seja n o nmero de registros a serem
ordenados.
Seja e b o tamanho do bloco de leitura ou
gravao do Sistema operacional.
Melhor caso: O( nb )
Por exemplo, ocorre quando o arquivo de
entrada j est ordenado.
Pior caso:
n2
O( TamArea )
130
Pesquisa em Memria
Primria
Transparncias
elaboradas por Fabiano C. Botelho, Leonardo Rocha, Leonardo Mata e Nivio Ziviani
Pesquisa Digital
Trie
Patricia
Transformao de Chave (Hashing)
Funes de Transformao
Listas Encadeadas
Endereamento Aberto
Hashing Perfeito
Dicionrio
Nome comumente utilizado para descrever
uma estrutura de dados para pesquisa.
Dicionrio um tipo abstrato de dados
com as operaes:
1. Inicializa
2. Pesquisa
3. Insere
4. Retira
Analogia com um dicionrio da lngua
portuguesa:
Chaves palavras
Registros entradas associadas com
cada palavra:
pronncia
definio
sinnimos
outras informaes
Pesquisa Seqencial
Mtodo de pesquisa mais simples: a partir
do primeiro registro, pesquise
seqencialmente at encontrar a chave
procurada; ento pare.
Armazenamento de um conjunto de registros
por meio do tipo estruturado arranjo.
Pesquisa Seqencial
package cap5;
import cap4. Item ; / / vide programa do captulo 4
public class Tabela {
private Item registros [ ] ;
private int n;
public Tabela ( int maxN) {
this . registros = new Item [maxN+1];
this .n = 0;
}
public int pesquisa ( Item reg ) {
this . registros [0] = reg ; / / sentinela
int i = this .n;
while ( this . registros [ i ] .compara ( reg ) ! = 0 ) i ;
return i ;
}
public void insere ( Item reg ) throws Exception {
i f ( this .n == ( this . registros . length 1))
Pesquisa Seqencial
Cada registro contm um campo chave que
identifica o registro.
A Interface Item definida no captulo 4 foi
utilizada por permitir a criao de mtodos
genricos.
Alm da chave, podem existir outros
componentes em um registro, os quais no
tm influncia nos algoritmos.
O mtodo pesquisa retorna o ndice do registro
que contm a chave passada como
parmetro no registro reg; caso no esteja
presente, o valor retornado zero.
Essa implementao no suporta mais de um
registro com a mesma chave.
Pesquisa Seqencial
Utilizao de um registro sentinela na
posio zero do array:
1. Garante que a pesquisa sempre termina:
se o ndice retornado por Pesquisa for
zero, a pesquisa foi sem sucesso.
2. No necessrio testar se i > 0, devido a
isto:
o anel interno da funo Pesquisa
extremamente simples: o ndice i
decrementado e a chave de pesquisa
comparada com a chave que est no
registro.
isto faz com que esta tcnica seja
conhecida como pesquisa seqencial
rpida.
10
Pesquisa Seqencial
Anlise
Pesquisa com sucesso:
melhor caso : C(n) = 1
pior caso
: C(n) = n
caso medio
: C(n) = (n + 1)/2
11
Pesquisa Binria
Pesquisa em tabela pode ser mais
eficiente Se registros forem mantidos
em ordem
Para saber se uma chave est presente na
tabela
1. Compare a chave com o registro que est
na posio do meio da tabela.
2. Se a chave menor ento o registro
procurado est na primeira metade da
tabela
3. Se a chave maior ento o registro
procurado est na segunda metade da
tabela.
4. Repita o processo at que a chave seja
encontrada, ou fique apenas um registro
cuja chave diferente da procurada,
significando uma pesquisa sem sucesso.
12
13
Chaves iniciais:
14
Pesquisa Binria
Anlise
A cada iterao do algoritmo, o tamanho da
tabela dividido ao meio.
Logo: o nmero de vezes que o tamanho da
tabela dividido ao meio cerca de log n.
Ressalva: o custo para manter a tabela
ordenada alto:
a cada insero na posio p da tabela
implica no deslocamento dos registros a partir
da posio p para as posies seguintes.
Conseqentemente, a pesquisa binria no
deve ser usada em aplicaes muito
dinmicas.
15
rvores de Pesquisa
A rvore de pesquisa uma estrutura de
dados muito eficiente para armazenar
informao.
Particularmente adequada quando existe
necessidade de considerar todos ou alguma
combinao de:
1. Acesso direto e seqencial eficientes.
2. Facilidade de insero e retirada de
registros.
3. Boa taxa de utilizao de memria.
4. Utilizao de memria primria e
secundria.
16
17
7
4
O nvel do n raiz 0.
Se um n est no nvel i ento a raiz de suas
subrvores esto no nvel i + 1.
A altura de um n o comprimento do
caminho mais longo deste n at um n folha.
A altura de uma rvore a altura do n raiz.
18
19
20
21
22
23
24
7
4
25
26
27
easy
to
be
bye
to
and
be
be
and
be
to
and
to
Caminhamento Central
Aps construda a rvore, pode ser
necessrio percorrer todos os registros que
compem a tabela ou arquivo.
Existe mais de uma ordem de caminhamento
em rvores, mas a mais til a chamada
ordem de caminhamento central.
O caminhamento central mais bem
expresso em termos recursivos:
1. caminha na subrvore esquerda na ordem
central;
2. visita a raiz;
3. caminha na subrvore direita na ordem
central.
Uma caracterstica importante do
caminhamento central que os ns so
visitados de forma ordenada.
28
29
Caminhamento Central
Percorrer a rvore:
5
3
2
7
4
Anlise
O nmero de comparaes em uma pesquisa
com sucesso:
melhor caso : C(n) = O(1),
pior caso
: C(n) = O(n),
caso medio
30
Anlise
1. Para obter o pior caso basta que as chaves
sejam inseridas em ordem crescente ou
decrescente. Neste caso a rvore resultante
uma lista linear, cujo nmero mdio de
comparaes (n + 1)/2.
2. Para uma rvore de pesquisa randmica o
nmero esperado de comparaes para
recuperar um registro qualquer cerca de
1, 39 log n, apenas 39% pior que a rvore
completamente balanceada.
Uma rvore A com n chaves possui n + 1 ns
externos e estas n chaves dividem todos os
valores possveis em n + 1 intervalos. Uma
insero em A considerada randmica se
ela tem probabilidade igual de acontecer em
qualquer um dos n + 1 intervalos.
Uma rvore de pesquisa randmica com n
chaves uma rvore construida atravs de n
inseres randmicas sucessivas em uma
rvore inicialmente vazia.
31
32
3
2
7
4
2
1
6
3
33
34
35
rvores SBB
rvores B estrutura para memria
secundria. (Bayer R. e McCreight E.M.,
1972)
rvore 2-3 caso especial da rvore B.
Cada n tem duas ou trs subrvores.
Mais apropriada para memria primria.
Exemplo: Uma rvore 2-3 e a rvore B
binria correspondente(Bayer, R. 1971)
7
2,5
1
3,4
10
6
8,9
11
10
6
11
36
rvores SBB
rvore 2-3 rvore B binria (assimetria
inerente)
1. Referncias esquerda apontam para um
n no nvel abaixo.
2. Referncias direita podem ser verticais
ou horizontais.
Eliminao da assimetria nas rvores B
binrias rvores B binrias simtricas
(Symmetric Binary B-trees SBB)
rvore SBB uma rvore binria com 2 tipos
de referncias: verticais e horizontais, tal que:
1. todos os caminhos da raiz at cada n
externo possuem o mesmo nmero de
referncias verticais, e
2. no podem existir dois referncias
horizontais sucessivos.
3
1
5
4
9
7
10
37
2
1
38
39
40
41
42
43
Exemplo
Insero de uma seqncia de chaves em
uma rvore SBB inicialmente vazia.
1. rvore esquerda obtida aps a
insero das chaves 7, 10, 5.
2. rvore do meio obtida aps a insero
das chaves 2, 4 na rvore anterior.
3. rvore direita obtida aps a insero
das chaves 9, 3, 6 na rvore anterior.
5
5
10
3
7
10
5
4
9
7
10
Procedimento Retira
Assim como o mtodo insere mostrado
anteriormente, o mtodo retira possui uma
verso privada, que foi sobrecarregada com
uma interface que contm um parmetro a
mais que a sua verso pblica.
O mtodo privado retira utiliza trs mtodos
auxiliares, a saber:
esqCurto (dirCurto) chamado quando um
n folha (que referenciado por uma
referncia vertical) retirado da subrvore
esquerda (direita), tornando-a menor na
altura aps a retirada;
Quando o n a ser retirado possui dois
descendentes, o mtodo antecessor
localiza o n antecessor para ser trocado
com o n a ser retirado.
44
45
46
47
48
49
Exemplo
Dada a rvore:
5
5
10
10
5
4
10
5
4
9
6
4
10
9
6
4
10
10
50
10
2
12
t
6
10
1a chamada DirCurto
10
2a chamada
DirCurto
2 chamadas DirCurto
Caso 2:
4
10
2
1
2
8
12
6
3
1a
10
2
1
chamada DirCurto
10
51
4
2
3
10
6
8
12
10
6
3
4
6
2
3
10
4
2
3
10
6
5
2
12 1
10
8
9
4
4
2
1
2
6
3
8
9
10
10
Anlise
Nas rvores SBB necessrio distinguir dois
tipos de alturas:
1. Altura vertical h necessria para manter
a altura uniforme e obtida atravs da
contagem do nmero de referncias
verticais em qualquer caminho entre a raiz
e um n externo.
2. Altura k representa o nmero mximo
de comparaes de chaves obtida atravs
da contagem do nmero total de
referncias no maior caminho entre a raiz
e um n externo.
A altura k maior que a altura h sempre que
existirem referncias horizontais na rvore.
Para uma rvore SBB com n ns internos,
temos que
h k 2h.
52
Anlise
De fato Bayer (1972) mostrou que
log(n + 1) k 2 log(n + 2) 2.
Custo para manter a propriedade SBB
Custo para percorrer o caminho de pesquisa
para encontrar a chave, seja para inser-la ou
para retir-la.
Logo: O custo O(log n).
Nmero de comparaes em uma pesquisa
com sucesso na rvore SBB
melhor caso : C(n) = O(1),
pior caso
caso medio
53
Pesquisa Digital
Pesquisa digital baseada na representao
das chaves como uma seqncia de
caracteres ou de dgitos.
Os mtodos de pesquisa digital so
particularmente vantajosos quando as chaves
so grandes e de tamanho varivel.
Um aspecto interessante quanto aos mtodos
de pesquisa digital a possibilidade de
localizar todas as ocorrncias de uma
determinada cadeia em um texto, com tempo
de resposta logartmico em relao ao
tamanho do texto.
Trie
Patrcia
54
Trie
Uma trie uma rvore M -ria cujos ns so
vetores de M componentes com campos
correspondentes aos dgitos ou caracteres
que formam as chaves.
Cada n no nvel i representa o conjunto de
todas as chaves que comeam com a mesma
seqncia de i dgitos ou caracteres.
Este n especifica uma ramificao com M
caminhos dependendo do (i + 1)-simo dgito
ou caractere de uma chave.
Considerando as chaves como seqncia
de bits (isto , M = 2), o algoritmo de
pesquisa digital semelhante ao de
pesquisa em rvore, exceto que, em vez de
se caminhar na rvore de acordo com o
resultado de comparao entre chaves,
caminha-se de acordo com os bits de
chave.
55
Exemplo
Dada as chaves de 6 bits:
B
= 010010
= 010011
H = 011000
J
= 100001
M = 101000
H
1
56
57
1
0
1
1
0
0
0
0
H
1
0
1
J
C
W
Q
58
59
= 100001
Q = 101000
1
3
6
B
3
H
60
Insero da Chave K
1
3
6
B
3
H
3
H
5
J
61
Insero da Chave W
A insero da chave W = 110110 ilustra um
outro aspecto.
Os bits das chaves K e W so comparados a
partir do primeiro para determinar em qual
ndice eles diferem, sendo, neste caso, os de
ndice 2.
Portanto: o ponto de insero agora ser no
caminho de pesquisa entre os ns internos de
ndice 1 e 3.
Cria-se a um novo n interno de ndice 2,
cujo descendente direito um n externo
contendo W e cujo descendente esquerdo a
subrvore de raiz de ndice 3.
1
3
6
B
2
H
5
J
62
63
Mtodos Auxiliares
/ / Retorna o i-simo bit da chave k a partir da esquerda
private int bit ( int i , char k) {
i f ( i == 0) return 0;
int c = ( int )k;
for ( int j = 1; j <= this .nbitsChave i ; j ++) c = c/2;
return c % 2;
}
/ / Verifica se p n externo
private boolean eExterno (PatNo p) {
Class classe = p.getClass ( ) ;
return classe.getName( ) .equals(PatNoExt.class.getName( ) ) ;
}
64
65
Mtodos Auxiliares
Mtodo para criar n externo:
private PatNo criaNoExt (char k) {
PatNoExt p = new PatNoExt ( ) ;
p.chave = k;
return p;
}
66
67
68
Algoritmo de insero
private PatNo insereEntre (char k , PatNo t , int i ) {
PatNoInt aux = null ;
i f ( ! this .eExterno ( t ) ) aux = (PatNoInt) t ;
i f ( this .eExterno ( t ) | | ( i < aux. index ) ) { / / Cria um novo n
externo
PatNo p = this . criaNoExt ( k ) ;
i f ( this . bit ( i , k) == 1) return this . criaNoInt ( i , t , p) ;
else return this . criaNoInt ( i , p, t ) ;
} else {
i f ( this . bit (aux. index , k) == 1)
aux. dir = this . insereEntre ( k , aux. dir , i ) ;
else aux.esq = this . insereEntre ( k , aux.esq, i ) ;
return aux;
}
}
private PatNo insere (char k , PatNo t ) {
i f ( t == null ) return this . criaNoExt ( k ) ;
else {
PatNo p = t ;
while ( ! this .eExterno (p) ) {
PatNoInt aux = (PatNoInt)p;
i f ( this . bit (aux. index , k) == 1) p = aux. dir ;
else p = aux.esq;
}
PatNoExt aux = (PatNoExt)p;
int i = 1; / / acha o primeiro bit diferente
while ( ( i <= this .nbitsChave)&&
( this . bit ( i , k) == this . bit ( i , aux.chave) ) ) i ++;
i f ( i > this .nbitsChave ) {
System. out . println ( "Erro : chave ja esta na arvore" ) ;
return t ;
}
else return this . insereEntre ( k , t , i ) ;
}
}
69
70
...
=
p=
M
M
M
N
Y
M i+1
M!
=
=
N
M
(M
N
)!M
i=1
71
10
0,883
22
0,524
23
0,493
30
0,303
72
Funes de Transformao
Uma funo de transformao deve mapear
chaves em inteiros dentro do intervalo
[0..M 1], onde M o tamanho da tabela.
A funo de transformao ideal aquela
que:
1. Seja simples de ser computada.
2. Para cada chave de entrada, qualquer
uma das sadas possveis igualmente
provvel de ocorrer.
Como as transformaes sobre as chaves
so aritmticas, deve-se transformar as
chaves no-numricas em nmeros.
Em Java, basta realizar uma converso de
cada caractere da chave no numrica para
um nmero inteiro.
73
74
Transformao de Chaves No
Numricas
As chaves no numricas devem ser
transformadas em nmeros:
K=
n1
X
i=0
chave[i] p[i],
75
Transformao de Chaves No
Numricas
Programa que gera um peso para cada
caractere de uma chave constituda de n
caracteres:
private int [ ] geraPesos ( int n) {
int p[ ] = new int [n ] ;
java . u t i l .Random rand = new java . u t i l .Random ( ) ;
for ( int i = 0; i < n ; i ++) p[ i ] = rand. nextInt (M) + 1;
return p;
}
Implementao da funo de
transformao:
private int h ( String chave, int [ ] pesos) {
int soma = 0;
for ( int i = 0; i < chave. length ( ) ; i ++)
soma = soma + ( ( int )chave. charAt ( i ) ) pesos[ i ] ;
return soma % this .M;
}
76
77
Listas Encadeadas
Uma das formas de resolver as colises
simplesmente construir uma lista linear
encadeada para cada endereo da tabela.
Assim, todas as chaves com mesmo
endereo so encadeadas em uma lista
linear.
Exemplo: Se a i-sima letra do alfabeto
representada pelo nmero i e a funo de
transformao h(Chave) = Chave mod M
utilizada para M = 7, o resultado da insero
das chaves P E S Q U I S A na tabela o
seguinte:
Por exemplo, h(A) = h(1) = 1,
h(E) = h(5) = 5, h(S) = h(19) = 5, e assim
por diante.
T
0
1
2
3
4
5
6
U
A
P
Q
- nil
- nil
- I
- nil
nil
nil
E
nil
- S
- S
nil
78
79
80
Anlise
Assumindo que qualquer item do conjunto
tem igual probabilidade de ser endereado
para qualquer entrada da tabela, ento o
comprimento esperado de cada lista
encadeada N/M , em que N representa o
nmero de registros na tabela e M o tamanho
da tabela.
Logo: as operaes pesquisa, insere e retira
custam O(1 + N/M ) operaes em mdia,
sendo que a constante 1 representa o tempo
para encontrar a entrada na tabela, e N/M , o
tempo para percorrer a lista. Para valores de
M prximos de N , o tempo torna-se
constante, isto , independente de N .
81
Endereamento Aberto
Quando o nmero de registros a serem
armazenados na tabela puder ser
previamente estimado, ento no haver
necessidade de usar listas encadeadas para
armazenar os registros.
Existem vrios mtodos para armazenar N
registros em uma tabela de tamanho M > N ,
os quais utilizam os lugares vazios na prpria
tabela para resolver as colises. (Knuth,
1973, p.518)
No Endereamento aberto todas as chaves
so armazenadas na prpria tabela, sem o
uso de listas encadeadas em cada entrada
dela.
Existem vrias propostas para a escolha de
localizaes alternativas. A mais simples
chamada de hashing linear, onde a posio
hj na tabela dada por:
hj = (h(x) + j) mod M, para 1 j M 1.
82
Exemplo
Se a i-sima letra do alfabeto representada
pelo nmero i e a funo de transformao
h(chave) = chave mod M utilizada para
M = 7,
U
N
S
L
E
83
84
85
86
87
Anlise
Seja = N/M o fator de carga da tabela.
Conforme demonstrado por Knuth (1973), o
custo de uma pesquisa com sucesso
1
1
C(n) =
1+
2
1
O hashing linear sofre de um mal chamado
agrupamento(clustering) (Knuth, 1973,
pp.520521).
Este fenmeno ocorre na medida em que a
tabela comea a ficar cheia, pois a insero
de uma nova chave tende a ocupar uma
posio na tabela que esteja contgua a
outras posies j ocupadas, o que deteriora
o tempo necessrio para novas pesquisas.
Entretanto, apesar do hashing linear ser um
mtodo relativamente pobre para resolver
colises os resultados apresentados so
bons.
O melhor caso, assim como o caso mdio,
O(1).
88
Vantagens e Desvantagens de
Transformao da Chave
Vantagens:
Alta eficincia no custo de pesquisa, que
O(1) para o caso mdio.
Simplicidade de implementao.
Desvantagens:
Custo para recuperar os registros na ordem
lexicogrfica das chaves alto, sendo
necessrio ordenar o arquivo.
Pior caso O(N ).
89
Hashing Perfeito
Se h(xi ) = h(xj ) se e somente se i = j, ento
no h colises, e a funo de transformao
chamada de funo de transformao
perfeita ou funo hashing perfeita(hp).
Se o nmero de chaves N e o tamanho da
tabela M so iguais ( = N/M = 1), ento
temos uma funo de transformao
perfeita mnima.
Se xi xj e hp(xi ) hp(xj ), ento a ordem
lexicogrfica preservada. Nesse caso,
temos uma funo de transformao
perfeita mnima com ordem preservada.
90
91
92
93
Exemplo
Chaves: 12 meses do ano abreviados para
os trs primeiros caracteres.
Objetivo: obter uma funo de transformao
perfeita hp de tal forma que o i-simo ms
mantido na (i 1)-sima posio da tabela
hash:
Chave x
h1 (x)
h2 (x)
hp(x)
jan
10
11
fev
mar
abr
mai
jun
10
jul
ago
set
out
nov
10
dez
11
94
95
6
3
2
10
3
8
11
8
7
4
5
96
97
6
3
2
10
3
8
11
8
7
4
5
(a)
Chave x
h1 (x)
h2 (x)
hp(x)
v:
g(v)
jan
10
11
fev
mar
abr
mai
11
jun
10
jul
ago
set
out
nov
10
10
dez
11
11
(b)
Problema
Quando o grafo contm ciclos: o
mapeamento a ser realizado pode rotular de
novo um vrtice j processado e que tenha
recebido outro rtulo com valor diferente.
Por exemplo, se a aresta (5, 6), que a aresta
de rtulo 7, tivesse sido sorteada para a
aresta (8, 11), o algoritmo tentaria atribuir dois
valores distintos para o valor de g[11].
Para enxergar isso, vimos que se g[8] = 0,
ento g[11] deveria ser igual a 7, e no igual
ao valor 9 obtido acima.
Um grafo que permite a atribuio de dois
valores de g para um mesmo vrtice, no
vlido.
Grafos acclicos no possuem este problema.
Um caminho seguro para se ter sucesso
obter antes um grafo acclico e depois realizar
a atribuio de valores para o arranjo g.
Czech, Havas e Majewski (1992).
98
Primeiro Refinamento do
Procedimento para Atribuir Valores ao
Arranjo g
boolean rotuleDe ( int v , int c , Grafo G, int g [ ] ) {
boolean grafoRotulavel = true ;
i f (g[ v ] ! = Indefinido ) i f (g[ v ] ! = c)
grafoRotulavel = false ;
else {
g[ v ] = c ;
for (u G. listaAdjacentes ( v) )
}
return grafoRotulavel ;
}
boolean atribuig ( Grafo G, int g [ ] ) {
boolean grafoRotulavel = true ;
for ( int v = 0; v < M; v++) g[ v ] = Indefinido ;
for ( int v = 0; v < M; v++)
i f (g[ v] == Indefinido )
grafoRotulavel = rotuleDe ( v , 0 , G, g) ;
return grafoRotulavel ;
}
99
100
101
/ / nmero de chaves
private int M;
/ / nmero de vrtices
int i = 0;
102
103
104
105
106
107
108
109
Anlise
A questo crucial : quantas interaes so
necessrias para obter um grafo G = (V, A)
que seja rotulvel?
Para grafos arbitrrios, difcil achar uma
soluo para esse problema, isso se existir tal
soluo.
Entretanto, para grafos acclicos, a funo g
existe sempre e pode ser obtida facilmente.
Assim, a resposta a esta questo depende do
valor de M que escolhido no primeiro passo
do algoritmo.
Quanto maior o valor de M , mais esparso o
grafo e, conseqentemente, mais provvel
que ele seja acclico.
110
Anlise
Segundo Czech, Havas e Majewski (1992),
quando M 2N a probabilidade de gerar
aleatoriamente um grafo acclico tende para
zero quando N cresce.
Isto ocorre porque o grafo se torna denso, e o
grande nmero de arestas pode levar
formao de ciclos.
Por outro lado, quando M > 2N , a
probabilidade de que um grafo randmico
contendo M vrtices e N arestas seja acclico
aproximadamente
r
M 2N
,
M
E o nmero esperado de grafos gerados at
que o primeiro acclico seja obtido :
r
M
M 2N
111
Anlise
Para M = 3N o nmero esperado de
iteraes 3, em mdia,
aproximadamente 1,7 grafos sero testados
antes que aparea um grafo acclico.
Logo, a complexidade de tempo para gerar a
funo de transformao proporcional ao
nmero de chaves a serem inseridas na
tabela hash, desde que M > 2N .
O grande inconveniente de usar M = 3N o
espao necessrio para armazenar o arranjo
g.
Por outro lado, considerar M < 2N pode
implicar na necessidade de gerar muitos
grficos randmicos at que um grafo acclico
seja encontrado.
112
Outra Alternativa
No utilizar grafos tradicionais, mas sim
hipergrafos, ou r-grafos, nos quais cada
aresta conecta um nmero qualquer r de
vrtices.
Para tanto, basta usar uma terceira funo h3
para gerar um trigrafo com arestas
conectando trs vrtices, chamado de
3-grafo.
Em outras palavras, cada aresta uma tripla
do tipo (h1 (x), h2 (x), h3 (x)), e a funo de
transformao dada por:
h(x) = (g(h1 (x)) + g(h2 (x)) + g(h3 (x))) mod N.
113
Outra Alternativa
Nesse caso, o valor de M pode ser prximo a
1, 23N .
Logo, o uso de trigrafos reduz o custo de
espao da funo de transformao perfeita,
mas aumenta o tempo de acesso ao
dicionrio.
Alm disso, o processo de rotulao no
pode ser feito como descrito.
Ciclos devem ser detectados previamente,
utilizando a seguinte propriedade de r-grafos:
Um r-grafo acclico se e somente se a
remoo repetida de arestas contendo
apenas vrtices de grau 1 (isto , vrtices
sobre os quais incide apenas uma aresta)
elimina todas as arestas do grafo.
114
115
Experimentos
# Chamadas
# Chamadas
Tempo
geraGrafo
atribuig
(s)
10
3586
0.130
20
20795
16
0.217
30
55482
24
0.390
40
52077
33
0.432
50
47828
19
0.462
60
27556
10
0.313
70
26265
17
0.351
80
161736
92
1.543
90
117014
106
1.228
100
43123
26
0.559
# Chaves
Pesquisa em Memria
Secundria
Transparncias
Introduo
Pesquisa em memria secundria: arquivos
contm mais registros do que a memria
interna pode armazenar.
Custo para acessar um registro algumas
ordens de grandeza maior do que o custo de
processamento na memria primria.
Medida de complexidade: custo de trasferir
dados entre a memria principal e secundria
(minimizar o nmero de transferncias).
Memrias secundrias: apenas um registro
pode ser acessado em um dado momento
(acesso seqencial).
Memrias primrias: acesso a qualquer
registro de um arquivo a um custo uniforme
(acesso direto).
Em um mtodo eficiente de pesquisa, o
aspecto sistema de computao importante.
As caractersticas da arquitetura e do sistema
operacional da mquina tornam os mtodos
de pesquisa dependentes de parmetros que
afetam seus desempenhos.
Memria Virtual
Organizao de fluxo transformar o
endereo usado pelo programador na
localizao fsica de memria
correspondente.
Espao de Endereamento endereos
usados pelo programador.
Espao de Memria localizaes de
memria no computador.
O espao de endereamento N e o espao
de memria M podem ser vistos como um
mapeamento de endereos do tipo:
f : N M.
O mapeamento permite ao programador usar
um espao de endereamento que pode ser
maior que o espao de memria primria
disponvel.
N da
pgina
N do
byte
Tabela_de_Pginas
Pgina p
?
p0 = nil pgina no
presente na
memria
p0
p0 + b
Fim
6
?
Pgina p
..
6
?
..
Incio
10
Memria Virtual
Em casos em que precisamos manipular mais
de um arquivo ao mesmo tempo:
Deve-se utilizar os mecanismos de
Herana e Polimorfismo de Java que
permitem que uma pgina possa ser
definida como vrios tipos diferentes.
A fila de molduras nica cada moldura
deve ter indicado o arquivo a que se refere
aquela pgina.
package cap6. variostipos ;
public abstract class Pagina {
/ / Componentes e mtodos de uma pgina
}
class PaginaA extends Pagina {
/ / Componentes e mtodos de uma pgina do tipo A
}
class PaginaB extends Pagina {
/ / Componentes e mtodos de uma pgina do tipo B
}
class PaginaC extends Pagina {
/ / Componentes e mtodos de uma pgina do tipo C
}
11
Memria Virtual
Procedimentos para comunicao com o
sistema de paginao:
obtemRegistro torna disponvel um
registro.
escreveRegistro permite criar ou alterar o
contedo de um registro.
descarregaPaginas varre a fila de
molduras para atualizar na memria
secundria todas as pginas que tenham
sido modificadas.
12
13
Consulta
tabela de
pginas
P3
-
Determina
moldura
para pgina
p0
p
A2
Programa
Usurio
p0
Fila
de
molduras
p0
p
p0
p0
6
p
p0
?
P2
Determina
endereo
real
p0
?
P5
Grava pgina
na memria
secundria
p0
A3
Memria
secundria Pgina
A1
Tabela
de
pginas
Pgina
p0
p6
P4
Recupera pgina
da memria
Pgina
secundria
14
3 5 7 11
2 14 17 20 21
3 25 29 32 36
4 41 44 48
15
16
17
18
rvores B
rvores n-rias: mais de um registro por
nodo.
Em uma rvore B de ordem m:
pgina raiz: 1 e 2m registros.
demais pginas: no mnimo m registros e
m + 1 descendentes e no mximo 2m
registros e 2m + 1 descendentes.
pginas folhas: aparecem todas no
mesmo nvel.
Os registros aparecem em ordem crescente
da esquerda para a direita.
Extenso natural da rvore binria de
pesquisa.
rvore B de ordem m = 2 com trs nveis:
30hhh
hhh
10 20
40 50
`
``
`
`
```
`
`
3489
11 13 17
25 28
33 36
43 45 48
52 55
19
20
21
22
rvores B - Insero
1. Localizar a pgina apropriada aonde o regisro
deve ser inserido.
2. Se o registro a ser inserido encontra uma
pgina com menos de 2m registros, o
processo de insero fica limitado pgina.
3. Se o registro a ser inserido encontra uma
pgina cheia, criada uma nova pgina, no
caso da pgina pai estar cheia o processo de
diviso se propaga.
Exemplo: Inserindo o registro com chave 14.
3489
2
1 10
``
```
`
16 20 25 29
3
10 20
1
``
` `
`
`
3489
25 29
14 16
2
3
4
(a)
(b)
23
rvores B - Insero
Exemplo de insero das chaves: 20, 10, 40, 50,
30, 55, 3, 11, 4, 28, 36, 33, 52, 17, 25, 13, 45, 9,
43, 8 e 48
(a)
20
(b)
30 P
PP
10 20
40 50
(c)
10 20 30 40
(
(
hhh
(
Ph
(
P
hh
(
P
(
(
h
11 13 17
25 28
33 36
50 52 55
3 4
(d)
30hhh
hhh
10 20
40 50
`
``
`
`
```
``
3489
11 13 17
25 28
33 36
43 45 48
52 55
24
25
26
rvores B - Remoo
Pgina com o registro a ser retirado folha:
1. retira-se o registro,
2. se a pgina no possui pelo menos de m
registros, a propriedade da rvore B
violada. Pega-se um registro emprestado
da pgina vizinha. Se no existir registros
suficientes na pgina vizinha, as duas
pginas devem ser fundidas em uma s.
Pagina com o registro no folha:
1. o registro a ser retirado deve ser
primeiramente substitudo por um registro
contendo uma chave adjacente.
27
28
rvores B - Remoo
Exemplo: Retirando a chave 3.
4j
H
HH
2j
6 8
@
@
T
j
j
3
5j7j9j
1
4j
, ll
,
* j
6 8
T
jjj
1 2 5 7 9
6j
,, ll
8j
4j
AA
AA
j 7j 9j
1 2 5
4j
, ll
* ,
j
6j
AA
j j
1 2 5 7
j
4 6
T
jj
1 2 5 7
29
rvores B - Remoo
Exemplo de remoo das chaves 45 30 28; 50 8
10 4 20 40 55 17 33 11 36; 3 9 52.
(a)
30hhh
hhh
10 20
40 50
`
``
```
```
`
3489
11 13 17
25 28
33 36
43 45 48
52 55
(b)
10 25 40 50
(
(
hhhh
(
Ph
(
(
P
(
h
P
(
h
11 13 17 20
3 4 8 9
33 36
43 48
52 55
(c)
13 P
PP
25 43 48 52
3 9
(d)
13 25 43 48
30
31
32
33
34
rvores B* - Pesquisa
Semelhante pesquisa em rvore B,
A pesquisa sempre leva a uma pgina folha,
A pesquisa no pra se a chave procurada for
encontrada em uma pgina ndice. O
apontador da direita seguido at que se
encontre uma pgina folha.
35
36
37
38
39
40
41
42
43
3
7
44
rvore B - Tcnica de
Transbordamento (ou Overflow)
Assuma que um registro tenha de ser inserido
em uma pgina cheia, com 2m registros.
Em vez de particion-la, olhamos primeiro
para a pgina irm direita.
Se a pgina irm possui menos do que 2m
registros, um simples rearranjo de chaves
torna a partio desnecessria.
Se a pgina direita tambm estiver cheia ou
no existir, olhamos para a pgina irm
esquerda.
Se ambas estiverem cheias, ento a partio
ter de ser realizada.
Efeito da modificao: produzir uma rvore
com melhor utilizao de memria e uma
altura esperada menor.
Produz uma utilizao de memria de cerca
de 83% para uma rvore B randmica.
45
46
Algoritmos em Grafos
Transparncias
Motivao
Muitas aplicaes em computao
necessitam considerar conjunto de conexes
entre pares de objetos:
Existe um caminho para ir de um objeto a
outro seguindo as conexes?
Qual a menor distncia entre um objeto
e outro objeto?
Quantos outros objetos podem ser
alcanados a partir de um determinado
objeto?
Existe um tipo abstrato chamado grafo que
usado para modelar tais situaes.
Aplicaes
Alguns exemplos de problemas prticos que
podem ser resolvidos atravs de uma
modelagem em grafos:
Ajudar mquinas de busca a localizar
informao relevante na Web.
Descobrir os melhores casamentos entre
posies disponveis em empresas e
pessoas que aplicaram para as posies
de interesse.
Descobrir qual o roteiro mais curto para
visitar as principais cidades de uma regio
turstica.
Conceitos Bsicos
Grafo: conjunto de vrtices e arestas.
Vrtice: objeto simples que pode ter nome e
outros atributos.
Aresta: conexo entre dois vrtices.
3
aresta
1
vrtice
Notao: G = (V, A)
G: grafo
V: conjunto de vrtices
A: conjunto de arestas
Grafos Direcionados
Um grafo direcionado G um par (V, A), onde
V um conjunto finito de vrtices e A uma
relao binria em V .
Uma aresta (u, v) sai do vrtice u e entra
no vrtice v. O vrtice v adjacente ao
vrtice u.
Podem existir arestas de um vrtice para
ele mesmo, chamadas de self-loops.
0
Grafos No Direcionados
Um grafo no direcionado G um par (V, A),
onde o conjunto de arestas A constitudo de
pares de vrtices no ordenados.
As arestas (u, v) e (v, u) so consideradas
como uma nica aresta. A relao de
adjacncia simtrica.
Self-loops no so permitidos.
0
Grau de um Vrtice
Em grafos no direcionados:
O grau de um vrtice o nmero de
arestas que incidem nele.
Um vrice de grau zero dito isolado ou
no conectado.
Ex.: O vrtice 1 tem
grau 2 e o vrtice 3
isolado.
Em grafos direcionados
O grau de um vrtice o nmero de
arestas que saem dele (out-degree) mais
o nmero de arestas que chegam nele
(in-degree).
Ex.: O vrtice 2 tem
in-degree 2, out-degree
2 e grau 4.
Ciclos
Em um grafo direcionado:
Um caminho (v0 , v1 , . . . , vk ) forma um ciclo
se v0 = vk e o caminho contm pelo
menos uma aresta.
O ciclo simples se os vrtices
v1 , v2 , . . . , vk so distintos.
O self-loop um ciclo de tamanho 1.
Dois caminhos (v0 , v1 , . . . , vk ) e
(v00 , v10 , . . . , vk0 ) formam o mesmo ciclo se
existir um inteiro j tal que vi0 = v(i+j) mod k
para i = 0, 1, . . . , k 1.
Ex.: O caminho (0, 1, 2, 3, 0) forma um ciclo. O
caminho(0, 1, 3, 0) forma o mesmo ciclo que os
caminhos (1, 3, 0, 1) e (3, 0, 1, 3).
0
Ciclos
Em um grafo no direcionado:
Um caminho (v0 , v1 , . . . , vk ) forma um ciclo
se v0 = vk e o caminho contm pelo
menos trs arestas.
O ciclo simples se os vrtices
v1 , v2 , . . . , vk so distintos.
Ex.: O caminho (0, 1, 2, 0) um ciclo.
0
10
Componentes Conectados
Um grafo no direcionado conectado se
cada par de vrtices est conectado por um
caminho.
Os componentes conectados so as pores
conectadas de um grafo.
Um grafo no direcionado conectado se ele
tem exatamente um componente conectado.
Ex.: Os componentes so: {0, 1, 2}, {4, 5} e {3}.
0
11
12
Grafos Isomorfos
G = (V, A) e G0 = (V 0 , A0 ) so isomorfos se
existir uma bijeo f : V V 0 tal que
(u, v) A se e somente se (f (u), f (v)) A0 .
0
1
4
13
Subgrafos
Um grafo G0 = (V 0 , A0 ) um subgrafo de
G = (V, A) se V 0 V e A0 A.
Dado um conjunto V 0 V , o subgrafo
induzido por V 0 o grafo G0 = (V 0 , A0 ), onde
A0 = {(u, v) A|u, v V 0 }.
Ex.: Subgrafo induzido pelo conjunto de vrtices
{1, 2, 4, 5}.
0
14
15
16
Grafos Completos
Um grafo completo um grafo no
direcionado no qual todos os pares de
vrtices so adjacentes.
Possui (|V |2 |V |)/2 = |V |(|V | 1)/2 arestas,
pois do total de |V |2 pares possveis de
vrtices devemos subtrair |V | self-loops e
dividir por 2 (cada aresta ligando dois vrtices
contada duas vezes).
O nmero total de grafos diferentes com |V |
vrtices 2|V |(|V |1)/2 (nmero de maneiras
diferentes de escolher um subconjunto a
partir de |V |(|V | 1)/2 possveis arestas).
17
18
rvores
rvore livre: grafo no direcionado acclico e
conectado. comum dizer apenas que o
grafo uma rvore omitindo o livre.
Floresta: grafo no direcionado acclico,
podendo ou no ser conectado.
rvore geradora de um grafo conectado
G = (V, A): subgrafo que contm todos os
vrtices de G e forma uma rvore.
Floresta geradora de um grafo G = (V, A):
subgrafo que contm todos os vrtices de G e
forma uma floresta.
(a)
(b)
19
20
21
22
Matriz de Adjacncia
A matriz de adjacncia de um grafo
G = (V, A) contendo n vrtices uma matriz
n n de bits, onde A[i, j] 1 (ou verdadeiro)
se e somente se existe um arco do vrtice i
para o vrtice j.
Para grafos ponderados A[i, j] contm o
rtulo ou peso associado com a aresta e,
neste caso, a matriz no de bits.
Se no existir uma aresta de i para j ento
necessrio utilizar um valor que no possa
ser usado como rtulo ou peso.
23
24
0 1 2 3 4 5
0
1
1
1
1 1
2
1 1
3 1
4
5
0 1 2 3 4 5
0
1 1
1 1
1
2 1 1
3
4
5
(a)
(b)
25
26
27
28
" );
" );
" );
" );
29
5
0
1
7
2 7
0
1
7
1 3
5
0
1 5
1 5
0 5
2 7
1 7
30
31
32
33
34
35
3
0
(a)
V
7
0
1
2
3
4
5
6
4
6
2
3
1
1
2
cab
5
0
(b)
7
3
0
1
2
3
4
5
6
7
4
6
7
3
1
0
2
1
prox peso
4
5
0
0
0
6
0
5
3
7
prox peso
4
5
7
0
0
6
0
0
5
5
7
7
36
37
38
}
}
public int numVertices ( ) { return this .numVertices ; }
}
Busca em Profundidade
A busca em profundidade, do ingls
depth-first search), um algoritmo para
caminhar no grafo.
A estratgia buscar o mais profundo no
grafo sempre que possvel.
As arestas so exploradas a partir do vrtice
v mais recentemente descoberto que ainda
possui arestas no exploradas saindo dele.
Quando todas as arestas adjacentes a v
tiverem sido exploradas a busca anda para
trs para explorar vrtices que saem do
vrtice do qual v foi descoberto.
O algoritmo a base para muitos outros
algoritmos importantes, tais como verificao
de grafos acclicos, ordenao topolgica e
componentes fortemente conectados.
39
Busca em Profundidade
Para acompanhar o progresso do algoritmo
cada vrtice colorido de branco, cinza ou
preto.
Todos os vrtices so inicializados branco.
Quando um vrtice descoberto pela
primeira vez ele torna-se cinza, e tornado
preto quando sua lista de adjacentes tenha
sido completamente examinada.
d[v]: tempo de descoberta
t[v]: tempo de trmino do exame da lista de
adjacentes de v.
Estes registros so inteiros entre 1 e 2|V | pois
existe um evento de descoberta e um evento
de trmino para cada um dos |V | vrtices.
40
= 1;
= 2;
41
42
43
b( / )
c(1/ )
b( / )
b( / )
b( / ) 2
b( / )
b( / ) 2
(a)
(b)
c(1/ )
c(2/ )
c(1/ )
c(2/ )
b( / )
b( / ) 2
b( / )
c(3/ ) 2
(c)
(d)
c(1/ )
c(2/ )
1
b( / )
p(3/4) 2
(e)
44
p(2/5)
p(1/6)
p(2/5)
1
b( / )
b( / )
p(3/4) 2
p(3/4) 2
(g)
(f)
p(1/6)
p(2/5)
p(1/6)
p(2/5)
c(7/ )
p(3/4) 2
(h)
p(7/8)
p(3/4) 2
(i)
|adj[u]| = O(|A|),
uV
45
Classificao de Arestas
Existem:
1. Arestas de rvore: so arestas de uma
rvore de busca em profundidade. A aresta
(u, v) uma aresta de rvore se v foi
descoberto pela primeira vez ao percorrer a
aresta (u, v).
2. Arestas de retorno: conectam um vrtice u
com um antecessor v em uma rvore de
busca em profundidade (inclui self-loops).
3. Arestas de avano: no pertencem rvore
de busca em profundidade mas conectam um
vrtice a um descendente que pertence
rvore de busca em profundidade.
4. Arestas de cruzamento: podem conectar
vrtices na mesma rvore de busca em
profundidade, ou em duas rvores diferentes.
46
47
Classificao de Arestas
Classificao de arestas pode ser til para
derivar outros algoritmos.
Na busca em profundidade cada aresta pode
ser classificada pela cor do vrtice que
alcanado pela primeira vez:
Branco indica uma aresta de rvore.
Cinza indica uma aresta de retorno.
Preto indica uma aresta de avano quando
u descoberto antes de v ou uma aresta
de cruzamento caso contrrio.
2/9
3/6
2
arv
arv
arv
ret
arv
1/10
cruz
avan
3
4/5
cruz
4
7/8
cruz
5
11/12
48
Busca em Largura
Expande a fronteira entre vrtices
descobertos e no descobertos
uniformemente atravs da largura da
fronteira.
O algoritmo descobre todos os vrtices a uma
distncia k do vrtice origem antes de
descobrir qualquer vrtice a uma distncia
k + 1.
O grafo G(V, A) pode ser direcionado ou no
direcionado.
49
Busca em Largura
Cada vrtice colorido de branco, cinza ou
preto.
Todos os vrtices so inicializados branco.
Quando um vrtice descoberto pela
primeira vez ele torna-se cinza.
Vrtices cinza e preto j foram descobertos,
mas so distinguidos para assegurar que a
busca ocorra em largura.
Se (u, v) A e o vrtice u preto, ento o
vrtice v tem que ser cinza ou preto.
Vrtices cinza podem ter alguns vrtices
adjacentes brancos, e eles representam a
fronteira entre vrtices descobertos e no
descobertos.
50
51
= 1;
= 2;
52
53
(a)
c(0)
b( )
b( )
p(0)
c(1)
b( )
b( )
b( )
b( )
c(1)
b( )
b( )
F 0
0
F 1 3
1 1
(c)
(d)
p(0)
p(1)
b( )
p(0)
p(1)
b( )
c(1)
c(2)
b( )
p(1)
c(2)
b( )
F 3 2
1 2
F 2
2
54
(f)
p(0)
p(1)
b( )
p(0)
p(1)
c(0)
p(1)
p(2)
b( )
p(1)
p(2)
b( )
F 4
0
(g)
(h)
p(0)
p(1)
p(0)
p(0)
p(1)
p(0)
p(1)
p(2)
c(1)
p(1)
p(2)
p(1)
F 5
1
55
56
Ordenao Topolgica
Ordenao linear de todos os vrtices, tal que
se G contm uma aresta (u, v) ento u
aparece antes de v.
Pode ser vista como uma ordenao de seus
vrtices ao longo de uma linha horizontal de
tal forma que todas as arestas esto
direcionadas da esquerda para a direita.
Pode ser feita usando a busca em
profundidade.
57
58
Ordenao Topolgica
Os grafos direcionados acclicos so usados
para indicar precedncias entre eventos.
Uma aresta direcionada (u, v) indica que a
atividade u tem que ser realizada antes da
atividade v.
1/18
16/17
19/20
4/5 3
2/15
7/12
3/14
6/13
8/11
9/10
Ordenao Topolgica
Algoritmo para ordenar topologicamente um
grafo direcionado acclico G = (V, A):
1. Aplicar a busca em profundidade no grafo
G para obter os tempos de trmino t[u]
para cada vrtice u.
2. Ao trmino de cada vrtice, insira-o na
frente de uma lista linear encadeada.
3. Retornar a lista encadeada de vrtices.
A Custo O(|V | + |A|), uma vez que a busca
em profundidade tem complexidade de tempo
O(|V | + |A|) e o custo para inserir cada um
dos |V | vrtices na frente da lista linear
encadeada custa O(1).
59
60
61
0,1,2
(a)
(b)
(c)
62
63
64
2/7
1/6
0
cruz
3
4/5
2
3/6
(a)
ret
arv
3/4
cruz
arv cruz
1
arv
3
2
cruz
7/8
2/5
(b)
ret
2
arv
1
(c)
65
66
Vertice : "+u) ;
i f ( ! grafo . listaAdjVazia (u ) ) {
Grafo. Aresta a = grafo . primeiroListaAdj (u) ;
while (a ! = null ) {
int v = a.v2 ( ) ;
i f ( t t . restantes [ v ] ) { this . visitaDfs ( grafo , v , t t ) ; }
a = grafo . proxAdj (u) ;
}
}
}
public void obterCfc ( ) {
BuscaEmProfundidade dfs = new BuscaEmProfundidade ( this . grafo ) ;
dfs .buscaEmProfundidade ( ) ;
TempoTermino t t = new TempoTermino ( this . grafo .numVertices ( ) ) ;
for ( int u = 0; u < this . grafo .numVertices ( ) ; u++) {
t t . t [u] = dfs . t (u ) ; t t . restantes [u] = true ;
}
Grafo grafoT = this . grafo . grafoTransposto ( ) ;
while ( t t .numRestantes > 0) {
int vRaiz = t t .maxTT ( ) ;
System. out . println ( "Raiz da proxima arvore : " + vRaiz ) ;
this . visitaDfs ( grafoT , vRaiz , t t ) ;
}
}
}
67
68
69
70
6
1
5
3
2
5
4
(a)
2
4
(b)
S = ;
return S ;
71
72
p
V
V V
5
2
p
3
V V
6 4
4
5
3
73
74
75
(b)
0
6
1
6
3
0
5
1
2
5
6
4
(c)
2
1
(d)
0
0
0
2
2
1
2
1
3
2
1
2
1
6
(e)
(f)
2
1
2
1
2
1
5
2
1
5
76
77
78
79
80
81
82
(b)
0
6
1
5
3
3
2
2
5
6
4
4
4
(c)
(d)
0
2
4
2
5
(e)
(f)
0
2
4
2
5
83
84
85
S = ;
2.
3.
4.
5.
6.
S = S + {(u, v)} ;
7.
conj . uniao ( u, v ) ;
86
87
Pk
i=1
p(vi1 , vi )
n
o
c
min p(c) : u ; v
se existir caminho de u a v
caso contrrio
88
89
90
91
Algoritmo de Dijkstra
Mantm um conjunto S de vrtices cujos
caminhos mais curtos at um vrtice origem
j so conhecidos.
Produz uma rvore de caminhos mais curtos
de um vrtice origem s para todos os vrtices
que so alcanveis a partir de s.
Utiliza a tcnica de relaxamento:
Para cada vrtice v V o atributo p[v]
um limite superior do peso de um caminho
mais curto do vrtice origem s at v.
O vetor p[v] contm uma estimativa de um
caminho mais curto.
O primeiro passo do algoritmo inicializar os
antecessores e as estimativas de caminhos
mais curtos:
antecessor[v] = null para todo vrtice
v V,
p[u] = 0, para o vrtice origem s, e
p[v] = para v V {s}.
92
Relaxamento
O relaxamento de uma aresta (u, v) consiste
em verificar se possvel melhorar o melhor
caminho at v obtido at o momento se
passarmos por u.
Se isto acontecer, p[v] e antecessor[v] devem
ser atualizados.
i f (p[ v] > p[u] + peso da aresta ( u, v) )
p[ v ] = p[u] + peso da aresta ( u, v ) ;
antecessor [ v ] = u;
93
2.
p[ v ] = I n f i n i t o ;
3.
antecessor [ v] = 1;
4.
p[ raiz ] = 0;
5.
S = ;
7.
8.
u = heap. retiraMin ( ) ;
S = S + u;
10.
11.
12.
13.
antecessor [ v ] = u;
94
95
(b)
0
1
1
10
4
3
1
5
2
10
4
(c)
10
6
3
0
0
1
1
10
4
3
1
5
2
6
10
6
Iterao
d[0]
d[1]
d[2]
d[3]
d[4]
(a)
(b)
{0}
10
(c)
{0, 1}
10
96
(e)
0
0
1
1
3
1
5
2
5
10
9
4
10
6
4
3
1
2
(f)
6
2
0
0
1
1
1
2
6
4
5
5
10
6
2
Iterao
d[0]
d[1]
d[2]
d[3]
d[4]
(d)
{0, 1, 3}
(e)
{0, 1, 3, 2}
(f)
{0, 1, 3, 2, 4}
Algoritmo de Dijkstra
Para realizar de forma eficiente a seleo de
uma nova aresta, todos os vrtices que no
esto na rvore de caminhos mais curtos
residem no heap A baseada no campo p.
Para cada vrtice v, p[v] o caminho mais
curto obtido at o momento, de v at o vrtice
raiz.
O heap mantm os vrtices, mas a condio
do heap mantida pelo caminho mais curto
estimado at o momento atravs do arranjo
p[v], o heap indireto.
o arranjo pos[v] fornece a posio do vrtice v
dentro do heap, permitindo assim que o
vrtice v possa ser acessado a um custo O(1)
para a operao diminuiChave.
97
98
99
100
101
102
103
104
105
(b)
arestas
1
2
4
1
2
3
4
prim
0
1
2
3
4
(1,2,0) (3,4,1) (3,5,2) (0,2,3) (2,3,4)
0
3
1
0
2
4
3
9
4
6
5
7
0 1 2 3 4 5 6 7 8
prox 1 1 1 1 8 1 1 1 5
9
2
106
107
108
109
}
}
public int numVertices ( ) { return this .numVertices ; }
}
110
Processamento de
Cadeias de
Caracteres
Transparncias
Definio e Motivao
Notao
Texto: arranjo T [0..n 1] de tamanho n;
Padro: arranjo P [0..m 1] de tamanho
m n.
Os elementos de P e T so escolhidos de um
alfabeto finito de tamanho c.
Ex.: = {0, 1} ou = {a, b, . . . , z}.
Casamento de cadeias ou casamento de
padro: dados duas cadeias P (padro) de
comprimento |P | = m e T (texto) de
comprimento |T | = n, onde n m, deseja-se
saber as ocorrncias de P em T .
Categorias de Algoritmos
P e T no so pr-processados:
algoritmo seqencial, on-line e de
tempo-real;
padro e texto no so conhecidos a priori.
complexidade de tempo O(mn) e de
espao O(1), para pior caso.
P pr-processado:
algoritmo seqencial;
padro conhecido anteriormente
permitindo seu pr-processamento.
complexidade de tempo O(n) e de espao
O(m + c), no pior caso.
ex.: programas para edio de textos.
Categorias de Algoritmos
P e T so pr-processados:
algoritmo constri ndice.
complexidade de tempo O(log n) e de
espao O(n).
tempo para obter o ndice grande, O(n)
ou O(n log n).
compensado por muitas operaes de
pesquisa no texto.
Tipos de ndices mais conhecidos:
Arquivos invertidos
rvores trie e rvores Patricia
Arranjos de sufixos
Exemplos: P e T so pr-processados
Diversos tipos de ndices: arquivos invertidos,
rvores trie e Patricia, e arranjos de sufixos.
Um arquivo invertido possui duas partes:
vocabulrio e ocorrncias.
O vocabulrio o conjunto de todas as
palavras distintas no texto.
Para cada palavra distinta, uma lista de
posies onde ela ocorre no texto
armazenada.
O conjunto das listas chamado de
ocorrncias.
As posies podem referir-se a palavras ou
caracteres.
15
21 25
35
44
52
exe mplo
exe rcem
44
fas cnio
52
pal avras
25 35
tem
21
tex to
0 15
e
f fascnio: 53
p
palavras: 26,36
t
m
e
x
exemplo: 7
exercem: 45
tem: 22
texto: 1, 16
10
11
Casamento Exato
12
13
14
Autmatos
Um autmato um modelo de computao
muito simples.
Um autmato finito definido por uma tupla
(Q, I, F, , T ), onde Q um conjunto finito de
estados, entre os quais existe um estado
inicial I Q, e alguns so estados finais ou
estados de trmino F Q.
Transies entre estados so rotuladas por
elementos de {}, em que o alfabeto
finito de entrada e a transio vazia.
As transies so formalmente definidas por
uma funo de transio T .
T associa a cada estado q Q um conjunto
{q1 , q2 , . . . , qk } de estados de Q para cada
{}.
15
Tipos de Autmatos
Autmato finito no-determinista:
Quando T tal que existe um estado q
associado a um dado caractere para
mais de um estado, digamos
T (q, ) = {q1 , q2 , . . . , qk }, k > 1, ou existe
alguma transio rotulada por .
Neste caso, a funo de transio T
definida pelo conjunto de triplas
= {(q, , q 0 ), onde q Q, {}, e
q 0 T (q, ).
Autmato finito determinista:
Quando a funo de transio T definida
pela funo = Q Q.
Neste caso, se T (q, ) = {q 0 }, ento
(q, ) = q 0 .
16
Exemplo de Autmatos
Autmato finito no-determinista.
A partir do estado 0, atravs do caractere de
transio a possvel atingir os estados 2 e 3.
a
c
1
c
1
17
c
1
18
Transies Vazias
So transies rotulada com uma cadeia
vazia , tambm chamadas de transies-,
em autmatos no-deterministas
No h necessidade de se ler um caractere
para caminhar atravs de uma transio
vazia.
Simplificam a construo do autmato.
Sempre existe um autmato equivalente que
reconhece a mesma linguagem sem
transies-.
19
Estados Ativos
Se uma cadeia x rotula um caminho de I at
um estado q ento o estado q considerado
ativo depois de ler x.
Um autmato finito determinista tem no
mximo um estado ativo em um determinado
instante.
Um autmato finito no-determinista pode ter
vrios estados ativos.
Casamento aproximado de cadeias pode ser
resolvido por meio de autmatos finitos
no-deterministas.
20
21
Ciclos em Autmatos
Os autmatos abaixo so acclicos pois as
transies no formam ciclos.
a
c
1
c
1
b
a
c
0
b
c
a
b,c
a
a
22
Knuth-Morris-Pratt (KMP)
O KMP o primeiro algoritmo (1977) cujo pior
caso tem complexidade de tempo linear no
tamanho do texto, O(n).
um dos algoritmos mais famosos para
resolver o problema de casamento de
cadeias.
Tem implementao complicada e na prtica
perde em eficincia para o Shift-And e o
Boyer-Moore-Horspool.
At 1971, o limite inferior conhecido para
busca exata de padres era O(mn).
23
KMP - 2DPDA
Em 1971, Cook provou que qualquer
problema que puder ser resolvido por um
autmato determinista de dois caminhos com
memria de pilha (Two-way Deterministic
Pushdown Store Automaton, 2DPDA) pode
ser resolvido em tempo linear por uma
mquina RAM.
O 2DPDA constitudo de:
uma fita apenas para leitura;
uma pilha de dados (memria temporria);
um controle de estado que permite mover
a fita para esquerda ou direita, empilhar ou
desempilhar smbolos, e mudar de estado.
# c
... c
$ p 1 p 2 ... p m
Cabea de leitura
Controle
c n Pilha
c n1
...
c
24
... c
$ p 1 p 2 ... p m
Cabea de leitura
Controle
c n Pilha
c n1
...
c
25
KMP - Algoritmo
Primeira verso do KMP uma simulao
linear do 2DPDA
O algoritmo computa o sufixo mais longo no
texto que tambm o prefixo de P .
Quando o comprimento do sufixo no texto
igual a |P | ocorre um casamento.
O pr-processamento de P permite que
nenhum caractere seja reexaminado.
O apontador para o texto nunca
decrementado.
O pr-processamento de P pode ser visto
como a construo econmica de um
autmato determinista que depois usado
para pesquisar pelo padro no texto.
26
Shift-And
O Shift-And vezes mais rpido e muito mais
simples do que o KMP.
Pode ser estendido para permitir casamento
aproximado de cadeias de caracteres.
Usa o conceito de paralelismo de bit:
tcnica que tira proveito do paralelismo
intrnseco das operaes sobre bits dentro
de uma palavra de computador.
possvel empacotar muitos valores em
uma nica palavra e atualizar todos eles
em uma nica operao.
Tirando proveito do paralelismo de bit, o
nmero de operaes que um algoritmo
realiza pode ser reduzido por um fator de at
w, onde w o nmero de bits da palavra do
computador.
27
28
29
Shift-And - Princpio de
Funcionamento
Mantm um conjunto de todos os prefixos de
P que casam com o texto j lido.
Utiliza o paralelismo de bit para atualizar o
conjunto a cada caractere lido do texto.
Este conjunto representado por uma
mscara de bits R = (b0 , b1 , . . . , bm1 ).
O algoritmo Shift-And pode ser visto como a
simulao de um autmato que pesquisa pelo
padro no texto (no-determinista para
simular o paralelismo de bit).
Ex.: Autmato no-determinista que reconhece
todos os prefixos de P ={teste}
0
Shift-And - Algoritmo
O valor 1 colocado na j-sima posio de
R = (b0 , b1 , . . . , bm1 ) se e somente se p0 . . . pj
um sufixo de t0 . . . ti , onde i corresponde
posio corrente no texto.
A j-sima posio de R dita estar ativa.
bm1 ativo significa um casamento.
R0 , o novo valor do conjunto R, calculado na
leitura do prximo caractere ti+1 .
A posio j + 1 no conjunto R0 ficar ativa se
e somente se a posio j estiver ativa em R e
ti+1 casa com pi+1 (p0 . . . pj era um sufixo de
t0 . . . ti e ti+1 casa com pj+1 ).
Com o uso de paralelismo de bit possvel
computar o novo conjunto com custo O(1).
30
Shift-And - Pr-processamento
O primeiro passo a construo de uma
tabela M para armazenar uma mscara de
bits b0 . . . , bm1 para cada caractere.
Ex.: mscaras de bits para os caracteres
presentes em P ={teste}.
0
M[t]
M[e]
M[s]
31
32
Shift-And - Pesquisa
O valor do conjunto inicializado como
R = 0m (0m significa 0 repetido m vezes).
Para cada novo caractere ti+1 lido do texto o
valor do conjunto R0 atualizado:
R0 = ((R >> 1) | 10m1 ) & M [T [i]].
A operao >> desloca todas as posies
para a direita no passo i + 1 para marcar
quais posies de P eram sufixos no passo i.
A cadeia vazia tambm marcada como um
sufixo, permitindo um casamento na posio
corrente do texto (self-loop no incio do
autmato).
0
33
Exemplo de funcionamento do
Shif-And
Pesquisa do padro P ={teste} no texto
T ={os testes ...}.
Texto
R0
(R >> 1)|10m1
Shift-And - Implementao
void Shift-And ( P = p0 p1 . . . pm1 , T = t0 t1 . . . tn1 )
/ / Pr-processamento
for ( c ) M [c] = 0m ;
for ( j = 0; j < m; j ++) M [pj ] = M [pj ] | 0j 10mj1 ;
/ / Pesquisa
R = 0m ;
for ( i = 0; i < n ; i ++)
R = ((R >> 1) | 10m1 ) & M [T [i]] ;
i f ( R & 0m1 1 6= 0m ) "Casamento na posicao i m + 1" ;
34
Boyer-Moore-Horspool (BMH)
Em 1977, foi publicado o algoritmo
Boyer-Moore (BM).
A idia pesquisar no padro no sentido da
direita para a esquerda, o que torna o
algoritmo muito rpido.
Em 1980, Horspool apresentou uma
simplificao no algoritmo original, to
eficiente quanto o algoritmo original, ficando
conhecida como Boyer-Moore-Horspool
(BMH).
Pela extrema simplicidade de implementao
e comprovada eficincia, o BMH deve ser
escolhido em aplicaes de uso geral que
necessitam realizar casamento exato de
cadeias.
35
Funcionamento do BM e BMH
O BM e BMH pesquisa o padro P em uma
janela que desliza ao longo do texto T .
Para cada posio desta janela, o algoritmo
pesquisa por um sufixo da janela que casa
com um sufixo de P , com comparaes
realizadas no sentido da direita para a
esquerda.
Se no ocorrer uma desigualdade, ento uma
ocorrncia de P em T ocorreu.
Seno, o algoritmo calcula um deslocamento
que o padro deve ser deslizado para a
direita antes que uma nova tentativa de
casamento se inicie.
O BM original prope duas heursticas para
calcular o deslocamento: ocorrncia e
casamento.
36
BM - Heurstica Ocorrncia
Alinha a posio no texto que causou a
coliso com o primeiro caractere no padro
que casa com ele;
Ex.: P ={cacbac}, T ={aabcaccacbac}.
012345678901
cacbac
aabcac cacbac
cacbac
cacbac
cacbac
cacbac
A partir da posio 5, da direita para a
esquerda, existe uma coliso na posio 3 de
T , entre b do padro e c do texto.
Logo, o padro deve ser deslocado para a
direita at o primeiro caractere no padro que
casa com c.
O processo repetido at encontrar um
casamento a partir da posio 6 de T .
37
BM - Heurstica Casamento
Ao mover o padro para a direita, faa-o casar
com o pedao do texto anteriormente casado.
Ex.: P ={cacbac} no texto T ={aabcaccacbac}.
012345678901
cacbac
aabcaccacbac
cacbac
cacbac
Novamente, a partir da posio 5, da direita
para a esquerda, existe uma coliso na
posio 3 de T , entre o b do padro e o c do
texto.
Neste caso, o padro deve ser deslocado
para a direita at casar com o pedao do
texto anteriormente casado, no caso ac,
deslocando o padro 3 posies direita.
O processo repetido mais uma vez e o
casamento entre P e T ocorre.
38
Escolha da Heurstica
O algoritmo BM escolhe a heurstica que
provoca o maior deslocamento do padro.
Esta escolha implica em realizar uma
comparao entre dois inteiros para cada
caractere lido do texto, penalizando o
desempenho do algoritmo com relao a
tempo de processamento.
Vrias propostas de simplificao ocorreram
ao longo dos anos.
As que produzem os melhores resultados so
as que consideram apenas a heurstica
ocorrncia.
39
Algoritmo Boyer-Moore-Horspool
(BMH)
A simplificao mais importante devida a
Horspool em 1980.
Executa mais rpido do que o algoritmo BM
original.
Parte da observao de que qualquer
caractere j lido do texto a partir do ltimo
deslocamento pode ser usado para enderear
a tabela de deslocamentos.
Enderea a tabela com o caractere no texto
correspondente ao ltimo caractere do
padro.
40
41
BMH - Implementao
public static void bmh ( String T, int n, String P, int m) {
/ / Pr-processamento do padro
int d[ ] = new int [maxChar] ;
for ( int j = 0; j < maxChar; j ++) d[ j ] = m;
for ( int j = 0; j < (m1); j ++) d[ ( int )P. charAt ( j ) ] = m j 1;
int i = m 1;
while ( i < n ) { / / Pesquisa
int k = i ; int j = m 1;
while ( ( j >= 0) && (T. charAt ( k) == P. charAt ( j ) ) ) { j ; k; }
i f ( j < 0)
System. out . println ( "Casamento na posicao : " + (k + 1));
i = i + d[ ( int )T. charAt ( i ) ] ;
}
}
42
43
BMHS - Implementao
O pr-processamento do padro ocorre nas
duas primeiras linhas do cdigo.
A fase de pesquisa constituda por um anel
em que i varia de m 1 at n 1, com
incrementos d[(int)T.charAt(i + 1)], o que
equivale ao endereo na tabela d do
caractere que est na i + 1-sima posio no
texto, a qual corresponde posio do ltimo
caractere de P .
public static void bmhs ( String T, int n, String P, int m) {
/ / Pr-processamento do padro
int d[ ] = new int [maxChar] ;
for ( int j = 0; j < maxChar; j ++) d[ j ] = m + 1;
for ( int j = 0; j < m; j ++) d[ ( int )P. charAt ( j ) ] = m j ;
int i = m 1;
while ( i < n ) { / / Pesquisa
int k = i ; int j = m 1;
while ( ( j >= 0) && (T. charAt ( k) == P. charAt ( j ) ) ) { j ; k; }
i f ( j < 0)
System. out . println ( "Casamento na posicao : " + (k + 1));
i = i + d[ ( int )T. charAt ( i +1)];
}
}
44
BH - Anlise
Os dois tipos de deslocamento (ocorrncia e
casamento) podem ser pr-computados com
base apenas no padro e no alfabeto.
Assim, a complexidade de tempo e de espao
para esta fase O(m + c).
O pior caso do algoritmo O(nm).
O melhor caso e o caso mdio para o
algoritmo O(n/m), um resultado excelente
pois executa em tempo sublinear.
45
BMH - Anlise
O deslocamento ocorrncia tambm pode ser
pr-computado com base apenas no padro
e no alfabeto.
A complexidade de tempo e de espao para
essa fase O(m + c).
Para a fase de pesquisa, o pior caso do
algoritmo O(nm), o melhor caso O(n/m) e
o caso esperado O(n/m), se c no
pequeno e m no muito grande.
46
BMHS - Anlise
Na variante BMHS, seu comportamento
assinttico igual ao do algoritmo BMH.
Entretanto, os deslocamentos so mais
longos (podendo ser iguais a m + 1), levando
a saltos relativamente maiores para padres
curtos.
Por exemplo, para um padro de tamanho
m = 1, o deslocamento igual a 2m quando
no h casamento.
47
Casamento Aproximado
48
Distncia de Edio
nmero k de operaes de insero,
substituio e retirada de caracteres
necessrio para transformar uma cadeia x em
outra cadeia y.
ed(P, P 0 ): distncia de edio entre duas
cadeias P e P 0 ; o menor nmero de
operaes necessrias para converter P em
P 0 , ou vice versa.
Ex.: ed(teste, estende) = 4, valor obtido por
meio de uma retirada do primeiro t de P e a
insero dos 3 caracteres nde ao final de P .
O problema do casamento aproximado de
cadeias o de encontrar todas as ocorrncias
em T de cada P 0 que satisfaz ed(P, P 0 ) k.
49
Casamento Aproximado
A busca aproximada s faz sentido para
0 < k < m, pois para k = m toda subcadeia
de comprimento m pode ser convertida em P
por meio da substituio de m caracteres.
O caso em que k = 0 corresponde ao
casamento exato de cadeias.
O nvel de erro = k/m, fornece uma medida
da frao do padro que pode ser alterado.
Em geral < 1/2 para a maioria dos casos
de interesse.
Casamento aproximado de cadeias, ou
casamento de cadeias permitindo erros:
um nmero limitado k de operaes (erros)
de insero, de substituio e de retirada
permitido entre P e suas ocorrncias em T .
A pesquisa com casamento aproximado
modelado por autmato no-determinista.
O algoritmo de casamento aproximado de
cadeias usa o paralelismo de bit.
50
51
(a)
1
(b)
(c)
52
53
54
55
56
57
R00
R1 >> 1
R10
1 0 0 0
0 0 0 0 0 0 1 0 0 0 1 0 0 0 0
1 0 0 0
0 0 0 0 0 0 1 0 0 0 1 0 0 0 0
1 0 0 0
0 0 0 0 0 0 1 0 0 0 1 0 0 0 0
1 0 0 0
1 0 0 0 0 0 1 0 0 0 1 0 0 0 0
1 1 0 0
0 1 0 0 0 0 1 0 0 0 1 1 0 0 0
1 0 1 0
0 0 1 0 0 0 1 1 0 0 1 1 1 0 0
1 0 0 1
1 0 0 1 0 0 1 1 1 0 1 0 1 1 0
1 1 0 0
0 1 0 0 1 0 1 0 1 1 1 1 0 1 1
1 0 1 0
0 0 1 0 0 0 1 1 0 1 1 1 1 0 1
1 0 0 0
0 0 0 0 0 0 1 1 1 0 1 0 1 0 0
1 0 0 0
1 0 0 0 0 0 1 0 1 0 1 0 0 1 0
1 1 0 0
0 1 0 0 0 0 1 0 0 1 1 1 0 0 1
1 0 1 0
0 0 1 0 0 0 1 1 0 0 1 1 1 0 0
1 0 0 1
1 0 0 1 0 0 1 1 1 0 1 0 1 1 0
1 1 0 0
0 0 0 0 0 0 1 0 1 1 1 0 0 1 0
1 0 0 0
0 0 0 0 0 0 1 0 0 1 1 0 0 0 0
58
R00
R1 >> 1
R10
1 0 0 0
0 0 0 0 0 0 1 0 0 0 1 0 0 0 0
1 0 0 0
0 0 0 0 0 0 1 0 0 0 1 0 0 0 0
1 0 0 0
0 0 0 0 0 0 1 0 0 0 1 0 0 0 0
1 0 0 0
1 0 0 0 0 0 1 0 0 0 1 1 0 0 0
1 1 0 0
0 1 0 0 0 0 1 1 0 0 1 1 1 0 0
1 0 1 0
0 0 1 0 0 0 1 1 1 0 1 1 1 1 0
1 0 0 1
1 0 0 1 0 0 1 1 1 1 1 1 1 1 1
1 1 0 0
0 1 0 0 1 0 1 1 1 1 1 1 1 1 1
1 0 1 0
0 0 1 0 0 0 1 1 1 1 1 1 1 1 1
1 0 0 0
0 0 0 0 0 0 1 1 1 1 1 0 1 1 0
1 0 0 0
1 0 0 0 0 0 1 0 1 1 1 1 0 1 0
1 1 0 0
0 1 0 0 0 0 1 1 0 1 1 1 1 0 1
1 0 1 0
0 0 1 0 0 0 1 1 1 0 1 1 1 1 0
1 0 0 1
1 0 0 1 0 0 1 1 1 1 1 1 1 1 1
1 1 0 0
0 0 0 0 0 0 1 1 1 1 1 1 0 1 1
1 0 0 0
0 0 0 0 0 0 1 1 0 1 1 0 0 0 0
Compresso - Motivao
Exploso de informao textual disponvel
on-line:
Bibliotecas digitais.
Sistemas de automao de escritrios.
Bancos de dados de documentos.
World-Wide Web.
Somente a Web tem hoje bilhes de pginas
estticas disponveis.
Cada bilho de pginas ocupando
aproximadamente 10 terabytes de texto
corrido.
Em setembro de 2003, a mquina de busca
Google (www.google.com.br) dizia ter mais de
3,5 bilhes de pginas estticas em seu
banco de dados.
59
60
61
Razo de Compresso
Definida pela porcentagem que o arquivo
comprimido representa em relao ao
tamanho do arquivo no comprimido.
Exemplo: se o arquivo no comprimido
possui 100 bytes e o arquivo comprimido
resultante possui 30 bytes, ento a razo de
compresso de 30%.
Utilizada para medir O ganho em espao
obtido por um mtodo de compresso.
62
63
64
65
66
67
68
69
70
1
para
1
cada
c)
4
rosa
2
0
para
0
,
6
1
uma
b)
para
cada
2
uma
para
cada
10
0
1
6
1
uma
2
0
4
rosa
f)
2
uma
d)
4
rosa
rosa
1
cada
4
rosa
2
uma
2
uma
1
cada
e)
0
para
4
rosa
4
0
2
0
para
2
1
cada
0
,
rvore de Huffman
O mtodo de Huffman produz a rvore de
codificao que minimiza o comprimento do
arquivo comprimido.
Existem diversas rvores que produzem a
mesma compresso.
Por exemplo, trocar o filho esquerda de um
n por um filho direita leva a uma rvore de
codificao alternativa com a mesma razo
de compresso.
Entretanto, a escolha preferencial para a
maioria das aplicaes a rvore cannica.
Uma rvore de Huffman cannica quando a
altura da subrvore direita de qualquer n
nunca menor que a altura da subrvore
esquerda.
71
rvore de Huffman
A representao do cdigo na forma de
rvore facilita a visualizao.
Sugere mtodos de codificao e
decodificao triviais:
Codificao: a rvore percorrida
emitindo bits ao longo de suas arestas.
Decodificao: os bits de entrada so
usados para selecionar as arestas.
Essa abordagem ineficiente tanto em
termos de espao quanto em termos de
tempo.
72
73
O Algoritmo
A entrada do algoritmo um vetor A contendo
as freqncias das palavras em ordem
no-crescente.
Freqncias relativas frase exemplo: para
cada rosa rosa, uma rosa uma
rosa
4 2 1 1 1 1
74
75
n
...
a)
Freqncias
Folha
b)
...
Prox
Raiz
...
Freqncias
Posies
dos ns folhas disponveis
...
...
Pesos dos
ns internos
ndices pais
ns internos
1 2 3
n
...
c)
Peso da
rvore
ndices pais
ns internos
76
Exemplo de processamento da
primeira fase
1 2 3 4 5 6
a)
b)
c)
d)
e)
4 2 1 1 1 1
f)
g)
h)
i)
j)
k)
4 2 1 1 1 1
4 2 1 1 1 2
4 2 1 1 1 2
4 2 1 1 2 2
4 2 1 2 2 4
4 2 1 4 4 4
4 2 2 4 4 4
4 2 6 3 4 4
4 4 6 3 4 4
10 2 3 4 4
77
1 2 3
...
a)
Peso da
rvore
ndices pais
ns internos
Prox
1 2
...
b)
n
...
c)
n
...
78
79
n
...
a)
1
...
b)
Raiz
...
n
...
Comprimento Posies
Profundidade
dos cdigos disponveis dos ns internos
1
c)
n
...
Comprimento dos cdigos
80
81
82
Cdigo Cannico
Propriedades:
1. Os comprimentos dos cdigos obedecem
ao algoritmo de Huffman.
2. Cdigos de mesmo comprimento so
inteiros consecutivos.
A partir dos comprimentos obtidos, o clculo
dos cdigos propriamente dito trivial: o
primeiro cdigo composto apenas por zeros
e, para os demais, adiciona-se 1 ao cdigo
anterior e faz-se um deslocamento
esquerda para obter-se o comprimento
adequado quando necessrio.
Codificao Cannica Obtida:
i
Smbolo
Cdigo Cannico
rosa
uma
10
para
1100
cada
1101
,t
1110
1111
83
84
8
<0
se c = 1,
base[c]
offset[c]
12
85
Obteno do cdigo:
O mtodo de codificao recebe como
parmetros o ndice i do smbolo a ser
codificado e o comprimento maxCompCod dos
vetores base e offset.
No anel while feito o clculo do
comprimento c de cdigo a ser utilizado.
A seguir, basta saber qual a ordem do cdigo
para o comprimento c (i offset[c]) e somar
esse valor base[c].
86
Exemplo de Codificao
Para a palavra i = 4 (cada):
1. Verifica-se que um cdigo de
comprimento 4.
2. Verifica-se tambm que o segundo
cdigo com esse comprimento.
3. Assim, seu cdigo 13
(4 offset[4] + base[4]), o que corresponde
a 1101 em binrio.
87
88
Exemplo de Decodificao
Decodificao da seqncia de bits 1101:
c
LeBit
Codigo
Codigo << 1
Base[c + 1]
10 or 1 = 11
10
10
110 or 0 = 110
110
110
1100 or 1 = 1101
1100
1100
89
90
91
92
93
94
...
254 ns vazios
256 elementos
256 elementos
b) rvore tima
...
...
...
254 elementos
95
96
Classe HuffmanByte
package cap8;
import java . io .;
import cap5.endaberto.TabelaHash;
import cap4. ordenacaointerna .Ordenacao;
public class HuffmanByte {
private int baseNum;
private int base [ ] , offset [ ] ;
private RandomAccessFile arqComp; / / Arquivo comprimido
private String nomeArqTxt; / / Nome do arquivo texto a ser comprimido
private String nomeArqDelim; / / Nome do arquivo que contm os delimitadores
private TabelaHash vocabulario ;
private static class Codigo {
int codigo ;
}
public HuffmanByte ( String nomeArqDelim, int baseNum, int m,
int maxTamChave) throws Exception {
this .baseNum = baseNum; this .base = null ; this . offset = null ;
this .nomeArqTxt = null ; this .nomeArqDelim = nomeArqDelim;
this . vocabulario = new TabelaHash (m, maxTamChave) ;
}
public void compressao ( String nomeArqTxt,
String nomeArqComp) throws Exception {
public void descompressao ( String nomeArqTxt,
String nomeArqComp) throws Exception {
}
97
98
99
100
Mudanas em Relao ao
Pseudocdigo Apresentado
A mudana maior est no cdigo inserido
antes da primeira fase para eliminar o
problema causado por ns internos da rvore
no totalmente preenchidos.
Na primeira fase, as baseNum rvores de
menor custo so combinadas a cada passo,
em vez de duas como no caso da codificao
binria:
Isso feito pelo anel for introduzido na
parte que atualiza freqncias na primeira
fase.
A segunda fase no sofre alteraes.
A terceira fase recebe a varivel disp para
indicar quantos ns esto disponveis em
cada nvel.
101
102
Alteraes:
1. Permitir a leitura byte a byte do arquivo
comprimido, em vez de bit a bit. em relao
ao nmero de bits que devem ser deslocados
esquerda para se encontrar o comprimento
c do cdigo, o qual indexa os vetores base e
offset.
2. O nmero de bits que devem ser deslocados
esquerda para se encontrar o comprimento
c, o qualindexa os vetores base e offset,
dado por: log2 BaseNum
103
8
<0
se c = 1,
104
105
106
107
108
109
110
111
112
113
114
115
116
Mtodo escreve
O mtodo escreve recebe o cdigo e seu
comprimento c em um objeto do tipo Codigo.
O cdigo representado por um inteiro, o que
limita seu comprimento a, no mximo, 4 bytes
em um compilador que usa 4 bytes para
representar inteiros.
Primeiramente, o mtodo escreve extrai o
primeiro byte e, caso o cdigo de Huffman
utilizado seja o de marcao (baseNum =
128), coloca a marcao no oitavo bit,
fazendo uma operao or do byte com a
constante 128.
Esse byte ento colocado na primeira
posio do vetor saida.
No anel while, caso o comprimento c do
cdigo seja maior do que um, os demais
bytes so extrados e armazenados em
saida[i], em que 2 i c.
Por fim, o vetor de bytes saida gravado em
disco no anel for.
117
118
119
120
121
Resultados Experimentais
Mostram que no existe grande degradao
na razo de compresso na utilizao de
bytes em vez de bits na codificao das
palavras de um vocabulrio.
Por outro lado, tanto a descompresso quanto
a pesquisa so muito mais rpidas com uma
codificao de Huffman usando bytes do que
uma codificao de Huffman usando bits, isso
porque deslocamentos de bits e operaes
usando mscaras no so necessrias.
Os experimentos foram realizados em uma
mquina PC Pentium de 200 MHz com 128
megabytes de RAM.
122
123
Vocabulrio
Vocab./Texto
Tam (bytes)
#Palavras
Tam (bytes)
#Palavras
Tamanho
#Palavras
262.757.554
42.710.250
1.549.131
208.005
0,59%
0,48%
Razo de
Tempo (min) de
Tempo (min) de
Compresso
Compresso
Descompresso
Huffman binrio
27,13
8,77
3,08
Huffman pleno
30,60
8,67
1,95
33,70
8,90
2,02
Gzip
37,53
25,43
2,68
Compress
42,94
7,60
6,78
Mtodo
124
Casamento Exato
Algoritmo:
Buscar a palavra no vocabulrio, podendo
usar busca binria nesta fase:
Se a palavra for localizada no vocabulrio,
ento o cdigo de Huffman com marcao
obtido.
Seno a palavra no existe no texto
comprimido.
A seguir, o cdigo pesquisado no texto
comprimido usando qualquer algoritmo para
casamento exato de padro.
Para pesquisar um padro contendo mais de
uma palavra, o primeiro passo verificar a
existncia de cada palavra do padro no
vocabulrio e obter o seu cdigo:
Se qualquer das palavras do padro no
existir no vocabulrio, ento o padro no
existir no texto comprimido.
Seno basta coletar todos os cdigos
obtidos e realizar a pesquisa no texto
comprimido.
125
126
127
128
Opcoes
\n" ) ;
\n" ) ;
\n" ) ;
\n" ) ;
\n" ) ;
imprime ( "\n" ) ;
imprime ( " Opcao: " ) ; opcao = in . readLine ( ) ;
129
Casamento Aproximado
Algoritmo:
Pesquisar o padro no vocabulrio. Neste
caso, podemos ter:
Casamento exato, o qual pode ser uma
pesquisa binria no vocabulrio, e uma
vez que a palavra tenha sido encontrada a
folha correspondente na rvore de
Huffman marcada.
Casamento aproximado, o qual pode ser
realizado por meio de pesquisa seqencial
no vocabulrio, usando o algoritmo
Shift-And.
Neste caso, vrias palavras do vocabulrio
podem ser encontradas e a folha
correspondente a cada uma na rvore de
Huffman marcada.
130
Casamento Aproximado
Algoritmo (Continuao):
A seguir, o arquivo comprimido lido byte a
byte, ao mesmo tempo que a rvore de
decodificao de Huffman percorrida
sincronizadamente.
Ao atingir uma folha da rvore:
se ela estiver marcada, ento existe
casamento com a palavra do padro.
Seja uma folha marcada ou no, o
caminhamento na rvore volta raiz ao
mesmo tempo que a leitura do texto
comprimido continua.
131
puma
uma
umas
132
133
134
135
011
roupa
010
azul
000
XXX
1XX
uma
100
rosas
011
X1X
XX1
136
k=0
k=1
k=2
k=3
Agrep
23,8 0,38
117,9 0,14
146,1 0,13
174,6 0,16
Pesquisa direta
14,1 0,18
15,0 0,33
17,0 0,71
22,7 2,23
22,1 0,09
23,1 0,14
24,7 0,21
25,0 0,49
Problemas
N P-Completo e
Algoritmos
Aproximados
Transparncias
Introduo
Problemas intratveis ou difceis so comuns
na natureza e nas reas do conhecimento.
Problemas fceis: resolvidos por algoritmos
polinomiais.
Problemas difceis: somente possuem
algoritmos exponenciais para resolv-los.
A complexidade de tempo da maioria dos
problemas polinomial ou exponencial.
Polinomial: funo de complexidade
O(p(n)), em que p(n) um polinmio.
Ex.: algoritmos com pesquisa binria
(O(log n)), pesquisa sequencial (O(n)),
ordenao por insero (O(n2 )), e
multiplicao de matrizes (O(n3 )).
Exponencial: funo de complexidade
O(cn ), c > 1.
Ex.: problema do caixeiro-viajante
(PCV) (O(n!)).
Mesmo problemas de tamanho pequeno a
moderado no podem ser resolvidos por
algoritmos no-polinomiais.
Problemas N P-Completo
A teoria de complexidade a ser apresentada
no mostra como obter algoritmos polinomiais
para problemas que demandam algoritmos
exponenciais, nem afirma que no existem.
possvel mostrar que os problemas para os
quais no h algoritmo polinomial conhecido
so computacionalmente relacionados.
Formam a classe conhecida como N P.
Propriedade: um problema da classe N P
poder ser resolvido em tempo polinomial se
e somente se todos os outros problemas em
N P tambm puderem.
Este fato um indcio forte de que dificilmente
algum ser capaz de encontrar um algoritmo
eficiente para um problema da classe N P.
Caminho em um Grafo
Considere um grafo com peso nas arestas,
dois vrtices i, j e um inteiro k > 0.
5
2
11
10
13
5
3
12
1
2
Colorao de um Grafo
Em um grafo G = (V, A), mapear C : V S,
sendo S um conjunto finito de cores tal que se
vw A ento c(v) 6= c(w) (vrtices adjacentes
possuem cores distintas).
O nmero cromtico X(G) de G o menor
nmero de cores necessrio para colorir G,
isto , o menor k para o qual existe uma
colorao C para G e |C(V )| = k.
O problema produzir uma colorao tima,
que a que usa apenas X(G) cores.
Formulao do tipo sim/no: dados G e um
inteiro positivo k, existe uma colorao de G
usando k cores?
Fcil: k = 2.
Difcil: k > 2.
Aplicao: modelar problemas de
agrupamento (clustering) e de horrio
(scheduling).
Ciclo de Hamilton
Ciclo de Hamilton: ciclo simples (passa por
todos os vrtices uma nica vez).
Caminho de Hamilton: caminho simples
(passa por todos os vrtices uma nica vez).
Exemplo de ciclo de Hamilton: 0 1 4 2 3 0.
Exemplo de caminho de Hamilton: 0 1 4 2 3.
0
1
4
Cobertura de Arestas
Uma cobertura de arestas de um grafo
G = (V, A) um subconjunto A0 A de k
arestas tal que todo v V parte de pelo
menos uma aresta de A0 .
O conjunto resposta para k = 4
A0 = {(0, 3), (2, 3), (4, 6), (1, 5)}.
0
10
Algoritmos No-Deterministas
Algoritmos deterministas: o resultado de
cada operao definido de forma nica.
Em um arcabouo terico, possvel remover
essa restrio.
Apesar de parecer irreal, este um conceito
importante e geralmente utilizado para definir
a classe N P.
Neste caso, os algoritmos podem conter
operaes cujo resultado no definido de
forma nica.
Algorimo no-determinista: capaz de
escolher uma dentre as vrias alternativas
possveis a cada passo.
Algoritmos no-deterministas contm
operaes cujo resultado no unicamente
definido, ainda que limitado a um conjunto
especificado de possibilidades.
11
Funo escolhe(C)
Algoritmos no-deterministas utilizam uma
funo escolhe(C), que escolhe um dos
elementos do conjunto C de forma arbitrria.
O comando de atribuio X escolhe (1:n)
pode resultar na atribuio a X de qualquer
dos inteiros no intervalo [1, n].
A complexidade de tempo para cada
chamada da funo escolhe O(1).
Neste caso, no existe nenhuma regra
especificando como a escolha realizada.
Se um conjunto de possibilidades levam a
uma resposta, este conjunto escolhido
sempre e o algoritmo terminar com sucesso.
Em contrapartida, um algoritmo
no-determinista termina sem sucesso se e
somente se no h um conjunto de escolhas
que indique sucesso.
12
13
Mquina No-Determinista
Uma mquina capaz de executar a funo
escolhe admite a capacidade de
computao no-determinista.
Uma mquina no-determinista capaz de
produzir cpias de si mesma quando diante
de duas ou mais alternativas, e continuar a
computao independentemente para cada
alternativa.
A mquina no-determinista que acabamos
de definir no existe na prtica, mas ainda
assim fornece fortes evidncias de que certos
problemas no podem ser resolvidos por
algoritmos deterministas em tempo
polinomial, conforme mostrado na definio
da classe N P-completo frente.
14
Pesquisa No-Determinista
Pesquisar o elemento x em um conjunto de
elementos A[1 : n], n 1.
void pesquisaND ( x , A, 1 , n) {
j escolhe (A, 1 , n) ;
i f (A[ j ] == x ) sucesso ; else insucesso ;
}
15
Ordenao No-Determinista
Ordenar um conjunto A[1 : n] contendo n
inteiros positivos, n 1.
void ordenaND (A, 1 , n) {
for ( int i = 1; i <= n ; i ++) B[ i ] = 0;
for ( int i = 1; i <= n ; i ++) {
j escolhe (A, 1 , n) ;
i f (B[ j ] == 0) B[ j ] = A[ i ] ; else insucesso ;
}
}
16
Problema da Satisfabilidade
Considere um conjunto de variveis
booleanas x1 , x2 , , xn , que podem assumir
valores lgicos verdadeiro ou falso.
A negao de xi representada por xi .
Expresso booleana: variveis booleanas e
operaes ou () e e (). (tambm chamadas
respectivamente de adio e multiplicao).
Uma expresso booleana E contendo um
produto de adies de variveis booleanas
dita estar na forma normal conjuntiva.
Dada E na forma normal conjuntiva, com
variveis xi , 1 i n, existe uma atribuio
de valores verdadeiro ou falso s variveis
que torne E verdadeira (satisfaa)?
E1 = (x1 x2 ) (x1 x3 x2 ) (x3 )
satisfatvel (x1 = F , x2 = V , x3 = V ).
A expresso E2 = x1 x1 no satisfatvel.
17
18
Problema da Satisfabilidade
O algoritmo avalND(E, n) verifica se uma
expresso E na forma normal conjuntiva, com
variveis xi , 1 i n, satisfatvel.
void avalND (E, n) {
for ( int i = 1; i <= n ; i ++) {
xi escolhe ( true , false ) ;
i f ( E(x1 , x2 , , xn ) == true ) sucesso ; else insucesso ;
}
}
19
20
N P P ou N P = P? - Conseqncias
Muitos problemas prticos em N P podem ou
no pertencer a P (no conhecemos nenhum
algoritmo determinista eficiente para eles).
Se conseguirmos provar que um problema
no pertence a P, ento temos um indcio de
que esse problema pertence a N P e que
esse problema to difcil de ser resolvido
quanto outros problemas N P.
Como no existe tal prova, sempre h
esperana de que algum descubra um
algoritmo eficiente.
Quase ningum acredita que N P = P.
Existe um esforo considervel para provar o
contrrio, mas a questo continua em aberto!
21
Transformao Polinomial
Sejam 1 e 2 dois problemas sim/no.
Suponha que um algoritmo A2 resolva 2 .
Se for possvel transformar 1 em 2 e a
soluo de 2 em soluo de 1 , ento A2
pode ser utilizado para resolver 1 .
Se pudermos realizar as transformaes nos
dois sentidos em tempo polinomial, ento 1
polinomialmente transformvel em 2 .
Dados
de 1
Dados
de 2
Transformao
Polinomial
Soluo
para 2
Algoritmo A
Soluo
para 1
Transformao
Polinomial
22
23
24
Clique de um grafo
Clique de um grafo G = (V, A) constitudo
do subconjunto V 0 V , tal que
v, w V 0 (v, w) A.
Todo par de vrtices de V 0 adjacente (V 0
um subgrafo completo).
Exemplo de cardinalidade 3: V 0 = {3, 1, 4}.
25
26
Transformao Polinomial
Considere 1 o problema clique e 2 o
problema conjunto independente de vrtices.
A instncia I de clique consiste de um grafo
G = (V, A) e um inteiro k > 0.
A instncia f (I) de conjunto independente
pode ser obtida considerando-se o grafo
complementar G de G e o mesmo inteiro k.
f (I) uma transformao polinomial:
1. G pode ser obtido a partir de G em tempo
polinomial.
2. G possui clique de tamanho k se e
somente se G possui conjunto
independente de vrtices de tamanho k.
27
Transformao Polinomial
Se existe um algoritmo que resolve o conjunto
independente em tempo polinomial, ele pode
ser utilizado para resolver clique tambm em
tempo polinomial.
Diz-se que clique conjunto independente.
Denota-se 1 2 para indicar que 1
polinomialmente transformvel em 2 .
A relao transitiva (1 2 e
2 3 1 3 ).
28
29
30
31
Teorema de Cook
Existe algum problema em N P tal que se ele
for mostrado estar em P, implicaria P = N P?
Teorema de Cook: Satisfabilidade (SAT) est
em P se e somente se P = N P.
Ou seja, se existisse um algoritmo polinomial
determinista para satisfabilidade, ento todos
os problemas em N P poderiam ser
resolvidos em tempo polinomial.
A prova considera os dois sentidos:
1. SAT est em N P (basta apresentar um
algoritmo no-determinista que execute
em tempo polinomial). Logo, se P = N P,
ento SAT est em P.
2. Se SAT est em P, ento P = N P. A
prova descreve como obter de qualquer
algoritmo polinomial no determinista de
deciso A, com entrada E, uma frmula
Q(A, E) de modo que Q satisfatvel se e
somente se A termina com sucesso para
E. O tempo necessrio para construir Q
O(p3 (n) log(n)), em que n o tamanho de
E e p(n) a complexidade de A.
32
33
34
35
1
1
1
1
5
1
1
4
36
Classe N P-Intermediria
Segunda descrio tentativa do mundo N P,
assumindo P =
6 N P.
NP
NPC
NPI
P
37
Membros Potenciais de N PI
Isomorfismo de grafos: Dados G = (V, E) e
G0 = (V, E 0 ), existe uma funo f : V V , tal
que (u, v) E (f (u), f (v)) E 0 ?
Isomorfismo o problema de testar se
dois grafos so o mesmo.
Suponha que seja dado um conjunto de
grafos e que alguma operao tenha de
ser realizada sobre cada grafo.
Se pudermos identificar quais grafos so
duplicatas, eles poderiam ser descartados
para evitar trabalho redundante.
Nmeros compostos: Dado um inteiro
positivo k, existem inteiros m, n > 1 tais que
k = mn?
Princpio da criptografia RSA: fcil
encontrar nmeros primos grandes, mas
difcil fatorar o produto de dois deles.
38
39
Problemas Exponenciais
desejvel resolver instncias grandes de
problemas de otimizao em tempo razovel.
Os melhores algoritmos para problemas
N P-completo tm comportamento de pior
caso exponencial no tamanho da entrada.
Para um algoritmo que execute em tempo
proporcional a 2N , no garantido obter
resposta para todos os problemas de
tamanho N 100.
Independente da velocidade do computador,
ningum poderia esperar por um algoritmo
que leva 2100 passos para terminar sua tarefa.
Um supercomputador poderia resolver um
problema de tamanho N = 50 em 1 hora, ou
N = 51 em 2 horas, ou N = 59 em um ano.
Mesmo um computador paralelo contendo um
milho de processadores, (sendo cada
processador um milho de vezes mais rpido
que o melhor processador que possa existir)
no seria suficiente para chegar a N = 100.
40
41
42
43
0
2
5
1 3
2
2
1
4
4
1
1
4
1
1
1
1
2
44
45
46
1 3
1
1
4
1
A rvore de caminhamento :
0
1
2
4
3
5
4
4
6
5
6
4
2
2
4
4
4
4
2
1
6
1
2
5
5
3
1
2
4
2
1
2
6
4
6
5
0
47
48
49
50
51
0
1
2
2
3
3
4
10
11
25
12
26
20
15
18
52
53
54
55
56
57
58
1 3
1
4
4
1
2
0
1
1 3
1
4
59
60
61
62
(a)
(b)
(c)
63
64
65
66
67
68
(a)
(b)
(c)
(d)
69
70
71
72
1
1
1
1
1
1
1
1
timo
1
73