Análise e Técnicas de Algoritmos Agenda Introdução Informal

Agenda
•• Introdução
IntroduçãoInformal
Informal
•• Motivação
Motivação
Análise e Técnicas de Algoritmos
Jorge Figueiredo
Visão
VisãoGeral
Geraldo
doCurso
Curso
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
Introdução Informal
Problemas Computacionais
•• O
Onosso
nosso curso
cursoéésobre
sobretécnicas
técnicaseeanálise
análisede
dealgoritmos
algoritmos
(computacionais).
(computacionais).
•• O
Oque
queééum
umalgoritmo?
algoritmo?
–– Procedimento
Procedimentocomputacional
computacional que
quetoma
toma algum
algum valor
valor
(conjunto)
(conjunto)como
comoentrada
entradaee produz
produzum
umvalor
valor (conjunto)
(conjunto)como
como
saída.
saída.
•• Qual
Qual aadiferença
diferençaentre
entrealgoritmos
algoritmoseeprogramas?
programas?
–– Idéia
Idéiaxxtexto
textodescritivo
descritivo
–– humanos
humanosxxcomputadores
computadores
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
Problemas Computacionais
Especifica
Especificaaarelação
relação entre
entre aaentrada
entradaeeaasaída
saídadesejada
desejada
Ordenação
Entrada: Uma seqüência de n números ‹a1, a2, ..., an›.
Saída: Uma reordenação da seqûëncia de entrada ‹a'1, a'2, ..., a'n›,
onde a'1 ≤ a'2 ≤ ... ≤ a'n.
Número Primo
Entrada: Uma número natural q.
Saída: sim ou não, dependendo se q é primo.
Análise e Técnicas de Algoritmos – 2007.1
© Jorge Figueiredo, DSC/UFCG
Como Descrever Algoritmos?
•• Um
Um instância
instância de
de um
um problema
problema computacional
computacionaléé um
um possível
possível
valor
valor para
paraaaentrada.
entrada.
–– ‹45,
‹45,7,
7,13,
13, 23,
23, 2›
2›ééuma
uma instância
instância para
para oo problema
problemada
da
ordenação.
ordenação.
–– 29
29ééuma
umainstância
instânciapara
paraooproblema
problemados
dos números
númerosprimos.
primos.
Análise e Técnicas de Algoritmos – 2007.1
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
© Jorge Figueiredo, DSC/UFCG
•• Utilizar
Utilizar uma
uma linguagem.
linguagem.Qual?
Qual?
–– Linguagem
Linguagemnatural
natural(português
(portuguêsou
ouinglês).
inglês).
–– Linguagem
Linguagemde
deprogramação.
programação.
•• Problemas:
Problemas:
–– Ambiguidade
Ambiguidade
–– Estruturação
Estruturação
–– Prolixidade
Prolixidade
–– Inadequação
Inadequação para
paraprogramação
programação
Análise e Técnicas de Algoritmos – 2007.1
© Jorge Figueiredo, DSC/UFCG
1
Como descrever algoritmos?
Como descrever algoritmos?
Linguagem
Natural
Código
Expressividade
Flexibilidade
Controle
Concisão
Estrutura
Formal
Linguagem
Natural
Código
Expressividade
Flexibilidade
Controle
Concisão
Estrutura
Formal
Pseudo-Código
Reduzir ambiguidade
Abstrair detalhes não importantes
Fácil de ser assimilado por humanos
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
Insertion Sort
j
1
Exemplo do Insertion Sort
n
45
A:
ORDENADO
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
7
13
23
2
chave
InsertionSort(A, n)
for j← 2 to n do
chave ← A[j]
► insere A[j] na parte ordenada A[1..j-1]
i←j–1
while i > 0 e A[i] > chave do
A[i + 1] ← A[i]
i←i–1
A[i + 1] ← chave
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
Exemplo do Insertion Sort
45
Análise e Técnicas de Algoritmos – 2007.1
7
13
23
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
Exemplo do Insertion Sort
2
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
45
7
13
23
2
7
45
13
23
2
© Jorge Figueiredo, DSC/UFCG
2
Exemplo do Insertion Sort
Exemplo do Insertion Sort
45
7
13
23
2
45
7
13
23
2
7
45
13
23
2
7
45
13
23
2
7
13
45
23
2
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
Exemplo do Insertion Sort
Exemplo do Insertion Sort
45
7
13
23
2
45
7
13
23
2
7
45
13
23
2
7
45
13
23
2
7
13
45
23
2
7
13
45
23
2
7
13
23
45
2
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
Exemplo do Insertion Sort
Análise e Técnicas de Algoritmos – 2007.1
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
Exemplo do Insertion Sort
45
7
13
23
2
45
7
13
23
2
7
45
13
23
2
7
45
13
23
2
7
13
45
23
2
7
13
45
23
2
7
13
23
45
2
7
13
23
45
2
2
7
13
23
45
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
© Jorge Figueiredo, DSC/UFCG
3
Avaliação de Algoritmos
Avaliação de Algoritmos
•• Propriedades:
Propriedades:
–– Corretude
Corretude
–– Simplicidade
Simplicidade
–– Eficiência
Eficiência
•• Corretude:
Corretude:
–– Um
Um algoritmo
algoritmo está
estácorreto
correto se
separa
paratoda
toda entrada
entrada(legal)
(legal) ele
ele
produz
produzaa saída
saídacorreta.
correta.
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
Avaliação de Algoritmos
Avaliação de Algoritmos
•• Simplicidade:
Simplicidade:
–– Benefícios
Benefíciospragmáticos:
pragmáticos:
•• Fácil
Fácilde
de ser
serentendido
entendido
•• Fácil
Fácil de
de implementar
implementar
•• Fácil
Fácil de
de manter
manter
Análise e Técnicas de Algoritmos – 2007.1
•• Eficiência
Eficiência (em
(emfunção
funçãodo
dotamanho
tamanhodo
doproblema/entrada):
problema/entrada):
–– Tempo
Tempo
•• Quanto
Quantotempo
tempoleva
levapara
paraproduzir
produzir aasaída
saídacorreta?
correta?
–– Espaço
Espaço
•• Quanto
Quantoespaço
espaçode
dememória
memóriaéé necessário?
necessário?
© Jorge Figueiredo, DSC/UFCG
Como provar a corretude de um algoritmo?
•• Não
Nãoééuma
umatarefa
tarefa simples
simples
•• Testes
Testesnão
não são
sãosuficientes:
suficientes:servem
servemapenas
apenaspara
paramostrar
mostrarque
que
um
um algoritmo
algoritmo tem
tem erros.
erros.
•• Ferramentas
Ferramentasutilizadas:
utilizadas:
–– Invariantes
Invariantesde
delaço
laço
–– Função
Funçãorecursiva
recursiva
–– Prova
Provapor
por indução
indução
Análise e Técnicas de Algoritmos – 2007.1
© Jorge Figueiredo, DSC/UFCG
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
Corretude do Insertion Sort
j
1
n
A:
ORDENADO
chave
InsertionSort(A, n)
for j← 2 to n do
chave ← A[j]
► insere A[j] na parte ordenada A[1..j-1]
i←j–1
while i > 0 e A[i] > chave do
A[i + 1] ← A[i]
i←i–1
A[i + 1] ← chave
Análise e Técnicas de Algoritmos – 2007.1
© Jorge Figueiredo, DSC/UFCG
4
Corretude do Insertion Sort
Eficiência do Insertion Sort
•• Invariante
Invariantede
delaço:
laço:
No
No início
iníciode
decada
cada iteração
iteraçãodo
dolaço,
laço,oo subarray
subarrayA[1..j-1]
A[1..j-1]
contém
contémos
oselementos
elementosoriginais
originaisde
deA[1..j-1]
A[1..j-1] mas,
mas,ordenados.
ordenados.
•• Prova:
Prova:
Inicialização
Inicialização:: j=2,
j=2,A[1..j-1]=A[1..1]=A[1],
A[1..j-1]=A[1..1]=A[1],ordenado.
ordenado.
Manutenção:
Manutenção:cada
cadaiteração
iteraçãopreserva
preservaooinvariante.
invariante.
Término:
Término:j=n+1,
j=n+1,então
entãoA[1..j-1]=A[1..n],
A[1..j-1]=A[1..n],ordenado.
ordenado.
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
Independência da Máquina
© Jorge Figueiredo, DSC/UFCG
Eficiência do Insertion Sort
custo
c1
c2
0
c4
c5
c6
c7
c8
vezes
n
n-1
n-1
n-1
∑j=2n tj
∑j=2n(tj –1)
∑j=2n(tj –1)
n –1
(tj é o número de vezes que o teste do laço na linha 5 é executado para o valor de j)
O custo total é T(n) = soma de custo × vezes em cada linha
=c1n + c2(n-1) + c4(n-1) + c5∑j=2n tj+ c6∑j=2n (tj-1)+ c7∑j=2n (tj-1)+ c8(n-1)
Análise e Técnicas de Algoritmos – 2007.1
© Jorge Figueiredo, DSC/UFCG
•• Pior
Pior caso:
caso:
–– Maior
Maior tempo
tempode
deexecução
execuçãode
deum
umalgoritmo
algoritmo para
paraqualquer
qualquer
entrada
entradade
detamanho
tamanho n.n.
–– ÉÉ ootipo
tipomais
maisutilizado.
utilizado. Todos
Todosgostam
gostamde
degarantia.
garantia.
•• Caso
Caso médio:
médio:
–– Tempo
Tempo esperado
esperado de
de um
umalgoritmo
algoritmosobre
sobre todas
todasas
asentradas
entradas
de
detamanho
tamanhon.n.
–– Necessidade
Necessidade de
deusar
usar distribuição
distribuiçãoestatística.
estatística.
•• Melhor
Melhor caso:
caso:
–– Raramente
Raramenteééfeita.
feita.
Análise e Técnicas de Algoritmos – 2007.1
© Jorge Figueiredo, DSC/UFCG
Eficiência do Insertion Sort (cont.)
•• Como
Comodeterminar
determinarootempo
tempode
deexecução?
execução?
InsertionSort(A, n)
for j ← 2 to n do
chave ← A[j]
//insere A[j] na parte ordenada A[1..j-1]
i ← j-1
while i >0 e A[i]>chave do
A[i+1] ← A[i]
i ← i-1
A[i+1] ← chave
Análise e Técnicas de Algoritmos – 2007.1
Tempo de Execução – Tipos de Análise
•• Para
Paracomparar
compararos
osdiferentes
diferentesalgoritmos,
algoritmos,de
deforma
formajusta,
justa,éé
necessário
necessáriodefinir
definir um
um modelo
modeloabstrato
abstratode
de máquina.
máquina.
•• Máquina
Máquinade
deAcesso
Acesso Aleatório:
Aleatório:
–– Um
Um único
únicoprocessador
processadorgenérico.
genérico.
–– Instruções
Instruçõesexecutadas
executadassequencialmente,
sequencialmente,sem
sem operações
operações
concorrentes.
concorrentes.
–– Memória
Memória ilimitada.
ilimitada.
–– Instrução
Instruçãobásica
básicatoma
toma uma
umaunidade
unidadede
de tempo.
tempo.
Análise e Técnicas de Algoritmos – 2007.1
•• O
Oalgoritmo
algoritmoééeficiente?
eficiente?
•• O
Otempo
tempode
deexecução
execuçãode
deum
umalgoritmo
algoritmodepende
dependeda
dacara
cara da
da
entrada.
entrada.
•• Na
Na análise
análisedo
dotempo
tempo de
deexecução,
execução,aaparametrização
parametrização éé
baseada
baseadano
notamanho
tamanhoda
daentrada.
entrada.
•• AA análise
análisedo
dotempo
tempode
deexecução,
execução,ééuma
uma forma
formade
dedefinir
definir
eficiência.
eficiência.
•• Random-Access-Model
Random-Access-Model (RAM)
(RAM)
© Jorge Figueiredo, DSC/UFCG
•• Melhor
Melhor caso:
caso:números
números já
jáordenados
ordenados
–– tj=1,
tj=1,eelinhas
linhas66ee77serão
serãoexecutadas
executadas00 vezes
vezes
–– T(n)
T(n)== c1n
c1n++c2(n-1)
c2(n-1) ++c4(n-1)
c4(n-1) ++c5(n-1)
c5(n-1) ++c8(n-1)
c8(n-1)
=(c1
=(c1++c2
c2++c4
c4 ++c5
c5++c8)n
c8)n–– (c2
(c2++ c4
c4++c5
c5++c8)
c8)==cn
cn ++c‘c‘
•• Pior
Pior caso:
caso:números
númerosem
emordem
ordeminversa
inversa
–– tj=j
tj=j
nn tj = n(n+1)/2-1 e ∑ nn(tj –1) = n(n-1)/2,
–– ∑∑j=2
j=2 tj = n(n+1)/2-1 e ∑j=2
j=2 (tj –1) = n(n-1)/2,
–– T(n)
T(n) ==c1n
c1n++ c2(n-1)
c2(n-1) ++ c4(n-1)
c4(n-1)++c5(n(n+1)/2
c5(n(n+1)/2 -1)
-1)++c6(n(nc6(n(n1)/2
1)/2-1)
-1)++ c7(n(n-1)/2)+
c7(n(n-1)/2)+ c8(n-1)
c8(n-1)
=((c5
=((c5 ++c6
c6++c7)/2)n2
c7)/2)n2+(c1
+(c1++c2
c2++c4
c4+c5/2-c6/2-c7/2+c8)n+c5/2-c6/2-c7/2+c8)n2
(c2
(c2 ++c4
c4++c5
c5++c8)
c8)== an
an2+bn+c
+bn+c
Análise e Técnicas de Algoritmos – 2007.1
© Jorge Figueiredo, DSC/UFCG
5
Eficiência do Insertion Sort (cont.)
•• Caso
Caso médio:
médio:números
números aleatórios
aleatórios
–– Na
Na média,
média,ttj j== j/2
j/2
2
–– T(n)
T(n) será
seráda
daordem
ordem de
denn2,,mesmo
mesmoque
queno
nopior
pior caso.
caso.
Análise e Técnicas de Algoritmos – 2007.1
© Jorge Figueiredo, DSC/UFCG
Ainda Sobre Análise de Algoritmos
•• AA análise
análisede
dealgoritmos
algoritmospermite
permiteooestudo
estudoteórico
teóricode
deprogramas
programas
computacionais:
computacionais:
–– Desempenho.
Desempenho.
–– Utilização
Utilizaçãode
de recursos.
recursos.
–– Corretude.
Corretude.
•• Estudo
Estudo de
de métodos,
métodos,técnicas,
técnicas,idéias,
idéias,dicas
dicas para
paradesenvolver
desenvolver
algoritmos
algoritmos(eficientes).
(eficientes).
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
Objetivos do Curso
•• Importância
Importânciado
doestudo
estudoeeanálise
análisede
dealgoritmos:
algoritmos:
–– Ajuda
Ajudano
noentendimento
entendimentode
deescalabilidade.
escalabilidade.
–– Permite
Permitedefinir
definirooque
que ééviável
viável eeooque
queééimpossível.
impossível.
–– AA matemática
matemática utilizada
utilizadaserve
serve como
comouma
uma linguagem
linguagempara
para
lidar
lidar com
comoocomportamento
comportamentode
deum
umprograma.
programa.
–– Provê
Provêmeios
meiospara
paracomparar
comparardiferentes
diferentessoluções
soluçõesde
deum
um
mesmo
mesmoproblema.
problema.
Análise e Técnicas de Algoritmos – 2007.1
© Jorge Figueiredo, DSC/UFCG
Razões para Estudar Algoritmos
Análise e Técnicas de Algoritmos – 2007.1
© Jorge Figueiredo, DSC/UFCG
Razões para Estudar Algoritmos
•• Evitar
Evitarreinventar
reinventaraaroda:
roda:
–– Existem
Existem bons
bonsalgoritmos
algoritmosque
quesolucionam
solucionam problemas
problemas
importantes.
importantes.
•• Ajudar
Ajudarno
nodesenvolvimento
desenvolvimento de
deseus
seusalgoritmos:
algoritmos:
–– Nem
Nem sempre
sempreexiste
existeum
umalgoritmo
algoritmode
deprateleira
prateleiraque
quesirva
sirva
para
pararesolver
resolver ooseu
seuproblema.
problema.
–– O
O conhecimento
conhecimentode
dealgoritmos
algoritmosbem
bemestabelecidos
estabelecidosééfonte
fonte
de
de inspiração.
inspiração.
–– Muitos
Muitosdos
dosprincípios
princípiosde
deprojetos
projetosde
dealgoritmos
algoritmossão
são úteis
úteis
em
em todos
todosos
osproblemas
problemas de
deprogramação.
programação.
Análise e Técnicas de Algoritmos – 2007.1
1.
1. Aprender
Aprenderalgoritmos
algoritmos clássicos
clássicos
2.
2. Aprender
Aprendercomo
como identificar/desenvolver
identificar/desenvolveralgoritmos
algoritmoscorretos
corretos ee
eficientes
eficientespara
para resolver
resolver um
umdeterminado
determinado
3.
3. Aprender
Aprendercomo
comoexpressar
expressaralgoritmos
algoritmos
4.
4. Aprender
Aprendercomo
como validar/verificar
validar/verificaralgoritmos
algoritmos
5.
5. Aprender
Aprendercomo
comoanalisar
analisar
6.
6. Aprender
Aprendercomo
como reutilizar
reutilizar algoritmos
algoritmos
7.
7. Aprender
Aprendercomo
comoaplicar
aplicar algoritmos
algoritmosbastante
bastante conhecidos.
conhecidos.
© Jorge Figueiredo, DSC/UFCG
•• Ajudar
Ajudaraaentender
entenderferramentas
ferramentasque
queutilizam
utilizam algoritmos
algoritmos
particulares.
particulares.
–– Por
Porexemplo,
exemplo,ferramentas
ferramentasde
decompressão
compressãode
de dados.
dados.
•• Útil
Útil conhecer
conhecer as
astécnicas
técnicasde
dealgoritmos
algoritmos empregadas
empregadas para
para
resolver
resolverdeterminadas
determinadasclasses
classesde
deproblemas.
problemas.
Análise e Técnicas de Algoritmos – 2007.1
© Jorge Figueiredo, DSC/UFCG
6
Agenda
Análise e Técnicas de Algoritmos
Jorge Figueiredo
••
••
••
••
Indução
Indução Matemática
Matemática
Corretude
Corretudede
deAlgoritmos
AlgoritmosRecursivos
Recursivos
Invariante
Invariantede
deLaços
Laços
Corretude
Corretudede
deAlgoritmos
AlgoritmosNão-Recursivos
Não-Recursivos
Corretude
Corretudede
deAlgoritmos
Algoritmos
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
Indução Matemática
Formato da Prova por Indução
•• Técnica
Técnica de
deprova
provapoderosa
poderosaeecomumente
comumenteusada
usadaem
em Ciência
Ciência
da
da Computação.
Computação.
•• Axioma
Axioma da
daIndução:
Indução:
–– Suponha
Suponhaque:
que:
•• P(0)
P(0)éétrue
true
•• ∀m
∀m ∈∈N,
N,P(m)
P(m) →
→P(m+1)
P(m+1)
–– Então:
Então:
•• ∀n
∀n ∈∈N,
N,P(n)
P(n)éé true
true
Análise e Técnicas de Algoritmos – 2007.1
© Jorge Figueiredo, DSC/UFCG
•• O
Otexto
textode
deuma
umaprova
provapor
por indução
induçãoconsiste
consistede
detrês
trêspartes:
partes:
•• Especificação
Especificaçãoda
da hipótese
hipóteseda
da indução:
indução:
•• P(n)
P(n)
•• O
O caso
casobase:
base:
•• P(0)
P(0)
•• O
Opasso
passo indutivo:
indutivo:
•• ∀m
∀m ∈∈ N,
N, P(m)
P(m)→
→P(m+1)
P(m+1)
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
Exemplo: Identidade de Gauss
Variações
•• Queremos
Queremosprovar
provarque:
que:11++22++…
…++nn==n.(n
n.(n+1)/2
+1)/2
•• Hipótese
Hipóteseda
daIndução
Indução (H.I.):
(H.I.):
–– AA própria
própria identidade
identidade
•• Variação
Variação11
–– Caso
Casobase:
base:nn==11
–– Provar
Provarque
quepara
para∀n
∀n≥≥2,
2,se
seaapropriedade
propriedadeééválida
válidapara
paran-1,
n-1,
ela
ela ééválida
válidapara
paran.
n.
•• Variação
Variação22
–– Vários
Várioscasos
casosbase:
base:nn==1,
1,22ee33
–– Provar
Provarque
quepara
para∀n
∀n≥≥4,
4,se
seaapropriedade
propriedadeééválida
válidapara
paran,
n,
ela
ela ééválida
válidapara
paran+1.
n+1.
•• Variação
Variação33 (indução
(indução forte)
forte)
–– Caso
Casobase:
base:nn==11
–– Provar
Provarque
quepara
para∀n
∀n≥≥2,
2,se
seaapropriedade
propriedadeééválida
válidapara
para
∀1≤m≤n,
∀1≤m≤n,ela
elaéé válida
válidapara
paran+1.
n+1.
–– I(n)
I(n) ==n.(n
n.(n ++1)/2
1)/2
•• Caso
Casobase:
base:
–– nn ==11
–– I(1)
I(1) ==11 ==1.(1
1.(1++1)/2
1)/2 ==11
•• Passo
Passo indutivo:
indutivo:
–– Provar
Provarque
queI(n
I(n++1)
1)== (n
(n++1).(n
1).(n++2)/2
2)/2
–– Utilizar
Utilizar aa H.I.
H.I.
Análise e Técnicas de Algoritmos – 2007.1
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
© Jorge Figueiredo, DSC/UFCG
1
Árvore Binária Completa
Triomino
•• Provar
Provarque
queuma
umaárvore
árvorebinária
bináriacompleta
completacom
comkkníveis
níveistem
tem
k
exatamente
exatamente22k ––11nós.
nós.
•• Prova:
Prova:
–– Caso
Casobase:
base:k=1.
k=1.Ok,
Ok,pois
poisnesse
nessecaso
casotem
temum
umúnico
úniconó.
nó.
k
–– H.I.:
H.I.: S(k)
S(k)==22k ––11nós.
nós.
k+1
–– Mostrar
Mostrarque
queS(k+1)=
S(k+1)= 22k+1–– 11nós.
nós.
•• Sabe-se
Sabe-seque
queS(K+1)
S(K+1) ==2.S(k)
2.S(k)++11
Análise e Técnicas de Algoritmos – 2007.1
© Jorge Figueiredo, DSC/UFCG
Corretude de Algoritmos Recursivos
••
••
••
Provar
Provarusando
usando indução.
indução.
Caso
Casobase
baseééoo caso
caso base
baseda
da recursão.
recursão.
Assumir
Assumirque
queas
as chamadas
chamadas recursivas
recursivasestão
estãocorretas,
corretas,eeusar
usar
esse
esseargumento
argumentopara
para provar
provarque
que aaexecução
execução corrente
correnteéé
correta
correta (passo
(passoindutivo).
indutivo).
Análise e Técnicas de Algoritmos – 2007.1
© Jorge Figueiredo, DSC/UFCG
••
••
••
n
Tabuleiro
Tabuleiro mxm,
mxm,em
em que
que m
méépotência
potênciade
de2,
2,ou
ou seja,
seja,m
m==22n..
Uma
das
células
do
tabuleiro
é
a
célula
especial.
Uma das células do tabuleiro é a célula especial.
Uma
Uma L-peça
L-peçaéésemelhante
semelhanteaaum
umtabuleiro
tabuleiro 2x2,
2x2,eliminando-se
eliminando-se
uma
umadas
dascélulas.
células.
•• ÉÉ possível
possívelcobrir
cobrir com
com L-peças
L-peçastodo
todoootabuleiro,
tabuleiro,com
com
exceçãoda
exceçãodacélula
célulaespecial?
especial?
Corretude de Fibonnaci Recursivo
FF00== 0,
+ F n-2
0, FF11==1,
1, ∀∀n≥2,
n≥2, FFnn==FFn-1
n-1 + Fn-2
Fib(n)
if n≤1 then
return n
else
return Fib(n – 1) + Fib(n – 2)
Maximo(n)
if n≤1 then
return A[1]
else
return max(Maximo(n – 1), A[n])
Análise e Técnicas de Algoritmos – 2007.1
© Jorge Figueiredo, DSC/UFCG
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
Invariante de Laço
Corretude de Algoritmo Recursivo
Encontrar
Encontrar oo maior
maiorvalor
valor em
emum
umarray
arrayAA de
dennelementos.
elementos.
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
•• Conceito
Conceito importante
importante que
quepode
podenos
nosajudar
ajudaraaanalisar
analisar
programas.
programas.
•• Pode
Podeser
serdefinido
definidocomo
comouma
umarelação
relaçãoentre
entreas
asvariáveis
variáveisde
deum
um
algoritmo
algoritmo(programa)
(programa) que
queééverdadeira
verdadeira nas
nas seguintes
seguintes
condições:
condições:
–– Antes
Antesdo
doinício
iníciodo
dolaço
laço
–– Durante
Duranteaa manutenção
manutençãodo
dolaço.
laço.
–– Na
Na saída
saídado
dolaço.
laço.
Análise e Técnicas de Algoritmos – 2007.1
© Jorge Figueiredo, DSC/UFCG
2
Exemplo de Invariante de Laço
Ainda sobre Laços
Algoritmo
Algoritmoque
quecalcula
calcula aasoma
somade
detodos
todos os
oselementos
elementosde
deum
um array
array
Soma(A[])
s←0
i←1
while i ≤ A.length do
s ← s + A[i]
i←i+1
return s
∀j≥0, ij = j +1, sj = A[1] +…+ A[j]
Soma(A[])
s←0
i←1
while i ≤ A.length do
s ← s + A[i]
i←i+1
return s
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
Ainda sobre Laços
© Jorge Figueiredo, DSC/UFCG
Exemplo: Derivando Laços a partir de Invariante
Considerar
Considerar aadefinição
definiçãoda
dadivisão
divisãode
deinteiros
inteirosque
querelaciona
relacionaas
as
saídas
saídasqq(quociente)
(quociente)eerr(resto)
(resto)às
àsentradas
entradasnn(número)
(número)eedd
(divisor).
(divisor). Por
Pordefinição:
definição: rr << dd ee nn == qq××dd ++r.r.
•• AA definição
definiçãoda
da divisão
divisãocorresponde
correspondeaapós-condição
pós-condiçãodo
do laço:
laço:
–– ¬G
¬G éérr <<ddeeInvariante
Invarianteéénn==qq××dd++ r.r.
–– G
Géé rr≥≥d.
d.
Análise e Técnicas de Algoritmos – 2007.1
Análise e Técnicas de Algoritmos – 2007.1
Guarda: i ≤ A.length
Variante: A.length – i + 1
© Jorge Figueiredo, DSC/UFCG
Derivando Laços a partir de Invariante
•• Um
Um laço
laçoestá
estácorreto
correto se
se as
as seguintes
seguintes55condições
condições são
são
satisfeitas:
satisfeitas:
1.
1. Início:
Início:invariante
invarianteééverdadeiro
verdadeiroantes
antesde
de entrar
entrar no
no laço.
laço.
2.
2. Invariância:
Invariância:oo corpo
corpo do
do laço
laçopreserva
preservaoo invariante.
invariante.
3.
3. Progresso:
Progresso:oo corpo
corpodo
dolaço
laço diminui
diminui aavariante.
variante.
4.
4. Limitação:
Limitação:quando
quandoaa variante
varianteatinge
atingecerto
certovalor,
valor,aaguarda
guarda
se
setorna
tornafalsa.
falsa.
5.
5. Saída:
Saída:aanegação
negaçãoda
da guarda
guardaeeoo invariante
invariantedescrevem
descrevemoo
objetivo
objetivodo
dolaço.
laço.
Análise e Técnicas de Algoritmos – 2007.1
•• Dois
Dois elementos:
elementos:
–– Guarda:
Guarda:expressão
expressãobooleana
booleanaque
que indica
indica se
se oocorpo
corpodo
do laço
laço
deve
deveou
ounão
não ser
ser executado.
executado.
–– Variante:
Variante:expressão
expressão numérica
numéricaque
que mede
medeooquanto
quantode
de
execução
execuçãoainda
aindafalta.
falta.
© Jorge Figueiredo, DSC/UFCG
PRE
►invariante verdadeiro
while G do
►invariante verdadeiro
C
►invariante verdadeiro
►¬G e invariante verdadeiro
POS
Análise e Técnicas de Algoritmos – 2007.1
© Jorge Figueiredo, DSC/UFCG
Exemplo: Derivando Laços a partir de Invariante
PRE
►n=q×d+r
while r≥d do
►n=q×d+r
C
►n=q×d+r
►¬(r≥d) e n = q × d + r
POS
Análise e Técnicas de Algoritmos – 2007.1
r←n
q←0
►n=q×d+r
while r≥d do
►n=q×d+r
r←r–d
q←q+1
►n=q×d+r
►¬(r≥d) e n = q × d + r
return q
© Jorge Figueiredo, DSC/UFCG
3
Corretude de Algoritmos Não Recursivos
•• Analisar
Analisarum
um laço
laçopor
porvez,
vez,começando
começandopelo
pelomais
maisinterno
internose
se
houver
houveraninhamento
aninhamento de
de laços.
laços.
•• Para
Paracada
cadalaço
laço determinar
determinar um
uminvariante
invariantede
de laço.
laço.
•• Provar
Provarque
queoo invariante
invariantede
delaço
laçoééválido.
válido.
•• Mostrar
Mostrarque
queooalgoritmo
algoritmotermina.
termina.
•• Usar
Usar ooinvariante
invariante de
de laço
laçopara
paraprovar
provarque
queooalgoritmo
algoritmo retorna
retornaoo
valor
valor desejado.
desejado.
•• Restringir
Restringiraaalgoritmos
algoritmos com
comum
um laço:
laço:
–– O
O valor
valordo
doidentificador
identificadorxxapós
apósaa i-ésima
i-ésima iteração
iteraçãode
deum
um
laço
laçoéé xxi i(i=0
(i=0 indica
indicaoovalor
valorde
dexx imediatamente
imediatamenteantes
antesde
de
iniciar
iniciar oo laço).
laço).
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
Corretude de Fibonnaci Não Recursivo
Fatos
Fatossobre
sobreoo algoritmo
algoritmo
Corretude de Fibonnaci Não Recursivo
FF00== 0,
+ F n-2
0, FF11==1,
1, ∀∀n≥2,
n≥2, FFnn==FFn-1
n-1 + Fn-2
Fib(n)
if n = 0 then
return 0
else
a=0
b=1
i=2
while i ≤ n do
c=a+b
a=b
b=c
i=i+1
return b
Corretude de Fibonnaci Não Recursivo
Invariante
Invariantede
delaço
laço
Fib(n)
if n = 0 then
return 0
else
a=0
b=1
i=2
while i ≤ n do
c=a+b
a=b
b=c
i=i+1
return b
i0 = 2
ij+1 = ij + 1
a0 = 0
aj+1 = bj
b0 = 1
bj+1 = cj+1
cj+1 = aj + bj
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
Fib(n)
if n = 0 then
return 0
else
a=0
b=1
i=2
while i ≤ n do
c=a+b
a=b
b=c
i=i+1
return b
Mostrar
Mostrarque
quetermina
termina ee retorna
retornaoo valor
valorcorreto
correto (b
(b ==FFnn))
Análise e Técnicas de Algoritmos – 2007.1
∀j≥0, ij = j +2, aj = Fj e bj = Fj+1
Prova por indução
Caso base: j = 0
Hipótese da Indução:
próprio invariante
Prova p/ j+1:
usando os fatos e a H.I.
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
Corretude de Fibonnaci Não Recursivo
Fib(n)
if n = 0 then
return 0
else
a=0
b=1
i=2
while i ≤ n do
c=a+b
a=b
b=c
i=i+1
return b
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
Exercício
n
Mostrar
Mostrarque
queooalgoritmo
algoritmo abaixo
abaixo computa
computa xxn..
Prova
para n = 0, OK.
Como ij+1 = ij + 1,
eventualmente i = n+1
-Assumir que ocorre depois
de t iterações: it = n+1
-i = t + 2, logo: t = n – 1
t
-Pelo invariante, b = F
t
t+1.
-Logo: b = F
t
n
-
© Jorge Figueiredo, DSC/UFCG
Potencia(x, n)
p←1
i←0
while i < n do
p ← p.x
i←i+1
return p
Análise e Técnicas de Algoritmos – 2007.1
© Jorge Figueiredo, DSC/UFCG
4
Agenda
Análise e Técnicas de Algoritmos
••
••
••
Motivação
Motivaçãopara
paraanálise
análise de
dealgoritmos
algoritmos
Análise
Análiseassintótica
assintótica
Alguns
Algunsexemplos
exemplos simples
simples
Jorge Figueiredo
Análise
Análisede
deAlgoritmos
Algoritmos
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
Introdução
Introdução
•• Dois
Dois aspectos
aspectosimportantes:
importantes:
–– Um
Um problema
problemapode,
pode, geralmente,
geralmente,ser
ser resolvido
resolvidopor
por
diferentes
diferentesalgoritmos.
algoritmos.
–– AA existência
existênciade
deum
umalgoritmo
algoritmonão
não implica,
implica,necessariamente,
necessariamente,
que
queeste
esteproblema
problemapossa
possa ser
ser resolvido
resolvidona
naprática.
prática.
•• AA análise
análisede
dealgoritmos
algoritmos pode
pode ser
serdefinida
definida como
comoooestudo
estudoda
da
estimativa
estimativade
detempo
tempo de
deexecução
execuçãode
dealgoritmos.
algoritmos.
•• O
Otempo
tempode
deexecução
execuçãoéédeterminado
determinadopelos
pelos seguintes
seguintes
aspectos:
aspectos:
–– Tempo
Tempo para
paraexecutar
executar uma
uma instrução
instruçãoou
ou passo.
passo.
–– AA natureza
naturezado
doalgoritmo.
algoritmo.
–– O
Otamanho
tamanhodo
doconjunto
conjuntode
dedados
dados que
queconstitui
constituiooproblema.
problema.
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
•• ÉÉ necessário
necessárioter
ter uma
uma forma
formade
decriar
criarmedidas
medidasde
decomparação
comparação
entre
entrealgoritmos
algoritmosque
que resolvem
resolvemum
um mesmo
mesmo problema.
problema.Desta
Desta
forma,
forma,éé possível
possíveldeterminar:
determinar:
–– AA viabilidade
viabilidadede
deum
um algoritmo.
algoritmo.
–– Qual
Qual ééoomelhor
melhoralgoritmo
algoritmopara
paraaa solução
soluçãode
deum
um
problema.
problema.
•• O
O interessante
interessante ééter
ter uma
umacomparação
comparaçãorelativa
relativaentre
entre
algoritmos.
algoritmos.
–– Assumir
Assumirque
queaaexecução
execuçãode
dequalquer
qualquerpasso
passode
deum
um
algoritmo
algoritmoleva
levauma
umaum
umtempo
tempofixo
fixo eeigual.
igual.
–– O
Otempo
tempode
deexecução
execuçãode
deum
umcomputador
computadorparticular
particular não
nãoéé
interessante.
interessante.
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
Introdução
Eficiência de Algoritmo
•• Qual
Qual aaquantidade
quantidadede
de recursos
recursosutilizados
utilizadospara
pararesolver
resolver um
um
problema?
problema?
–– Tempo
Tempo
–– Espaço
Espaço
•• Expressar
Expressarcomo
comouma
uma função
funçãodo
dotamanho
tamanhodo
doproblema.
problema.
–– Como
Comoos
os requisitos
requisitoscrescem
crescem com
comooaumento
aumentodo
doproblema?
problema?
•• Tamanho
Tamanhodo
doproblema:
problema:
–– Número
Númerode
deelementos
elementosaaser
sertratado
tratado
–– Tamanho
Tamanhodos
doselementos
elementos
Análise e Técnicas de Algoritmos – 2007.1
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
© Jorge Figueiredo, DSC/UFCG
•• Considerar
Considerar eficiência
eficiência de
detempo:
tempo:
–– Número
Númerode
deoperações
operaçõesexpresso
expresso em
emtermos
termosdo
dotamanho
tamanhoda
da
entrada.
entrada.
–– Se
dobramos
o
tamanho
da
entrada,
qual
o
tempo
de
Se dobramos o tamanho da entrada, qual o tempo de
resposta?
resposta?
•• Por
Porque
que eficiência
eficiênciaéé importante?
importante?
–– Velocidade
Velocidadede
decomputação
computação aumentou
aumentou(hardware)
(hardware)
–– Crescimento
Crescimentode
deaplicações
aplicaçõescom
comooaumento
aumentodo
dopoder
poder
computacional
computacional
–– Maior
Maior demanda
demandapor
por aumento
aumentona
navelocidade
velocidadede
decomputação.
computação.
Análise e Técnicas de Algoritmos – 2007.1
© Jorge Figueiredo, DSC/UFCG
1
Eficiência de Algoritmo
Eficiência de Algoritmo
•• Quando
Quandoaa velocidade
velocidadede
decomputação
computaçãoaumenta,
aumenta,podemos
podemos
tratar
tratar mais
maisdados?
dados?
•• Suponha
Suponhaque:
que:
2
–– Um
Um algoritmo
algoritmotoma
tomann2 comparações
comparaçõespara
paraordenar
ordenarnn
números.
números.
–– Necessitamos
Necessitamosde
de11segundo
segundopara
paraordenar
ordenar55números
números (25
(25
comparações)
comparações)
–– Velocidade
Velocidadede
decomputação
computaçãoaumenta
aumentade
de um
umfator
fator de
de100
100
–– Usando
Usando11 segundo,
segundo,podemos
podemosexecutar
executar100x25
100x25
comparações,
comparações,i.e.,
i.e.,ordenar
ordenar50
50números
números
N
T(n) = n
T(n) = nlgn
T(n) = n2
T(n) = n3
Tn = 2n
5
0.005 µs
0.01 µs
0.03 µs
0.13 µs
0.03 µs
10
0.01 µs
0.03 µs
0.1 µs
1 µs
1 µs
20
0.02 µs
0.09 µs
0.4 µs
8 µs
1 ms
50
0.05 µs
0.28 µs
2.5 µs
125 µs
13 dias
100
0.1 µs
0.66 µs
10 µs
1 ms
4 x 1013 anos
Com
Com 100
100vezes
vezesde
deganho
ganhoem
emvelocidade,
velocidade,ordenamos
ordenamosapenas
apenas10
10
vezes
vezesmais
maisnúmeros!
números!
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
Como Medir Eficiência de Algoritmo?
•• Medindo
Medindoeficiência:
eficiência:
–– Estudo
Estudo experimental
experimental e/ou
e/ouBenchmarking.
Benchmarking.
–– Análise
Análiseassintótica.
assintótica.
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
Abordagem Experimental
•Abordagem
•Abordagemexperimental:
experimental:
–Escrever
–Escrever um
umprograma
programa que
que implementa
implementa oo algoritmo
algoritmo
–Executar
–Executar ooprograma
programa com
comdiferentes
diferentescenários
cenários
–Usar
–Usar um
ummétodo
método como
como System.currentTimeMillis()
System.currentTimeMillis()para
para
obter
obter medidas
medidas acuradas
acuradasdo
dotempo
tempode
deexecução
execução real.
real.
t (ms)
60
50
40
30
20
10
0
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
Abordagem Experimental
100
n
© Jorge Figueiredo, DSC/UFCG
Análise Assintótica
•• Limitações
Limitações dos
dos estudos
estudos experimentais:
experimentais:
–– Necessidade
Necessidade de
dese
seimplementar
implementareetestar
testar ooalgoritmo.
algoritmo.
–– Experimentos
Experimentospodem
podem ser
serfeitos
feitosapenas
apenas em
emum
umnúmero
número
limitado
limitadode
decenários.
cenários.Pode,
Pode, portanto,
portanto,não
nãoindicar
indicar tempo
tempode
de
execução
em
cenários
que
não
foram
considerados
execução em cenários que não foram consideradosno
no
experimento.
experimento.
–– Para
Paracomparar
comparardois
dois algoritmos:
algoritmos:garantir
garantir os
osmesmos
mesmos
hardware
hardwareeeambiente
ambientede
desoftware.
software.
Análise e Técnicas de Algoritmos – 2007.1
50
Análise e Técnicas de Algoritmos – 2007.1
© Jorge Figueiredo, DSC/UFCG
•• Metodologia
Metodologia para
para analisar
analisar tempo
tempo de
de execução
execução de
de
algoritmos.
algoritmos.
•• Ao
Ao contrário
contrário da
da abordagem
abordagem experimental:
experimental:
–– Usa
Usa uma
umadescrição
descriçãode
dealto
altonível
níveldos
dosalgoritmos
algoritmosem
emvez
vezde
de
testar
testaruma
umade
de suas
suasimplementações.
implementações.
–– Leva
Levaem
emconsideração
consideração todas
todasas
aspossíveis
possíveis entradas.
entradas.
–– Permite
Permiteaaavaliação
avaliação de
deeficiência
eficiênciade
dealgoritmos
algoritmosde
deuma
uma
forma
forma que
que éé independente
independentedo
dohardware
hardware eeambiente
ambientede
de
software
softwareutilizado.
utilizado.
Análise e Técnicas de Algoritmos – 2007.1
© Jorge Figueiredo, DSC/UFCG
2
Notação Assintótica
Big-Oh
•Objetivo:
•Objetivo: simplificar
simplificar aaanálise
análise descartando
descartando informações
informações
desnecessárias:
desnecessárias:
–“arredondamento”
–“arredondamento”1,000,001≈1,000,000
1,000,001≈1,000,000
2
2
–Dizer
–Dizer que
que3n
3n2≈≈nn2
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
•• Sejam
Sejamduas
duasfunções
funções f(n)
f(n)eeg(n).
g(n).
–– f(n)
f(n)éé O(g(n))
O(g(n)) se
seexistem
existemconstantes
constantespositivas
positivas cceenn00tais
taisque
que
f(n)
f(n) ≤≤ cg(n)
cg(n) para
parann≥≥nn00
•• Exemplo:
Exemplo:2n
2n++10
10ééO(n)
O(n)
–– 2n
2n++10
10≤≤ cn
cn
–– (c
(c−−2)
2)nn≥≥10
10
–– nn≥≥10/(c
10/(c−−2)
2)
–– Escolher
Escolher cc==33eenn00==10
10
Big-Oh
Big-Oh
2
•Exemplo:
•Exemplo:nn2não
nãoééO(n)
O(n)
2
–n
cn
–n2≤≤cn
–n
≤
c
–n ≤ c
––AAdesigualdade
desigualdadenão
nãopode
podeser
ser
satisfeita
satisfeitapois
poisccdeve
deveser
seruma
uma
constante.
constante.
10.000
3n
2n+10
1.000
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
n
100
1.000.000
n^2
100n
100.000
10n
n
10.000
1.000
100
10
10
1
1
10
n
100
1.000
1
1
10
100
1.000
n
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
Big-Omega
Big-Theta
•• Sejam
Sejamduas
duasfunções
funções f(n)
f(n)eeg(n).
g(n).
–– f(n)
f(n)ééΩ
Ω(g(n))
(g(n)) se
seg(n)
g(n) ééO(f(n))
O(f(n))
–– Existe
≥1 tal
tal que
quef(n)
f(n)≥≥ ccg(n)
g(n)
Existe uma
uma constante
constantereal
real cc>0
>0eenn00≥1
para
parann≥≥nn00
•• Sejam
Sejam duas
duas funções
funções f(n)
f(n) ee g(n)
g(n)
Θ
(g(n))
se
f(n)
–– f(n)
é
O(g(n)) ee f(n)
f(n) éé ΩΩ(g(n))
(g(n))
f(n) é Θ(g(n)) se f(n) éé O(g(n))
–– existem
constantes
reais
a>0
e
existem constantes reais a>0 e b>0,
b>0, ee uma
uma
constante
≥1 tal
tal que
que aa g(n)
g(n) ≥≥ f(n)
f(n) ≥≥ bb g(n)
g(n)
constante inteira
inteira nn00≥1
para
para nn ≥≥ nn00
Análise e Técnicas de Algoritmos – 2007.1
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
© Jorge Figueiredo, DSC/UFCG
3
Taxas de Crescimento Mais Comum
1
log n
constante logarítmica
2n
n n2 n3 ... nk ...
2n
polinomial
exponencial
Análise Assintótica
•• AA análise
análiseassintótica
assintótica éébaseada
baseadanessas
nessas definições
definiçõesee
estabelece
estabeleceuma
umaordem
ordem relativa
relativaentre
entrefunções.
funções.
•• AA notação
notaçãoBig-Oh
Big-Ohéé usada
usadapara
paraexpressar
expressar oonúmero
númerode
de
operações
operaçõesprimitivas
primitivas executadas
executadascomo
comofunção
funçãodo
dotamanho
tamanho da
da
entrada.
entrada.
–– um
umalgoritmo
algoritmoque
queexecuta
executaem
emtempo
tempoO(n)
O(n)éémelhor
melhordo
doque
queum
umque
que
2
executa
executaem
emtempo
tempoO(n
O(n2))
–– de
deforma
formasemelhante,
semelhante,O(log
O(logn)
n)éémelhor
melhordo
doque
queO(n)
O(n)
n2
•• Cuidado!
Cuidado! Preste
Presteatenção
atençãoaa constantes
constantesmuito
muitoaltas.
altas. Um
Um
algoritmo
algoritmoque
queexecuta
executaem
emtempo
tempo 1,000,000.n
1,000,000.nééO(n),
O(n), mas
mas
2
menos
menoseficiente
eficientedo
doque
queum
umque
queexecuta
executa em
emtempo
tempo2n
2n2,,que
queéé
2
O(n
O(n2).).
n
log n
c
n
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
Complexidade de Tempo
Complexidade de Tempo
•• Para
Paradeterminar
determinarootempo
tempode
deexecução
execuçãode
deum
umdeterminado
determinado
algoritmo
algoritmo
–– descobrir
descobrir aaforma
formageral
geral da
da curva
curvaque
quecaracteriza
caracteriza seu
seutempo
tempo
de
deexecução
execuçãoem
emfunção
funçãodo
dotamanho
tamanhodo
do problema.
problema.
•• Para
Parasimplificarmos
simplificarmos aaanálise
análisede
decomplexidade
complexidadede
detempo:
tempo:
–– adotamos
adotamosaanão
nãoexistência
existênciade
deunidades
unidades de
detempo
tempo
particulares.
particulares.
–– não
nãoconsideramos
consideramostambém
tambémos
ostermos
termosde
deordem
ordeminferior,
inferior,
isto
istoé,
é,usamos
usamos Big-Oh.
Big-Oh.
•• AA complexidade
complexidadede
detempo
tempopara
paradiferentes
diferentesalgoritmos
algoritmospode
pode
indicar
indicar diferentes
diferentes classes
classesde
de complexidade.
complexidade.Cada
Cadaclasse
classeéé
caracterizada
caracterizadapor
poruma
uma família
famíliadiferente
diferente de
de curva.
curva.
•• Informalmente,
Informalmente,para
para se
se determinar
determinaraaordem
ordemde
decomplexidade
complexidade
de
deuma
umadeterminada
determinada função
funçãof(n):
f(n):
1.
1. Separar
Separarf(n)
f(n)em
emduas
duaspartes:
partes:termo
termodominante
dominanteeetermos
termos
de
deordem
ordeminferior.
inferior.
2.
2. ignorar
ignoraros
ostermos
termosde
de ordem
ordem inferior.
inferior.
3.
3. ignorar
ignoraras
asconstantes
constantesde
deproporcionalidade.
proporcionalidade.
Análise e Técnicas de Algoritmos – 2007.1
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
Análise de Algoritmos Simples
Análise de Algoritmos Simples
•• Em
Em nosso
nosso modelo
modelode
deanálise,
análise,consideramos
consideramosque
que as
as
instruções
instruçõessão
sãoexecutadas
executadas sequencialmente
sequencialmenteeeque
queooconjunto
conjunto
de
de instruções
instruções simples
simples (adição,
(adição,comparação,
comparação,atribuição,
atribuição,etc)
etc)
tomam
tomamexatamente
exatamenteuma
umaunidade
unidadede
detempo
tempopara
paraserem
serem
executadas.
executadas.
•• Tipos
Tiposde
deanálise:
análise:
Pior
Piorcaso:
caso: indica
indica oomaior
maiortempo
tempoobtido,
obtido, levando
levandoem
em
consideração
consideraçãotodas
todasas
asentradas
entradaspossíveis.
possíveis.
Melhor
Melhor caso:
caso: indica
indica oomenor
menortempo
tempoobtido,
obtido, levando
levandoem
em
consideração
consideraçãotodas
todasas
asentradas
entradaspossíveis.
possíveis.
Média:
Média: indica
indicaootempo
tempo médio
médioobtido,
obtido,considerando
considerandotodas
todas as
as
entradas
entradaspossíveis.
possíveis.
Análise e Técnicas de Algoritmos – 2007.1
© Jorge Figueiredo, DSC/UFCG
© Jorge Figueiredo, DSC/UFCG
••
Como
Comoooobjetivo
objetivoéédeterminar
determinaraaforma
formada
dacurva
curvaque
quecaracteriza
caracterizaoo
algoritmo,
algoritmo,vamos
vamosdefinir
definiralgumas
algumasregras
regrasque
quepodem
podemser
serutilizadas:
utilizadas:
Laços:
O
tempo
de
execução
de
um
laço
é
no
máximo
Laços: O tempo de execução de um laço é no máximoootempo
tempode
de
execução
das
instruções
dentro
do
laço
(incluindo
os
execução das instruções dentro do laço (incluindo ostestes)
testes)vezes
vezesoo
número
númerode
deiterações.
iterações.
Aninhamento
Aninhamentode
deLaços:
Laços:Analisar
Analisaros
osmais
maisinternos.
internos.OOtempo
tempototal
totalde
de
execução
execuçãode
deuma
umainstrução
instruçãodentro
dentrode
deum
umgrupo
grupode
delaços
laçosaninhados
aninhadoséé
ootempo
tempode
deexecução
execuçãoda
dainstrução
instruçãomultiplicado
multiplicadopelo
peloproduto
produtodos
dos
tamanhos
tamanhosde
detodos
todosos
oslaços.
laços.
Instruções
InstruçõesConsecutivas:
Consecutivas:Apenas
Apenasefetuar
efetuaraasoma.
soma.
If/Else:
If/Else:ootempo
tempode
deexecução
execuçãode
deuma
umainstrução
instruçãoif/else
if/elsenunca
nuncaéémaior
maiordo
do
que
o
tempo
de
execução
do
teste
mais
o
maior
que o tempo de execução do teste mais o maiordos
dostempos
temposde
de
execução
de
S1
e
S2.
S1
e
S2
representam
as
instruções
do
then
execução de S1 e S2. S1 e S2 representam as instruções do thenee
else,
else,respectivamente.
respectivamente.
Análise e Técnicas de Algoritmos – 2007.1
© Jorge Figueiredo, DSC/UFCG
4
Análise de Algoritmos Simples
Algumas Dicas
Chamada
Chamadade
de Funções:
Funções:AAanálise
análiseééfeita
feitacomo
comono
no caso
casode
de
laços
laçosaninhados.
aninhados.Para
Para calcular
calcularaa complexidade
complexidadede
deum
um
programa
programa com
com várias
váriasfunções,
funções,determina-se
determina-seprimeiro
primeiro aa
complexidade
complexidade de
decada
cadauma
umadas
dasfunções.
funções.Desta
Destaforma,
forma,na
na
análise,
análise, cada
cadauma
umadas
dasfunções
funçõeséévista
vistacomo
comouma
uma
instrução
instruçãocom
comaacomplexidade
complexidadeque
quefoi
foicalculada.
calculada.
Recursão:
Recursão: ÉÉaaparte
parte mais
maisdifícil
difícil da
daanálise
análise de
de complexidade.
complexidade.
Em
Em muitos
muitoscasos,
casos,pode-se
pode-sefazer
fazeraa linearização
linearizaçãoatravés
atravésda
da
substituição
substituiçãoda
dachamada
chamadarecursiva
recursivapor
poralguns
algunslaços
laços
aninhados,
por
exemplo.
Entretanto,
existem
algoritmos
aninhados, por exemplo. Entretanto, existem algoritmos
que
que não
não possibilitam
possibilitam aa linearização.
linearização. Nestes
Nestes caso,
caso,éé
necessário
necessáriousar
usar uma
uma relação
relaçãode
de recorrência
recorrênciaque
quetem
temque
que
ser
ser resolvida.
resolvida.
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
••
••
••
••
••
Identificar
Identificaraaoperação
operaçãofundamental
fundamentalusada
usadano
noalgoritmo.
algoritmo.AAanálise
análisedessa
dessa
operação
operaçãofundamental
fundamentalidentifica
identificaootempo
tempode
deexecução.
execução.Isso
Issopode
podeevitar
evitaraa
análise
linha-por-linha
do
algoritmo.
análise linha-por-linha do algoritmo.
Quando
Quandoum
umalgoritmo,
algoritmo,em
emuma
umapassada
passadade
deuma
umaiteração,
iteração,divide
divideoo
conjunto
conjuntode
dedados
dadosde
deentrada
entradaem
emuma
umaou
oumais
maispartes,
partes,tomado
tomadocada
cadauma
uma
dessas
dessaspartes
parteseeprocessando
processandoseparada
separadaeerecursivamente,
recursivamente,eedepois
depois
juntando
juntandoos
osresultados,
resultados,este
estealgoritmo
algoritmoéépossivelmente
possivelmenteO(n.log
O(n.logn)
n)
Um
Umalgoritmo
algoritmoééO(log
O(logn)
n)se
seele
eleleva
levatempo
tempoconstante
constantepara
parareduzir
reduziroo
tamanho
tamanhodo
doproblema,
problema,geralmente
geralmentepela
pelametade.
metade.Por
Porexemplo,
exemplo,aapesquisa
pesquisa
binária.
binária.
Se
o
algoritmo
leva
tempo
constante
para
reduzir
o
tamanho
do
problema
Se o algoritmo leva tempo constante para reduzir o tamanho do problema
em
emum
umtamanho
tamanhoconstante,
constante,ele
eleserá
seráO(n).
O(n).
Algoritmos
Algoritmoscombinatoriais
combinatoriaissão
sãoexponenciais.
exponenciais.Por
Porexemplo,
exemplo,ooproblema
problemado
do
caixeiro
caixeiroviajante.
viajante.
Análise e Técnicas de Algoritmos – 2007.1
© Jorge Figueiredo, DSC/UFCG
Exercício
Qual
Qual aacomplexidade
complexidadedo
doalgoritmo
algoritmoabaixo?
abaixo?
Potencia(x, n)
p←1
i←0
while i < n do
p ← p.x
i←i+1
return p
Análise e Técnicas de Algoritmos – 2007.1
© Jorge Figueiredo, DSC/UFCG
5
Agenda
Análise e Técnicas de Algoritmos
Jorge Figueiredo
•• Relação
Relaçãode
de Recorrência
Recorrência
–– Derivando
Derivando recorrência
recorrência
–– Resolvendo
Resolvendorecorrência
recorrência
•• Análise
Análisede
dealgoritmos
algoritmos recursivos
recursivos
Análise
Análisede
deAlgoritmos
Algoritmos Recursivos
Recursivos
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
Introdução
Introdução
•• AA análise
análisede
deum
um algoritmo
algoritmorecursivo
recursivo requer
requer aaresolução
resoluçãode
de
uma
uma recorrência.
recorrência.
•• Uma
Uma recorrência
recorrência ééum
um algoritmo
algoritmo recursivo
recursivo que
que calcula
calculaoovalor
valor
de
deuma
umafunção
funçãoem
emum
um ponto
pontodado.
dado.
•• Uma
Uma recorrência
recorrênciadefine
defineT(n)
T(n)em
emtermos
termosde
deT(n-1),
T(n-1),T(n-2),
T(n-2), etc.
etc.
•• Exemplo:
Exemplo:
–– T(1)
T(1)==11
–– T(n)
T(n)==T(n
T(n––1)
1)++3n
3n ++22,,para
paran≥2
n≥2
•• Exemplo
Exemplo2:
2:Quantos
Quantos pedaços
pedaçoscom
comnncortes?
cortes?
Cortes: 1
Pedaços: 2
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
Introdução
Introdução
•• Exemplo
Exemplo2:
2:Quantos
Quantos pedaços
pedaçoscom
comnncortes?
cortes?
Cortes: 1
Pedaços: 2
Análise e Técnicas de Algoritmos – 2007.1
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
•• Exemplo
Exemplo2:
2:Quantos
Quantos pedaços
pedaçoscom
comnncortes?
cortes?
Cortes: 2
Pedaços: 4
Cortes: 1
Pedaços: 2
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
Cortes: 2
Pedaços: 4
Cortes: 3
Pedaços: 7
Cortes: 4
Pedaços: 11
© Jorge Figueiredo, DSC/UFCG
1
Introdução
Derivando Relações de Recorrências
•• ÉÉ possível
possívelobservar
observar que
que oo n-ésimo
n-ésimo corte
corte cria
cria nn novos
novos pedaços.
pedaços.
•• Logo,
Logo,oonúmero
númerototal
total de
de pedaços
pedaços obtido
obtido com
com nn cortes,
cortes,
denotado
denotado por
porP(n),
P(n),éé dado
dado pela
pela seguinte
seguinte relação
relaçãode
de
recorrência:
recorrência:
–– P(1)
P(1) ==22
–– P(n)
P(n) ==P(n
P(n––1)
1) ++n,
n, para
paran≥2
n≥2
Análise e Técnicas de Algoritmos – 2007.1
© Jorge Figueiredo, DSC/UFCG
Derivando Relações de Recorrências
•• T(n)
T(n)éédefinido
definido como
como uma
uma soma
somade
de várias
várias ocorrências
ocorrênciasde
deT(m)
T(m)
(chamadas
(chamadasrecursivas),
recursivas),mais
maisaa soma
somade
deoutras
outrasinstruções
instruções
efetuadas.
efetuadas.Em
Emgeral,
geral,as
as chamadas
chamadas recursivas
recursivasestão
estão
relacionadas
relacionadascom
comaa subproblemas
subproblemasdo
domesmo
mesmotamanho
tamanhof(n),
f(n),
definindo
definindo um
umtermo
termo a.T(f(n))
a.T(f(n)) na
na relação
relação de
de recorrência.
recorrência.
•• AA relação
relação de
de recorrência
recorrência éédefinida
definida por:
por:
–– T(n)
T(n)==c,
c,se
senn==nn00
–– T(n)
T(n)==a.T(f(n))
a.T(f(n))++g(n),
g(n), caso
casocontrário
contrário
Análise e Técnicas de Algoritmos – 2007.1
© Jorge Figueiredo, DSC/UFCG
Derivando Relações de Recorrências
Hanoi(A, C, B, n)
if n > 1
Hanoi(A, B, C, n-1)
Move(A, C)
if n > 1
Hanoi(B, C, A, n-1)
Relação de Recorrência
T(1) = 1
T(n) = 2.T(n-1) + 1
Como
Comoproceder
procederpara
para derivar
derivaruma
uma relação
relaçãode
derecorrência
recorrênciapara
paraaa
análise
análisedo
dotempo
tempode
de execução
execuçãode
deum
umalgoritmo:
algoritmo:
•• Determinar
Determinarqual
qualootamanho
tamanhonndo
doproblema.
problema.
•• Verificar
Verificarque
que valor
valorde
dennééusado
usadocomo
comobase
baseda
darecursão.
recursão.Em
Em
geral
geralééum
umvalor
valorúnico
único (n=1,
(n=1,por
porexemplo),
exemplo), mas
maspode
podeser
ser
valores
múltiplos.
Vamos
considerar
esse
valor
como
n
.
valores múltiplos. Vamos considerar esse valor como n00.
•• Determinar
Determinar T(n
T(n00).).Pode-se
Pode-seusar
usar uma
uma constante
constante c,
c, mas,
mas,em
em
muitos,
muitos, casos
casos um
umnúmero
númeroespecífico
específicoéénecessário.
necessário.
Análise e Técnicas de Algoritmos – 2007.1
© Jorge Figueiredo, DSC/UFCG
Derivando Relações de Recorrências
•• Exemplo:
Exemplo:Torre
Torrede
deHanoi
Hanoi
–– Objetivo:
Objetivo:transferir
transferiros
osnn discos
discosde
deAApara
para CC
–– Regras:
Regras:
•• Mover
Moverum
umdisco
discopor
por vez.
vez.
•• Nunca
Nuncacolocar
colocarum
umdisco
disco maior
maiorem
em cima
cima de
deum
um menor.
menor.
–– Solução
SoluçãoRecursiva:
Recursiva:
•• Transferir
Transferir n-1
n-1discos
discos de
deAApara
paraBB
•• Mover
Moveroo maior
maior disco
disco de
deAApara
paraCC
•• Transferir
Transferir n-1
n-1discos
discos de
deBBpara
paraCC
Análise e Técnicas de Algoritmos – 2007.1
© Jorge Figueiredo, DSC/UFCG
Derivando Relações de Recorrências
MergeSort(A, n)
if n ≤ 1
return A
return merge(MergeSort(A1, n/2), MergeSort(A2, n/2))
Relação de Recorrência
T(1) = c
T(n) = 2.T(n/2) + d.n
Análise e Técnicas de Algoritmos – 2007.1
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
© Jorge Figueiredo, DSC/UFCG
2
Resolvendo Relações de Recorrência
•• Resolver
Resolveruma
umarelação
relaçãode
derecorrência
recorrêncianem
nem sempre
sempreééfácil.
fácil.
•• Resolvendo
Resolvendouma
uma relação
relaçãode
derecorrência,
recorrência,determina-se
determina-seoo
tempo
tempode
deexecução
execução do
doalgoritmo
algoritmo recursivo
recursivo correspondente.
correspondente.
•• Relação
Relaçãode
de recorrência:
recorrência:T(n)
T(n)==T(n
T(n11)) ++T(n
T(n22))+...+
+...+T(n
T(naa)) ++f(n)
f(n)
•• ÉÉ mais
maisfácil
fácil quando
quando temos
temosaasubproblemas
subproblemasde
demesmo
mesmo
tamanho
tamanhoque
queééuma
uma fração
fraçãode
denn(por
(porexemplo,
exemplo,n/b):
n/b):
–– T(n)
T(n)==a.T(n/b)
a.T(n/b)++f(n)
f(n)
•• Como
Como resolver:
resolver:
–– Método
Métododo
do chute
chute
–– Método
Métododa
da árvore
árvorede
de recursão
recursão
–– Método
Métododo
do desdobramento
desdobramento
–– Método
Métodomaster
master
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
Método do Chute e Prova por Indução
•• Seja
Sejaaaseguinte
seguinterelação
relaçãode
derecorrência:
recorrência:
–– T(1)
T(1)==11
–– T(n)
=
2.T(n/2)
+
n
,
para
T(n) = 2.T(n/2) + n , paran≥2
n≥2
•• AArelação
relaçãode
derecorrência
recorrênciaééresolvida
resolvidaem
emduas
duaspartes:
partes:
1.
1. Chute:
Chute:T(n)
T(n)==nn++n.logn
n.logn
2.
2. Prova:
Prova:
1.
1. Caso
Casobase:
base:11++1.log
1.log11==11
2.
2. H.I.:
H.I.:assumir
assumirque
queééválido
válidopara
paravalores
valoresaté
atén-1
n-1
3.
3. Provar
ProvarT(n):
T(n):
•• =2.(n/2
=2.(n/2++n/2.log
n/2.logn/2)
n/2)++nn
•• =n
=n++n.(logn
n.(logn-1)
-1)++nn
•• =n
=n++n.logn
n.logn
Logo,
Logo,T(n)
T(n)ééO(n.logn)
O(n.logn)
•• Seja
Sejaaaseguinte
seguinterelação
relaçãode
derecorrência:
recorrência:
–– T(1)
T(1)==11
–– T(n)
T(n)==T(n
T(n––1)
1)++3n
3n++22,,para
paran≥2
n≥2
•• AArelação
relaçãode
derecorrência
recorrênciaééresolvida
resolvidaem
emduas
duaspartes:
partes:
2
1.
/2++7n/2
7n/2––44
1. Chute:
Chute:T(n)
T(n)==3n
3n2/2
2.
2. Prova:
Prova:
1.
1. Caso
Casobase
baseéépara
paran=1
n=1
2.
2. H.I.:
H.I.:assumir
assumirque
queééválido
válidopara
paran-1
n-1
3.
3. Provar
ProvarT(n)
T(n)
2
Se
Seaaprova
provafor
forconfirmada,
confirmada,T(n)
T(n)ééO(n
O(n2))
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
Método da Árvore de Recursão
•• Talvez
Talvezoométodo
método mais
mais intuitivo.
intuitivo.
•• Consiste
Consisteem
em desenhar
desenharuma
umaárvore
árvorecujos
cujosnós
nósrepresentam
representam os
os
tamanhos
tamanhosdos
doscorrespondentes
correspondentesproblemas.
problemas.
•• Cada
Cadanível
nível iicontém
contém todos
todosos
os subproblemas
subproblemasde
de profundidade
profundidade i.i.
•• Dois
Dois aspectos
aspectosimportantes:
importantes:
–– AA altura
alturada
daárvore.
árvore.
–– O
Onúmero
númerode
depassos
passosexecutados
executadosde
decada
cadanível.
nível.
•• AA solução
soluçãoda
darecorrência
recorrência(tempo
(tempode
deexecução
execuçãodo
doalgoritmo)
algoritmo) éé
aa soma
somade
detodos
todosos
os passos
passosde
detodos
todosos
osníveis.
níveis.
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
Método do Chute e Prova por Indução
Método da Árvore de Recursão
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
Método da Árvore de Recursão
•• Resolver
ResolverT(n)
T(n)== 2.T(n/2)
2.T(n/2)++nn
T(n)
n
T(n/2)
Análise e Técnicas de Algoritmos – 2007.1
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
T(n/2)
© Jorge Figueiredo, DSC/UFCG
3
Método da Árvore de Recursão
Método da Árvore de Recursão
n
n
n/2
T(n/4)
n/2
T(n/4) T(n/4)
n/2
T(n/4)
n/4
n/2
n/4
n/4
n/4
T(1)
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
Método da Árvore de Recursão
Método da Árvore de Recursão
n
n
n
n/2
n/2
n/2
h = log n
n/2
h = log n
n/4
n/4
n/4
n/4
n/4
1
n/4
n/4
n/4
1
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
Método da Árvore de Recursão
Método da Árvore de Recursão
n
n
n/2
2.n/2= n
n/2
h = log n
n
n
n/2
2.n/2= n
n/2
h = log n
n/4
n/4
n/4
n/4
n/4
1
Análise e Técnicas de Algoritmos – 2007.1
n/4
n/4
n/4
4.n/4= n
1
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
© Jorge Figueiredo, DSC/UFCG
4
Método da Árvore de Recursão
n
n
n/2
1
n/4
n/4
n/4
n folhas
4.n/4= n
n.1= n
n
n
2.n/2= n
n/2
h = log n
n/4
Método da Árvore de Recursão
n/2
2.n/2= n
n/2
h = log n
n/4
1
n/4
n/4
n/4
n folhas
4.n/4= n
n.1= n
(log n).n
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
Método do Desdobramento
Método do Desdobramento – Exemplo 1
•• Esse
Essemétodo
métodoééooda
da árvore
árvorede
derecursão,
recursão, representado
representadode
de
forma
formaalgébrica.
algébrica.
•• Consiste
Consisteem:
em:
–– Usar
Usar (algumas
(algumaspoucas)
poucas) substituições
substituiçõesrepetidamente
repetidamenteaté
até
encontrar
encontrar um
umpadrão.
padrão.
–– Escrever
Escrever uma
umafórmula
fórmula em
emtermos
termosde
de nn eeoonúmero
númerode
de
substituições
substituições i.i.
–– Escolher
Escolher ii de
detal
talforma
forma que
quetodas
todasas
as referências
referênciasaa T()
T()
sejam
sejam referências
referênciasao
aocaso
caso base.
base.
–– Resolver
Resolveraafórmula.
fórmula.
Análise e Técnicas de Algoritmos – 2007.1
© Jorge Figueiredo, DSC/UFCG
•• Solução
Soluçãopara
paraooproblema
problemada
dapizza:
pizza:
–– T(1)
T(1)==22
–– T(n)
=
T(n
–
1)
+
n
,
para
n≥2
T(n) = T(n – 1) + n , para n≥2
•• Desdobrando
Desdobrandoaarelação
relaçãode
derecorrência:
recorrência:
T(n)
T(n)==T(n-1)
T(n-1)++nn
T(n)
T(n)==T(n-2)
T(n-2)++(n-1)
(n-1)++nn
T(n)
T(n)==T(n-3)
T(n-3)++(n-2)
(n-2)++(n-1)
(n-1)++nn
...
...
T(n)
T(n)==T(n-i)
T(n-i)++(n-i+1)
(n-i+1)++...
...++(n-1)
(n-1)++nn
•• Caso
Casobase
basealcançado
alcançadoquando
quandoi=n-1
i=n-1
•• T(n)
T(n)==22++22++33++...
...++(n
(n––1)
1)++nn
•• T(n)
=
1
+
n.(n-1)/2
T(n) = 1 + n.(n-1)/2
2
•• Logo,
Logo,T(n)
T(n)==O(n
O(n2))
•• Solução
Soluçãopara
paraooproblema
problemada
daTorre
Torrede
deHanoi:
Hanoi:
–– T(1)
T(1)==11
–– T(n)
T(n)==2.T(n
2.T(n––1)
1)++11,,para
paran≥2
n≥2
•• Desdobrando
Desdobrandoaarelação
relaçãode
derecorrência:
recorrência:
T(n)
T(n)==2.T(n
2.T(n––1)
1)++11
T(n)
T(n)==2.(2.T(n-2)
2.(2.T(n-2)++1)
1)++11==4.T(n-2)
4.T(n-2)++22++11
T(n)
T(n)==4.(2.T(n-3)
4.(2.T(n-3)++1)
1)++22++11==8.T(n-3)
8.T(n-3)++44++22++11
...
...
ii
i-1
i-2
1
T(n)
.T(n-i)++22i-1++22i-2...
...++221++11
T(n)==22.T(n-i)
•• Caso
Casobase
basealcançado
alcançadoquando
quandoi=n-1
i=n-1
n-1
n-2
n-3
1
•• T(n)
...++221++11
T(n)==22n-1++22n-2++22n-3++...
•• Isso
Issoééuma
umasoma
somageométrica
geométrica
n
n
•• Logo,
O(2n))
Logo,T(n)
T(n)==22n––11==O(2
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
Método do Desdobramento – Exemplo 2
Análise e Técnicas de Algoritmos – 2007.1
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
Método Master
•• Teorema
Teoremaque
que resolve
resolvequase
quasetodas
todasas
asrecorrências.
recorrências.
•• T(n)
T(n)da
daforma
forma a.T(n/b)
a.T(n/b)++f(n),
f(n),a,b
a,b>>11
•• Casos:
Casos:
logaab- ε
1.
paraalgum
algumεε >>0,
0,temos
temosque:
que:
1. Se
Sef(n)
f(n)∈∈O(n
O(nlog b- ε),), para
logaab
•• T(n)
T(n)∈∈ Θ(n
Θ(nlog b).).
a
log ab
2.
2. Se
Sef(n)
f(n)∈∈ Θ(n
Θ(nlog b),), temos
temosque:
que:
logaab
•• T(n)
∈
Θ(n
T(n) ∈ Θ(nlog b.log
.logn).
n).
logaab + ε
3.
3. Se
Sef(n)
f(n)∈∈Ω(n
Ω(nlog b + ε),), para
paraalgum
algumεε>>00ee se
se a.f(n/b)≤c.f(n)
a.f(n/b)≤c.f(n)
para
paraalgum
algumcc>>00eenn suficientemente
suficientementegrande,
grande,temos
temosque:
que:
•• T(n)
T(n)∈∈ Θ(f(n)).
Θ(f(n)).
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
© Jorge Figueiredo, DSC/UFCG
5
Método Master – Exemplo 1
Método Master – Exemplo 2
•• MergeSort:
MergeSort:
–– T(n)
T(n)==2.T(n/2)
2.T(n/2)++nn
–– aa ==bb==22
–– f(n)
f(n) ==nn
a
•• log
logabb == 1.
1. Cai
Cai no
no caso
caso2.
2.
•• Logo,
Logo,T(n)
T(n)== Θ(n.log
Θ(n.log n)
n)
Análise e Técnicas de Algoritmos – 2007.1
•• T(n)
T(n)==9.T(n/3)
9.T(n/3)++nn
–– aa ==9,
9, bb==33
–– f(n)
f(n) ==nn
a
•• log
2.Se
Seεε==1,
1,Cai
Cai no
nocaso
caso1.
1.
logabb == 2.
2
•• Logo,
Logo,T(n)
T(n)== Θ(n
Θ(n2))
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
© Jorge Figueiredo, DSC/UFCG
6
Agenda
Análise e Técnicas de Algoritmos
Jorge Figueiredo
•• Ordenação
Ordenaçãobaseada
baseada em
emcomparação
comparação
–– Insertion
InsertionSort
Sort
–– Mergesort
Mergesort
–– Quicksort
Quicksort
•• Ordenação
Ordenaçãoem
emtempo
tempo linear
linear
Análise
Análisede
deAlgoritmos
Algoritmosde
deOrdenação
Ordenação
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
Problema da Ordenação
Estratégia de Ordenação
Formalmente
Formalmentepode
podeassim
assim ser
serdefinido:
definido:
Ordenação
Entrada: Uma seqüência de n números ‹a1, a2, ..., an›.
Saída: Uma reordenação da seqûëncia de entrada ‹a'1, a'2, ..., a'n›,
onde a'1 ≤ a'2 ≤ ... ≤ a'n.
Em geral, consideramos a seqüência de entrada como um array de
n elementos.
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
•• Alguns
Algunsalgoritmos
algoritmosclássicos
clássicosde
de ordenação
ordenaçãoutilizam
utilizam divisão-edivisão-econquista:
conquista:
–– Quebra
Quebraaaentrada
entradaoriginal
original em
emduas
duaspartes.
partes.
–– Recursivamente
Recursivamenteordena
ordena cada
cadauma
umadas
das partes.
partes.
–– Combina
Combinaas
asduas
duaspartes
partesordenadas.
ordenadas.
•• Duas
Duascategorias
categoriasde
desoluções:
soluções:
–– Quebra
Quebrasimples,
simples, combinação
combinaçãodifícil.
difícil.
–– Quebra
Quebradifícil,
difícil, combinação
combinaçãosimples.
simples.
j
Análise do Insertion Sort
n
A:
ORDENADO
chave
InsertionSort(A, n)
for j← 2 to n do
chave ← A[j]
► insere A[j] na parte ordenada A[1..j-1]
i←j–1
while i > 0 e A[i] > chave do
A[i + 1] ← A[i]
i←i–1
A[i + 1] ← chave
Análise e Técnicas de Algoritmos – 2007.1
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
Insertion Sort
1
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
© Jorge Figueiredo, DSC/UFCG
•• Pior
Pior caso:
caso:
–– Entrada
Entrada em
emordem
ordemreversa.
reversa.
2
–– O(n
O(n2))
•• Caso
Caso médio:
médio:
2
–– O(n
O(n2))
•• Melhor
Melhor caso:
caso:
–– Entrada
Entrada ordenada.
ordenada.
–– O(n)
O(n)
Análise e Técnicas de Algoritmos – 2007.1
© Jorge Figueiredo, DSC/UFCG
1
MergeSort
Análise do MergeSort
•• Partição
Partiçãosimples.
simples.
•• Combinação
Combinaçãomais
maistrabalhosa.
trabalhosa.
3
72
1
5
47 34 20 10
9
23
34 20 10
9
•• Requer
Requer resolução
resoluçãode
de recorrência.
recorrência.
•• Melhor
Melhor caso
caso==Caso
Caso médio
médio==Pior
Pior caso.
caso.
–– O(n.logn)
O(n.logn)
simples
quebra
3
72
1
5
47
1
3
5
47 72
23
ordena
9
10 20 23 34
combina
1
3
5
9
MergeSort(A, inicio, fim)
if inicio < fim then
meio ← (inicio + fim) div 2
MergeSort(A, inicio, meio)
MergeSort(A, meio + 1, fim)
Intercala(A, inicio, meio, fim)
difícil
10 20 23 34 47 72
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
QuickSort
QuickSort
•• Proposto
Propostopor
por C.A.R.
C.A.R. Hoare
Hoareem
em1962.
1962.
•• Como
Comooo MergeSort,
MergeSort, utiliza
utiliza uma
umaestratégia
estratégia de
dedivisão-edivisão-econquista.
conquista.
•• AA parte
parte mais
mais complicada
complicadaééaaquebra.
quebra.
•• AA combinação
combinação éésimples.
simples.
•• Ao
Aocontrário
contráriodo
doMergeSort,
MergeSort,ordena
ordena in
inplace.
place.
•• Ponto
Pontochave
chaveééencontrar
encontrar uma
umaestratégia
estratégia de
departicionamento
particionamento
eficiente.
eficiente.
•• Divisão:
Divisão:escolher
escolherum
umpivô.
pivô.Dividir
Dividirooarray
arrayem
emduas
duaspartes
partesem
em
torno
torno do
do pivô.
pivô.
•• Conquista:
Conquista: Recursivamente
Recursivamenteordenar
ordenar os
os dois
dois sub-arrays.
sub-arrays.
•• Combinação:
Combinação:Trivial.
Trivial.
≤≤pp
pp
>>pp
pivô
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
Escolha do Pivô
QuickSort
3
72
1
5
47 34 20 10
9
23
difícil
quebra
3
20
1
5
10
9
23
1
3
5
9
10 20 23
47 34 72
ordena
34 47 72
combina
1
3
Análise e Técnicas de Algoritmos – 2007.1
5
9
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
•• Particionamento
Particionamentopode
podeser
serfeito
feitode
dediferentes
diferentesformas.
formas.
•• AA principal
principaldecisão
decisãoéé escolher
escolher oopivô.
pivô.
–– Primeiro
Primeiro elemento
elementodo
doarray.
array.
–– Último
Último elemento
elementodo
do array.
array.
–– Elemento
Elementomédio
médiodo
doarray.
array.
–– Elemento
Elementoque
quemais
maisocorre
ocorre no
noarray.
array.
–– Elemento
Elementomais
maispróximo
próximo da
da média
médiaaritmética
aritméticados
doselementos
elementos
do
doarray.
array.
simples
10 20 23 34 47 72
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
© Jorge Figueiredo, DSC/UFCG
2
Rotina de Particionamento
Exemplo de Particionamento
•• Em
Emnossa
nossarotina,
rotina,oopivô
pivôééooúltimo
últimoelemento.
elemento.
Particiona(A, L, R)
p ← A[R]
i←R
for j ← R – 1 downto L do
if A[j] > p then
i←i–1
swap A[i] ↔ A[j]
swap A[R] ↔ A[i]
return i
3
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
72
72
1
5
47 34 20 10
9
j
3
© Jorge Figueiredo, DSC/UFCG
72
72
Análise e Técnicas de Algoritmos – 2007.1
1
5
47 34 20 10
j ←
9
9
23
© Jorge Figueiredo, DSC/UFCG
1
5
47 34 20 10 9
j ←
23
i
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
Exemplo de Particionamento
3
47 34 20 10
Exemplo de Particionamento
23
i
Análise e Técnicas de Algoritmos – 2007.1
5
Análise e Técnicas de Algoritmos – 2007.1
Exemplo de Particionamento
3
1
Exemplo de Particionamento
23
i
3
© Jorge Figueiredo, DSC/UFCG
72
Análise e Técnicas de Algoritmos – 2007.1
1
5
47 34 20 10
j ←
9
23
i
© Jorge Figueiredo, DSC/UFCG
3
Exemplo de Particionamento
3
72
1
5
47 34 20 10
j
9
Exemplo de Particionamento
23
i
3
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
72
72
1
5
47 34 20 10
3
72
1
5
47 9
j ←
9
47 34 20 10
j
Exemplo de Particionamento
23
3
72
1
5
47 34 20 10
3
72
1
5
47
j
© Jorge Figueiredo, DSC/UFCG
72
1
5
47 34 20 10
3
72
1
5
47
3
72
1
5 10
j ←
9
9
9
23
20 10 34 23
i ←
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
Exemplo de Particionamento
3
9 23
i ←
© Jorge Figueiredo, DSC/UFCG
20 10 34 23
i
Análise e Técnicas de Algoritmos – 2007.1
Análise e Técnicas de Algoritmos – 2007.1
5
Análise e Técnicas de Algoritmos – 2007.1
Exemplo de Particionamento
3
1
Exemplo de Particionamento
23
3
72
1
5
47 34 20 10
9
20 10 34 23
3
72
1
5
47
9
20 10 34 23
9
20 47 34 23
i
3
72
1 5
j ←
10
9
20 47 34 23
i
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
9
23
© Jorge Figueiredo, DSC/UFCG
4
Exemplo de Particionamento
3
72
1
5
47 34 20 10
3
72
1
5
47
3
72 1
j ←
5
10
9
Exemplo de Particionamento
23
3
72
1
5
47 34 20 10
9
20 10 34 23
3
72
1
5
47
9
20 10 34 23
9
20 47 34 23
i
3
72
j
1
5
10
9
20 47 34 23
i ←
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
23
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
Exemplo de Particionamento
9
9
Exemplo de Particionamento
3
72
1
5
47 34 20 10
23
3
72
1
5
47 34 20 10
3
72
1
5
47
9
20 10 34 23
3
72
1
5
47
9
20 10 34 23
3
72
j
1
5
10
9
20 47 34 23
i ←
3
72
1
5
10
9
20 47 34 23
3 20
j ←
1
5
10
9
72 47 34 23
i
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
72
1
5
47 34 20 10
3
72
1
5
47
3
72
1
5
10
3
j
20
1
5
10
Análise e Técnicas de Algoritmos – 2007.1
9
23
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
Exemplo de Particionamento
3
9
Exemplo de Particionamento
23
3
72
1
5
47 34 20 10
9
20 10 34 23
3
72
1
5
47
9
20 10 34 23
9
20 47 34 23
3
72
1
5
10
9
20 47 34 23
9
72 47 34 23
i
3
20
1
5
10
9
72 47 34 23
3
20
1
5
10
9
23 47 34 72
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
9
23
© Jorge Figueiredo, DSC/UFCG
5
QuickSort - Algoritmo
Análise do QuickSort
•• Requer
Requer aaresolução
resolução de
deuma
umarelação
relaçãode
de recorrência.
recorrência.
•• Como
Comonem
nemsempre
sempreos
osdados
dadossão
sãodivididos
divididosem
em duas
duas metades
metades
de
de mesmo
mesmotamanho:
tamanho:
–– Melhor
Melhorcaso,
caso,pior
piorcaso
casoeecaso
caso médio
médiopodem
podem variar.
variar.
•• Vamos
Vamos assumir:
assumir:
–– Tempo
Tempo de
departição
partiçãoééO(n).
O(n).
–– AA posição
posiçãofinal
finaldo
dopivô
pivôéé i.i.
•• AA chamada
chamadainicial
inicial ééQuickSort(A,
QuickSort(A,1,
1,n)
n)
QuickSort(A, inicio, fim)
if inicio < fim then
meio ← particiona(A, inicio, fim)
QuickSort(A, inicio, meio - 1)
QuickSort(A, meio + 1, fim)
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
Análise do QuickSort
T(n) = 1
T(n) = T(n - i) + T(i – 1) + n
Análise do QuickSort
n=1
nos demais casos
•• Melhor
Melhorcaso:
caso:
–– Pivô
Pivôsempre
semprefica
ficano
nomeio.
meio.
–– T(n)
T(n)==2T(n/2)
2T(n/2)++nn
–– O(n.log
O(n.logn)
n)
T(n) = 1
T(n) = T(n - i) + T(i – 1) + n
n=1
nos demais casos
•• Pior
Piorcaso:
caso:
–– Pivô
Pivôsempre
semprefica
ficana
naprimeira
primeiraou
ouúltima
últimaposição.
posição.
–– T(n)
T(n)==T(n
T(n--1)
1)++nn
2
–– O(n
O(n2))
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
Análise do QuickSort
T(n) = 1
T(n) = T(n - i) + T(i – 1) + n
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
Ainda sobre QuickSort
n=1
nos demais casos
•• ÉÉ talvez
talvez oo algoritmo
algoritmo de
de ordenação
ordenação mais
mais usado.
usado.
•• ÉÉ fácil
fácil de
de implementar
implementar ee muito
muito rápido
rápido na
na prática.
prática.
•• ÉÉ tipicamente
tipicamente mais
mais do
do que
que duas
duas vezes
vezes mais
mais rápido
rápido
do
do que
que oo MergeSort.
MergeSort.
•• Caso
Casomédio:
médio:
–– Pivô
Pivôtem
temaamesma
mesmaprobabilidade
probabilidade1/n
1/nde
decair
cairem
emuma
umadas
dasnnposições.
posições.
–– TTa(n)
(n)==nn++1/n
1/n∑(
∑(TTaa(i(i--1)
1)++TTaa(n
(n--i))
i))
a
–– O(n.log
O(n.logn)
n)
Análise e Técnicas de Algoritmos – 2007.1
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
© Jorge Figueiredo, DSC/UFCG
6
Exercício 1
Exercício 2
•• Definir
Definir um
umQuicksort
Quicksort diferente,
diferente,onde
ondeoopivô
pivôééoo primeiro
primeiro
elemento
elementodo
doarray.
array.
–– Escreva
Escreva,, em
empseudo-código,
pseudo-código,um
um procedimento
procedimentoque
que
efetua
efetuaaapartição
partiçãodo
do array
arraypara
paraeste
estenovo
novoQuicksort.
Quicksort.
–– Ilustre
Ilustreaaoperação
operaçãode
departição,
partição, considerando
considerandoooarray
array
A=[13,
A=[13,19,
19,9,
9,5,
5,12,
12,8,
8,7,
7,4,
4,11,
11,2].
2].
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
•• Um
Um problema
problema que
que está
está relacionado
relacionado com
com oo problema
problema
de
de ordenação
ordenação éé oo de
de encontrar
encontrar oo k-ésimo
k-ésimo menor
menor
elemento
elemento de
de uma
uma lista
lista não
não ordenada.
ordenada.
–– Escreva
um
algoritmo
Escreva um algoritmo que
que encontra
encontra oo k-ésimo
k-ésimo
menor
menor elemento.
elemento. Esse
Esse algoritmo
algoritmo deve
deve ser
ser Θ(n)
Θ(n)
na
na média
média ee no
no melhor
melhor caso.
caso.
Ordenação por Comparação
Ordenação por Comparação
•• Todos
Todos os
os algoritmos
algoritmos de
de ordenação
ordenação que
que estudamos
estudamos
até
até agora
agora utilizam
utilizam comparação
comparação de
de elementos.
elementos.
•• Em
Em uma
uma ordenação
ordenação por
por comparação,
comparação, aa ordem
ordem
relativa
em uma
uma seqüência
seqüência
relativa de
de dois
dois elementos
elementos aai i ee aaj j em
éé obtida
obtida utilizando
utilizando testes
testes de
de comparação:
comparação:
–– aai << aaj,, aai ≤≤ aaj,, aai == aaj,, aai >> aaj ee aai ≥≥ aaj..
i
j
i
j
i
j
i
j
i
j
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
•• O
O melhor
melhor algoritmo
algoritmo que
que vimos
vimos para
para ordenação
ordenação éé
O(n.log
O(n.log n).
n).
•• ÉÉ possível
possível encontrar
encontrar uma
uma melhor
melhor solução?
solução?
•• Árvore
Árvore de
de decisão
decisão pode
pode nos
nos ajudar
ajudar aa desvendar
desvendar
isso.
isso.
•• ÉÉ possível
possível usar
usar uma
uma árvore
árvore de
de decisão
decisão para
para
visualizar
visualizar ordenação
ordenação por
por comparação.
comparação.
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
Árvore de Decisão
Sort(<15, 4, 8>)
a1:a2
a2:a3
≤
a1:a3
≤
<1, 3, 2>
Análise e Técnicas de Algoritmos – 2007.1
a2:a3
>
≤
≤
a2:a3
<2, 1, 3>
>
15 > 4
≤
a1:a3
>
<1, 2, 3>
a1:a2
>
≤
≤
<3, 1, 2> <2, 3, 1>
<1, 2, 3>
a1:a3
>
<3, 2, 1>
© Jorge Figueiredo, DSC/UFCG
a1:a3
>
≤
<1, 3, 2>
Análise e Técnicas de Algoritmos – 2007.1
>
≤
a2:a3
<2, 1, 3>
>
≤
<3, 1, 2> <2, 3, 1>
>
<3, 2, 1>
© Jorge Figueiredo, DSC/UFCG
7
Sort(<15, 4, 8>)
Sort(<15, 4, 8>)
a1:a2
a1:a2
>
≤
a2:a3
a1:a3
≤
>
<1, 2, 3>
a1:a3
>
<3, 1, 2> <2, 3, 1>
<1, 3, 2>
>
<1, 2, 3>
≤
>
<3, 2, 1>
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
≤
>
a2:a3
a1:a3
>
<1, 2, 3>
a1:a3
≤
<1, 3, 2>
>
≤
a2:a3
<2, 1, 3>
>
≤
<3, 1, 2> <2, 3, 1>
>
Árvore de decisão
<3, 1, 2> <2, 3, 1>
>
<3, 2, 1>
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
•• As
As folhas
folhas de
de de
de uma
uma árvore
árvore de
de decisão
decisão indicam
indicam uma
uma
possível
possível ordenação
ordenação para
para os
os elementos.
elementos.
–– O
O número
número de
de permutações
permutações possível
possível éé n!.
n!.
•• Para
Para definir
definir um
um limite
limite inferior:
inferior:
d
–– Uma
folhas, onde
onde
Uma árvore
árvore binária
binária tem
tem no
no máximo
máximo 22d folhas,
dd éé aa sua
profundidade.
sua profundidade.
–– Uma
Uma árvore
árvore binária
binária com
com LL folhas
folhas tem
tem profundidade
profundidade
de
de pelo
pelo menos
menos ‪ ‪ log
log LL ‫ ‫ ‫‬..
Análise e Técnicas de Algoritmos – 2007.1
© Jorge Figueiredo, DSC/UFCG
Ordenação em Tempo Linear
•• O
O caminho
caminho mais
mais longo
longo da
da raiz
raiz de
de uma
uma árvore
árvore de
de
decisão
decisão para
para qualquer
qualquer uma
uma de
de suas
suas folhas
folhas representa
representa
oo pior
pior caso
caso do
do número
número de
de comparações.
comparações.
•• Para
Para nn elementos,
elementos, temos
temos n!
n! folhas:
folhas:
–– dd == ‪ ‪ log
log n!
n! ‫‫ ‫‬
–– dd ≥≥ log
log n!
n!
–– log
n!
log n! == Ө(n.log
Ө(n.log n)
n)
–– dd == Ω(n.log
Ω(n.log n)
n)
Análise e Técnicas de Algoritmos – 2007.1
4≤8
<3, 2, 1>
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
a2:a3
<2, 1, 3>
Árvore de decisão
a1:a2
≤
>
≤
>
<1, 3, 2>
Sort(<15, 4, 8>) = <4, 8, 15>
≤
a1:a3
≤
a2:a3
<2, 1, 3>
≤
a2:a3
15 > 8
≤
a1:a3
>
≤
© Jorge Figueiredo, DSC/UFCG
•• Nenhuma
Nenhumacomparação
comparaçãoééefetuada.
efetuada.
•• Counting
CountingSort:
Sort:
Counting Sort
Entrada: Um array de n números A = <a1, a2, ..., an›, em que
ai assume valores {1, 2, ..., k}.
Saída: Um array reordenado B = <b1, b2, ..., bn›.
Array auxiliar: Um array C = <c1, c2, ..., ck›
Análise e Técnicas de Algoritmos – 2007.1
© Jorge Figueiredo, DSC/UFCG
8
Counting Sort
Counting Sort - Exemplo
Counting Sort(A, B, k)
for i ← 1 to k do
C[i] ← 0
for j ← 1 to length[A] do
C[A[j]] ← C[A[j]] + 1
for i ←2 to k do
C[i] ← C[i] + C[i - 1]
for j ← length[A] downto 1 do
B[C[A[j]]] ← A[j]
C[A[j]] ← C[A[j]] - 1
A:
1
2
3
4
5
6
7
8
3
6
4
1
3
4
1
4
1
2
3
4
5
6
7
8
B:
1
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
1
2
3
4
5
6
7
8
3
6
4
1
3
4
1
4
1
2
3
4
5
6
7
8
4
5
6
© Jorge Figueiredo, DSC/UFCG
Exemplo – Laço 2
A:
B:
1
2
3
4
5
6
7
8
3
6
4
1
3
4
1
4
1
2
3
4
5
6
7
8
B:
C:
1
2
3
4
5
6
0
0
0
0
0
0
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
C:
1
2
3
4
5
6
7
8
3
6
4
1
3
4
1
4
1
2
3
4
5
6
7
8
2
3
4
5
6
0
0
1
0
0
0
© Jorge Figueiredo, DSC/UFCG
Exemplo – Laço 2
A:
1
2
3
4
5
6
7
8
3
6
4
1
3
4
1
4
1
2
3
4
5
6
7
8
B:
B:
C:
Análise e Técnicas de Algoritmos – 2007.1
1
Análise e Técnicas de Algoritmos – 2007.1
Exemplo – Laço 2
A:
3
Análise e Técnicas de Algoritmos – 2007.1
Exemplo – Laço 1
A:
2
C:
1
2
3
4
5
6
0
0
1
0
0
1
© Jorge Figueiredo, DSC/UFCG
C:
Análise e Técnicas de Algoritmos – 2007.1
1
2
3
4
5
6
0
0
1
1
0
1
© Jorge Figueiredo, DSC/UFCG
9
Exemplo – Laço 2
A:
1
2
3
4
5
6
7
8
3
6
4
1
3
4
1
4
1
2
3
4
5
6
7
8
Exemplo – Laço 2
A:
B:
1
2
3
4
5
6
7
8
3
6
4
1
3
4
1
4
1
2
3
4
5
6
7
8
B:
C:
1
2
3
4
5
6
1
0
1
1
0
1
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
C:
1
2
3
4
5
6
7
8
3
6
4
1
3
4
1
4
1
2
3
4
5
6
7
8
3
4
5
6
0
2
1
0
1
© Jorge Figueiredo, DSC/UFCG
Exemplo – Laço 2
A:
B:
1
2
3
4
5
6
7
8
3
6
4
1
3
4
1
4
1
2
3
4
5
6
7
8
B:
C:
1
2
3
4
5
6
1
0
2
2
0
1
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
C:
1
2
3
4
5
6
7
8
3
6
4
1
3
4
1
4
1
2
3
4
5
6
7
8
2
3
4
5
6
2
0
2
2
0
1
© Jorge Figueiredo, DSC/UFCG
Exemplo – Laço 3
A:
B:
1
2
3
4
5
6
7
8
3
6
4
1
3
4
1
4
1
2
3
4
5
6
7
8
B:
C:
Análise e Técnicas de Algoritmos – 2007.1
1
Análise e Técnicas de Algoritmos – 2007.1
Exemplo – Laço 2
A:
2
1
Análise e Técnicas de Algoritmos – 2007.1
Exemplo – Laço 2
A:
1
1
2
3
4
5
6
2
0
2
3
0
1
© Jorge Figueiredo, DSC/UFCG
C:
Análise e Técnicas de Algoritmos – 2007.1
1
2
3
4
5
6
2
0
2
3
0
1
© Jorge Figueiredo, DSC/UFCG
10
Exemplo – Laço 3
A:
1
2
3
4
5
6
7
8
3
6
4
1
3
4
1
4
1
2
3
4
5
6
7
8
Exemplo – Laço 3
A:
B:
1
2
3
4
5
6
7
8
3
6
4
1
3
4
1
4
1
2
3
4
5
6
7
8
B:
C:
1
2
3
4
5
6
2
2
2
3
0
1
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
C:
1
2
3
4
5
6
7
8
3
6
4
1
3
4
1
4
1
2
3
4
5
6
7
8
3
4
5
6
2
4
3
0
1
© Jorge Figueiredo, DSC/UFCG
Exemplo – Laço 3
A:
1
2
3
4
5
6
7
8
3
6
4
1
3
4
1
4
1
2
3
4
5
6
7
8
B:
B:
C:
1
2
3
4
5
6
2
2
4
7
0
1
© Jorge Figueiredo, DSC/UFCG
Análise e Técnicas de Algoritmos – 2007.1
C:
1
2
3
4
5
6
7
8
3
6
4
1
3
4
1
4
1
2
3
4
5
6
7
8
Análise e Técnicas de Algoritmos – 2007.1
2
3
4
5
6
2
2
4
7
7
1
© Jorge Figueiredo, DSC/UFCG
Exemplo – Laço 4
A:
B:
B:
C:
1
Análise e Técnicas de Algoritmos – 2007.1
Exemplo – Laço 3
A:
2
2
Análise e Técnicas de Algoritmos – 2007.1
Exemplo – Laço 3
A:
1
1
2
3
4
5
6
2
2
4
7
7
8
© Jorge Figueiredo, DSC/UFCG
1
2
3
4
5
6
7
8
3
6
4
1
3
4
1
4
1
2
3
4
5
6
7
8
1
1
3
3
4
4
4
6
C:
Análise e Técnicas de Algoritmos – 2007.1
1
2
3
4
5
6
0
2
2
4
7
7
© Jorge Figueiredo, DSC/UFCG
11
Análise do Counting Sort
•• AA análise
análise éé trivial:
trivial:
–– O
O primeiro
primeiro ee terceiro
terceiro laços
laços correspondem
correspondem aa O(k).
O(k).
–– O
O segundo
segundo ee quarto
quarto laços
laços são
são O(n).
O(n).
–– O
O tempo
tempo total
total é,
é, portanto,
portanto, O(n+k).
O(n+k).
–– Na
Na prática,
prática, kk == O(n).
O(n).
–– Logo,
Logo, oo counting
counting sort
sort éé O(n).
O(n).
•• Counting
Counting Sort
Sort éé estável.
estável.
Análise e Técnicas de Algoritmos – 2007.1
© Jorge Figueiredo, DSC/UFCG
12