slides - Facom

Introdução à Análise de Algoritmos
Marcelo K. Albertini
23 de Outubro de 2014
Aula de hoje
Nesta aula veremos:
Análise empı́rica de algoritmos
2/1
Análise empı́rica de algoritmos
Custo = memória + tempo
Quanto espaço de memória o algoritmo vai consumir?
Quanto tempo levar o algoritmo?
3/1
Análise empı́rica de algoritmos
Custo = memória + tempo
Quanto espaço de memória o algoritmo vai consumir?
Quanto tempo levar o algoritmo?
Como atribuir custo/estimar tempo de operações
uniforme - todas as operações tem o mesmo custo fixo T
atribuições de valores, cópias de variáveis, chamadas de funções
operações lógico-aritméticas
proporcional - operações tem custo proporcional ao número de
bits sendo operados
3/1
Avaliação de custos em um algoritmo
1
2
3
4
5
6
7
8
9
// l e r i n t e i r o p o s i t i v o ”n ”. . .
i f ( n > 10) {
System . o u t . p r i n t l n ( ” I s t o pode d e m o r a r . . . ”) ;
}
f o r ( i n t i = 1 ; i < 1 0 ; i ++) {
f o r ( i n t j = 1 ; j < i ; j ++) {
System . o u t . p r i n t l n ( i ∗ j ) ;
}
}
4/1
Ordenação
Como ordenar cartas de baralho?
Como ordenar depósitos em um banco?
Como estimar a duração?
Qual é o modelo de aumento de custo com o aumento de
entradas?
Como extrapolar o resultado?
5/1
Definição de um problema
Exemplo: problema de ordenação crescente
Entrada: uma sequência de n números a1 , a2 , a3 , . . . , an
Saı́da: uma reordenação b1 , b2 , . . . , bn , tal que bi < bj se i < j
A solução: um algoritmo
correto: se para cada instância de entrada, o algoritmo conclui
com a saı́da correta
se o é algoritmo é correto então ele resolve o problema
6/1
Análise empı́rica de algoritmos
Custo = memória + tempo
Quanto espaço de memória o algoritmo vai consumir?
Quanto tempo levar o algoritmo?
7/1
Análise empı́rica de algoritmos
Custo = memória + tempo
Quanto espaço de memória o algoritmo vai consumir?
Quanto tempo levar o algoritmo?
Como atribuir custo/estimar tempo de operações
uniforme - todas as operações tem o mesmo custo fixo T
atribuições de valores, cópias de variáveis, chamadas de funções
operações lógico-aritméticas
proporcional - operações tem custo proporcional ao número de
bits sendo operados
7/1
Avaliação empı́rica
A avaliação empı́rica permite
avaliação do desempenho em uma determinada configuração
de computador/linguagem
considera custos não aparentes: custo de alocação de
memória, sobrecarga de chamada de funções
comparar computadores
comparar linguagens
reconhecer modelo de desempenho para casos difı́ceis de
avaliação matemática de algoritmos
8/1
Avaliação empı́rica
Dificuldades
necessário implementar o algoritmo
resultados dependem do computador utilizado e de eventos
ocorridos no momento de avaliação
difı́cil de generalizar
9/1
Avaliação matemática
A avaliação matemática
uso de algoritmo em um “computador” idealizado
simplificação para considerar somente os custos dominantes
10/1
Avaliação de custos em um algoritmo
1
2
3
4
5
6
7
8
9
10
// E n t r a d a : i n t e i r o p o s i t i v o ”n ”
// S aı́ d a : i m p r i m i r m u l t i p l i c a ç õ e s de 0 a ”n ”
i f ( n > 10) {
System . o u t . p r i n t l n ( ” I s t o pode d e m o r a r . . . ”) ;
}
f o r ( i n t i = 0 ; i < n ; i ++) {
f o r ( i n t j = 0 ; j < i ; j ++) {
System . o u t . p r i n t l n ( i ∗ j ) ;
}
}
11/1
Avaliação de custos em um algoritmo
1 // E n t r a d a : i n t e i r o p o s i t i v o ”n ”
2 // S aı́ d a : i m p r i m i r m u l t i p l i c a ç õ e s de 0 a ”n ”
3 i f ( n > 10) {
12/1
Avaliação de custos em um algoritmo
1 // E n t r a d a : i n t e i r o p o s i t i v o ”n ”
2 // S aı́ d a : i m p r i m i r m u l t i p l i c a ç õ e s de 0 a ”n ”
3 i f ( n > 1 0 ) { // 1 vez , c u s t o c1
4
12/1
Avaliação de custos em um algoritmo
1 // E n t r a d a : i n t e i r o p o s i t i v o ”n ”
2 // S aı́ d a : i m p r i m i r m u l t i p l i c a ç õ e s de 0 a ”n ”
3 i f ( n > 1 0 ) { // 1 vez , c u s t o c1
4 System . o u t . p r i n t l n ( ” I s t o pode d e m o r a r . . . ”) ; c2
5
12/1
Avaliação de custos em um algoritmo
1
2
3
4
5
6
// E n t r a d a : i n t e i r o p o s i t i v o ”n ”
// S aı́ d a : i m p r i m i r m u l t i p l i c a ç õ e s de 0 a ”n ”
i f ( n > 1 0 ) { // 1 vez , c u s t o c1
System . o u t . p r i n t l n ( ” I s t o pode d e m o r a r . . . ”) ; c2
}
12/1
Avaliação de custos em um algoritmo
1
2
3
4
5
6
7
// E n t r a d a : i n t e i r o p o s i t i v o ”n ”
// S aı́ d a : i m p r i m i r m u l t i p l i c a ç õ e s de 0 a ”n ”
i f ( n > 1 0 ) { // 1 vez , c u s t o c1
System . o u t . p r i n t l n ( ” I s t o pode d e m o r a r . . . ”) ; c2
}
f o r ( i n t i = 0 ; i < n ; i ++) { // n v e z e s , c3 + nc1 + nc4
12/1
Avaliação de custos em um algoritmo
1
2
3
4
5
6
7
8
// E n t r a d a : i n t e i r o p o s i t i v o ”n ”
// S aı́ d a : i m p r i m i r m u l t i p l i c a ç õ e s de 0 a ”n ”
i f ( n > 1 0 ) { // 1 vez , c u s t o c1
System . o u t . p r i n t l n ( ” I s t o pode d e m o r a r . . . ”) ; c2
}
f o r ( i n t i = 0 ; i < n ; i ++) { // n v e z eP
s , c3 + nc1 + nc4
f o r ( i n t j = 0 ; j < i ; j ++) { // m = nj=1 j v e z e s ,
c3 + mc1 + mc4
12/1
Avaliação de custos em um algoritmo
1
2
3
4
5
6
7
// E n t r a d a : i n t e i r o p o s i t i v o ”n ”
// S aı́ d a : i m p r i m i r m u l t i p l i c a ç õ e s de 0 a ”n ”
i f ( n > 1 0 ) { // 1 vez , c u s t o c1
System . o u t . p r i n t l n ( ” I s t o pode d e m o r a r . . . ”) ; c2
}
f o r ( i n t i = 0 ; i < n ; i ++) { // n v e z eP
s , c3 + nc1 + nc4
f o r ( i n t j = 0 ; j < i ; j ++) { // m = nj=1 j v e z e s ,
c3 + mc1 + mc4
8
System . o u t . p r i n t l n ( i ∗ j ) ; // c2 + c5
9
12/1
Avaliação de custos em um algoritmo
1
2
3
4
5
6
7
// E n t r a d a : i n t e i r o p o s i t i v o ”n ”
// S aı́ d a : i m p r i m i r m u l t i p l i c a ç õ e s de 0 a ”n ”
i f ( n > 1 0 ) { // 1 vez , c u s t o c1
System . o u t . p r i n t l n ( ” I s t o pode d e m o r a r . . . ”) ; c2
}
f o r ( i n t i = 0 ; i < n ; i ++) { // n v e z eP
s , c3 + nc1 + nc4
f o r ( i n t j = 0 ; j < i ; j ++) { // m = nj=1 j v e z e s ,
c3 + mc1 + mc4
8
System . o u t . p r i n t l n ( i ∗ j ) ; // c2 + c5
9 }
10
12/1
Avaliação de custos em um algoritmo
1
2
3
4
5
6
7
// E n t r a d a : i n t e i r o p o s i t i v o ”n ”
// S aı́ d a : i m p r i m i r m u l t i p l i c a ç õ e s de 0 a ”n ”
i f ( n > 1 0 ) { // 1 vez , c u s t o c1
System . o u t . p r i n t l n ( ” I s t o pode d e m o r a r . . . ”) ; c2
}
f o r ( i n t i = 0 ; i < n ; i ++) { // n v e z eP
s , c3 + nc1 + nc4
f o r ( i n t j = 0 ; j < i ; j ++) { // m = nj=1 j v e z e s ,
c3 + mc1 + mc4
8
System . o u t . p r i n t l n ( i ∗ j ) ; // c2 + c5
9 }
10 }
Custos
comparação c1 , impressão c2 , atribuição c3 , incremento c4 ,
multiplicação c5
12/1
Avaliação de custos em um algoritmo
1
2
3
4
5
6
7
// E n t r a d a : i n t e i r o p o s i t i v o ”n ”
// S aı́ d a : i m p r i m i r m u l t i p l i c a ç õ e s de 0 a ”n ”
i f ( n > 1 0 ) { // 1 vez , c u s t o c1
System . o u t . p r i n t l n ( ” I s t o pode d e m o r a r . . . ”) ; c2
}
f o r ( i n t i = 0 ; i < n ; i ++) { // n v e z eP
s , c3 + nc1 + nc4
f o r ( i n t j = 0 ; j < i ; j ++) { // m = nj=1 j v e z e s ,
c3 + mc1 + mc4
8
System . o u t . p r i n t l n ( i ∗ j ) ; // c2 + c5
9 }
10 }
Custos: pior caso – quando o algoritmo executar tudo
T (n) =
13/1
Avaliação de custos em um algoritmo
1
2
3
4
5
6
7
// E n t r a d a : i n t e i r o p o s i t i v o ”n ”
// S aı́ d a : i m p r i m i r m u l t i p l i c a ç õ e s de 0 a ”n ”
i f ( n > 1 0 ) { // 1 vez , c u s t o c1
System . o u t . p r i n t l n ( ” I s t o pode d e m o r a r . . . ”) ; c2
}
f o r ( i n t i = 0 ; i < n ; i ++) { // n v e z eP
s , c3 + nc1 + nc4
f o r ( i n t j = 0 ; j < i ; j ++) { // m = nj=1 j v e z e s ,
c3 + mc1 + mc4
8
System . o u t . p r i n t l n ( i ∗ j ) ; // c2 + c5
9 }
10 }
Custos: pior caso – quando o algoritmo executar tudo
T (n) = c1 +
13/1
Avaliação de custos em um algoritmo
1
2
3
4
5
6
7
// E n t r a d a : i n t e i r o p o s i t i v o ”n ”
// S aı́ d a : i m p r i m i r m u l t i p l i c a ç õ e s de 0 a ”n ”
i f ( n > 1 0 ) { // 1 vez , c u s t o c1
System . o u t . p r i n t l n ( ” I s t o pode d e m o r a r . . . ”) ; c2
}
f o r ( i n t i = 0 ; i < n ; i ++) { // n v e z eP
s , c3 + nc1 + nc4
f o r ( i n t j = 0 ; j < i ; j ++) { // m = nj=1 j v e z e s ,
c3 + mc1 + mc4
8
System . o u t . p r i n t l n ( i ∗ j ) ; // c2 + c5
9 }
10 }
Custos: pior caso – quando o algoritmo executar tudo
T (n) = c1 + c2 +
13/1
Avaliação de custos em um algoritmo
1
2
3
4
5
6
7
// E n t r a d a : i n t e i r o p o s i t i v o ”n ”
// S aı́ d a : i m p r i m i r m u l t i p l i c a ç õ e s de 0 a ”n ”
i f ( n > 1 0 ) { // 1 vez , c u s t o c1
System . o u t . p r i n t l n ( ” I s t o pode d e m o r a r . . . ”) ; c2
}
f o r ( i n t i = 0 ; i < n ; i ++) { // n v e z eP
s , c3 + nc1 + nc4
f o r ( i n t j = 0 ; j < i ; j ++) { // m = nj=1 j v e z e s ,
c3 + mc1 + mc4
8
System . o u t . p r i n t l n ( i ∗ j ) ; // c2 + c5
9 }
10 }
Custos: pior caso – quando o algoritmo executar tudo
T (n) = c1 + c2 + (c3 + nc1 + nc4 ) +
13/1
Avaliação de custos em um algoritmo
1
2
3
4
5
6
7
// E n t r a d a : i n t e i r o p o s i t i v o ”n ”
// S aı́ d a : i m p r i m i r m u l t i p l i c a ç õ e s de 0 a ”n ”
i f ( n > 1 0 ) { // 1 vez , c u s t o c1
System . o u t . p r i n t l n ( ” I s t o pode d e m o r a r . . . ”) ; c2
}
f o r ( i n t i = 0 ; i < n ; i ++) { // n v e z eP
s , c3 + nc1 + nc4
f o r ( i n t j = 0 ; j < i ; j ++) { // m = nj=1 j v e z e s ,
c3 + mc1 + mc4
8
System . o u t . p r i n t l n ( i ∗ j ) ; // c2 + c5
9 }
10 }
Custos: pior caso – quando o algoritmo executar tudo
T (n) = c1 + c2 + (c3 + nc1 + nc4 ) + (c3 + mc1 + mc4 ) +
13/1
Avaliação de custos em um algoritmo
1
2
3
4
5
6
7
// E n t r a d a : i n t e i r o p o s i t i v o ”n ”
// S aı́ d a : i m p r i m i r m u l t i p l i c a ç õ e s de 0 a ”n ”
i f ( n > 1 0 ) { // 1 vez , c u s t o c1
System . o u t . p r i n t l n ( ” I s t o pode d e m o r a r . . . ”) ; c2
}
f o r ( i n t i = 0 ; i < n ; i ++) { // n v e z eP
s , c3 + nc1 + nc4
f o r ( i n t j = 0 ; j < i ; j ++) { // m = nj=1 j v e z e s ,
c3 + mc1 + mc4
8
System . o u t . p r i n t l n ( i ∗ j ) ; // c2 + c5
9 }
10 }
Custos: pior caso – quando o algoritmo executar tudo
T (n) = c1 + c2 + (c3 + nc1 + nc4 ) + (c3 + mc1 + mc4 ) + m ∗ (c2 + c5 )
13/1
Avaliação de custos em um algoritmo
Custos: pior caso – quando o algoritmo executar tudo
T (n) = c1 +c2 +(c3 +nc1 +nc4 )+(c3 +mc1 +mc4 )+m∗(c2 +c5 ))
14/1
Avaliação de custos em um algoritmo
Custos: pior caso – quando o algoritmo executar tudo
T (n) = c1 +c2 +(c3 +nc1 +nc4 )+(c3 +mc1 +mc4 )+m∗(c2 +c5 ))
se todos custos forem considerados iguais a “c”:
14/1
Avaliação de custos em um algoritmo
Custos: pior caso – quando o algoritmo executar tudo
T (n) = c1 +c2 +(c3 +nc1 +nc4 )+(c3 +mc1 +mc4 )+m∗(c2 +c5 ))
se todos custos forem considerados iguais a “c”:
T (n) = c + c + (c + nc + nc) + (c + mc + mc) + m ∗ (c + c))
14/1
Avaliação de custos em um algoritmo
Custos: pior caso – quando o algoritmo executar tudo
T (n) = c1 +c2 +(c3 +nc1 +nc4 )+(c3 +mc1 +mc4 )+m∗(c2 +c5 ))
se todos custos forem considerados iguais a “c”:
T (n) = c + c + (c + nc + nc) + (c + mc + mc) + m ∗ (c + c))
T (n) = 2c + (c + 2nc) + (c + 2mc) + 2mc
14/1
Avaliação de custos em um algoritmo
Custos: pior caso – quando o algoritmo executar tudo
T (n) = c1 +c2 +(c3 +nc1 +nc4 )+(c3 +mc1 +mc4 )+m∗(c2 +c5 ))
se todos custos forem considerados iguais a “c”:
T (n) = c + c + (c + nc + nc) + (c + mc + mc) + m ∗ (c + c))
T (n) = 2c + (c + 2nc) + (c + 2mc) + 2mc
T (n) = 4c + 2nc + 4mc
14/1
Avaliação de custos em um algoritmo
Custo do algoritmo é
T (n) = 4c + 2nc + 4mc
15/1
Avaliação de custos em um algoritmo
Custo do algoritmo é
T (n) = 4c + 2nc + 4mc
Quanto é m ?
P
m = nj=1 j =
1 + 2 + 3 + 4 + 5 + . . . + (n − 3) + (n − 2) + (n − 1) + n =
15/1
Avaliação de custos em um algoritmo
Custo do algoritmo é
T (n) = 4c + 2nc + 4mc
Quanto é m ?
P
m = nj=1 j =
1 + 2 + 3 + 4 + 5 + . . . + (n − 3) + (n − 2) + (n − 1) + n =
(n + 1) + (2 + (n − 1)) + (3 + (n − 2)) + . . . + (n + 1)
15/1
Avaliação de custos em um algoritmo
Custo do algoritmo é
T (n) = 4c + 2nc + 4mc
Quanto é m ?
P
m = nj=1 j =
1 + 2 + 3 + 4 + 5 + . . . + (n − 3) + (n − 2) + (n − 1) + n =
(n + 1) + (2 + (n − 1)) + (3 + (n − 2)) + . . . + (n + 1)
Somamos n/2 pares de números (n + 1)
15/1
Avaliação de custos em um algoritmo
Custo do algoritmo é
T (n) = 4c + 2nc + 4mc
Quanto é m ?
P
m = nj=1 j =
1 + 2 + 3 + 4 + 5 + . . . + (n − 3) + (n − 2) + (n − 1) + n =
(n + 1) + (2 + (n − 1)) + (3 + (n − 2)) + . . . + (n + 1)
Somamos n/2 pares de números (n + 1)
m = n2 (n + 1)
15/1
Avaliação de custos em um algoritmo
Custo do algoritmo é
T (n) = 4c + 2nc + 4mc
Quanto é m ?
P
m = nj=1 j =
1 + 2 + 3 + 4 + 5 + . . . + (n − 3) + (n − 2) + (n − 1) + n =
(n + 1) + (2 + (n − 1)) + (3 + (n − 2)) + . . . + (n + 1)
Somamos n/2 pares de números (n + 1)
m = n2 (n + 1)
15/1
Avaliação de custos em um algoritmo
Custo do algoritmo é
T (n) = 4c + 2nc + 4mc
Quanto é m ?
P
m = nj=1 j =
1 + 2 + 3 + 4 + 5 + . . . + (n − 3) + (n − 2) + (n − 1) + n =
(n + 1) + (2 + (n − 1)) + (3 + (n − 2)) + . . . + (n + 1)
Somamos n/2 pares de números (n + 1)
m = n2 (n + 1)
Custo do algoritmo é
T (n) = 4c + 2nc + 4( n2 (n + 1))c
15/1
Avaliação de custos em um algoritmo
Custo do algoritmo é
T (n) = 4c + 2nc + 4( n2 (n + 1))c
Qual é o custo dominante do algoritmo?
16/1
Avaliação de custos em um algoritmo
Custo do algoritmo é
T (n) = 4c + 2nc + 4( n2 (n + 1))c
T (n) = 4c + 2nc + 2n(n + 1)c
Qual é o custo dominante do algoritmo?
16/1
Avaliação de custos em um algoritmo
Custo do algoritmo é
T (n) = 4c + 2nc + 4( n2 (n + 1))c
T (n) = 4c + 2nc + 2n(n + 1)c
T (n) = 4c + 2nc + 2n2 c + 2nc
Qual é o custo dominante do algoritmo?
16/1
Avaliação de custos em um algoritmo
Custo do algoritmo é
T (n) = 4c + 2nc + 4( n2 (n + 1))c
T (n) = 4c + 2nc + 2n(n + 1)c
T (n) = 4c + 2nc + 2n2 c + 2nc
T (n) = 4c + 4cn + 2cn2
Qual é o custo dominante do algoritmo?
16/1
Complexidade de tempo
Custo do algoritmo de multiplicação de números
A função que descreve o custo do nosso algoritmo é
T (n) = 4c + 4cn + 2cn2 .
17/1
Complexidade de tempo
Custo do algoritmo de multiplicação de números
A função que descreve o custo do nosso algoritmo é
T (n) = 4c + 4cn + 2cn2 .
Complexidade de tempo
Para descrever a complexidade usamos somente o custo
dominante: 2cn2 .
17/1
Complexidade de tempo
Custo do algoritmo de multiplicação de números
A função que descreve o custo do nosso algoritmo é
T (n) = 4c + 4cn + 2cn2 .
Complexidade de tempo
Para descrever a complexidade usamos somente o custo
dominante: 2cn2 .
Porquê?
Existe um número n = a a partir do qual o custo 2ca2 é sempre
superior a 4ca, tornando-o pouco importante.
17/1
Complexidade de tempo
Custo do algoritmo de multiplicação de números
A função que descreve o custo do nosso algoritmo é
T (n) = 4c + 4cn + 2cn2 .
Complexidade de tempo
Para descrever a complexidade usamos somente o custo
dominante: 2cn2 .
Porquê?
Existe um número n = a a partir do qual o custo 2ca2 é sempre
superior a 4ca, tornando-o pouco importante.
Ordem de crescimento
Dizemos que a complexidade de pior caso do nosso algoritmo é
O(n2 ).
17/1
Estudo de complexidade de algoritmos
Dois fatores
Tempo de execução
Espaço de memória necessário
Motivações
qual é o menor custo possı́vel?
é possı́vel resolver o problema em tempo hábil?
18/1
Caso hipotético
Problema
Um banco tem 10 milhões clientes.
Cada cliente faz em média 4 transações diárias.
19/1
Caso hipotético
Problema
Um banco tem 10 milhões clientes.
Cada cliente faz em média 4 transações diárias.
Relatório
O banco precisa entregar um relatório diário para o Banco Central,
com uma relação ordenada de todas as transações.
19/1
Caso hipotético
Problema
Um banco tem 10 milhões clientes.
Cada cliente faz em média 4 transações diárias.
Relatório
O banco precisa entregar um relatório diário para o Banco Central,
com uma relação ordenada de todas as transações.
Infraestrutura
O computador do banco é dedicado ao problema e resolve
operações lógico-aritméticas na taxa de 230 (∼ 1 bilhão) operações
por segundo.
19/1
Ordenação interna
ordenar em memória
Pré-condições: vetor em memória principal, inicializado com
elementos
20/1
Ordenação interna
ordenar em memória
Pré-condições: vetor em memória principal, inicializado com
elementos
Pós-condições: vetor com elementos em ordem crescente (ou
decrescente)
20/1
Ordenação interna
ordenar em memória
Pré-condições: vetor em memória principal, inicializado com
elementos
Pós-condições: vetor com elementos em ordem crescente (ou
decrescente)
Como fica ordenado?
20/1
Algoritmo de ordenação
Definição de ordenação
Sequência de comparações e trocas de posição entre elementos
para obter vetor ordenado.
21/1
Algoritmo de ordenação
Definição de ordenação
Sequência de comparações e trocas de posição entre elementos
para obter vetor ordenado.
Complexidade
Quantas trocas, comparações (complexidade de tempo) e variáveis
auxiliares (de espaço) são necessárias?
21/1
Outras iterações
22/1
Bubblesort - Ordenação em “bolhas”
Como programar um algoritmo de ordenação simples?
Ideia
Comparar pares consecutivos de elementos e trocá-los de posição
caso o primeiro seja maior que o segundo.
1 if
2
3
4
5 }
( vetor
aux =
vetor [
vetor [
[ i ] > v e t o r [ i +1]) {
vetor [ i ] ;
i ] = v e t o r [ i +1];
i +1] = aux ;
23/1
Bubblesort - Ordenação em “bolhas”
Como programar um algoritmo de ordenação simples?
Ideia
Comparar pares consecutivos de elementos e trocá-los de posição
caso o primeiro seja maior que o segundo.
1 if
2
3
4
5 }
( vetor
aux =
vetor [
vetor [
[ i ] > v e t o r [ i +1]) {
vetor [ i ] ;
i ] = v e t o r [ i +1];
i +1] = aux ;
Variável auxiliar aux é essencial.
23/1
Algoritmo Bubblesort: versão simplificada
1 b u b b l e s o r t ( i n t v e t o r [ ] , i n t nelem ) {
24/1
Algoritmo Bubblesort: versão simplificada
1 b u b b l e s o r t ( i n t v e t o r [ ] , i n t nelem ) {
2
i n t i , i t e r a c a o , aux ;
24/1
Algoritmo Bubblesort: versão simplificada
1 b u b b l e s o r t ( i n t v e t o r [ ] , i n t nelem ) {
2
i n t i , i t e r a c a o , aux ;
3
4
/∗ c o n t r o l e do número de i t e r a ç õ e s ( n − 1 ) ∗/
5
f o r ( i t e r a c a o = 0 ; i t e r a c a o < nelem −1; i t e r a c a o ++){
24/1
Algoritmo Bubblesort: versão simplificada
1 b u b b l e s o r t ( i n t v e t o r [ ] , i n t nelem ) {
2
i n t i , i t e r a c a o , aux ;
3
4
/∗ c o n t r o l e do número de i t e r a ç õ e s ( n − 1 ) ∗/
5
f o r ( i t e r a c a o = 0 ; i t e r a c a o < nelem −1; i t e r a c a o ++){
6
/∗ r e p e t i c a o i n t e r n a , p e r c o r r e v e t o r ( n − 1 ) ∗/
7
f o r ( i = 0 ; i < nelem − 1 ; i ++){
24/1
Algoritmo Bubblesort: versão simplificada
1 b u b b l e s o r t ( i n t v e t o r [ ] , i n t nelem ) {
2
i n t i , i t e r a c a o , aux ;
3
4
/∗ c o n t r o l e do número de i t e r a ç õ e s ( n − 1 ) ∗/
5
f o r ( i t e r a c a o = 0 ; i t e r a c a o < nelem −1; i t e r a c a o ++){
6
/∗ r e p e t i c a o i n t e r n a , p e r c o r r e v e t o r ( n − 1 ) ∗/
7
f o r ( i = 0 ; i < nelem − 1 ; i ++){
8
i f ( v e t o r [ i ] > v e t o r [ i +1]) {
24/1
Algoritmo Bubblesort: versão simplificada
1 b u b b l e s o r t ( i n t v e t o r [ ] , i n t nelem ) {
2
i n t i , i t e r a c a o , aux ;
3
4
/∗ c o n t r o l e do número de i t e r a ç õ e s ( n − 1 ) ∗/
5
f o r ( i t e r a c a o = 0 ; i t e r a c a o < nelem −1; i t e r a c a o ++){
6
/∗ r e p e t i c a o i n t e r n a , p e r c o r r e v e t o r ( n − 1 ) ∗/
7
f o r ( i = 0 ; i < nelem − 1 ; i ++){
8
i f ( v e t o r [ i ] > v e t o r [ i +1]) {
9
/∗ é n e c e s s á r i a uma t r o c a ∗/
10
aux = v e t o r [ i ] ;
11
v e t o r [ i ] = v e t o r [ i +1];
12
v e t o r [ i +1] = aux ;
13
}
14
}
15
}
16 }
24/1
Um problema de ordenação
Se o algoritmo é o Bubblesort, o banco:
25/1
Um problema de ordenação
Se o algoritmo é o Bubblesort, o banco:
a) conseguirá tranquilamente fazer o relatório a tempo;
25/1
Um problema de ordenação
Se o algoritmo é o Bubblesort, o banco:
a) conseguirá tranquilamente fazer o relatório a tempo;
b) deverá comprar um computador melhor;
25/1
Um problema de ordenação
Se o algoritmo é o Bubblesort, o banco:
a) conseguirá tranquilamente fazer o relatório a tempo;
b) deverá comprar um computador melhor;
c) deverá contratar um programador melhor.
25/1
Caso bancário
Avaliação:
Ordem do Bubblesort:
26/1
Caso bancário
Avaliação:
Ordem do Bubblesort:
26/1
Caso bancário
Avaliação:
Ordem do Bubblesort: O(n2 )
26/1
Caso bancário
Avaliação:
Ordem do Bubblesort: O(n2 )
Elementos a ordenar: número de transações n = 4 × 107
26/1
Caso bancário
Avaliação:
Ordem do Bubblesort: O(n2 )
Elementos a ordenar: número de transações n = 4 × 107
26/1
Caso bancário
Avaliação:
Ordem do Bubblesort: O(n2 )
Elementos a ordenar: número de transações n = 4 × 107
Operações necessárias: (4 × 107 )2
26/1
Caso bancário
Avaliação:
Ordem do Bubblesort: O(n2 )
Elementos a ordenar: número de transações n = 4 × 107
Operações necessárias: (4 × 107 )2
26/1
Caso bancário
Avaliação:
Ordem do Bubblesort: O(n2 )
Elementos a ordenar: número de transações n = 4 × 107
Operações necessárias: (4 × 107 )2
Capacidade do computador: 230 operações por segundo
26/1
Caso bancário
Avaliação:
Ordem do Bubblesort: O(n2 )
Elementos a ordenar: número de transações n = 4 × 107
Operações necessárias: (4 × 107 )2
Capacidade do computador: 230 operações por segundo
Tempo necessário em minutos: (4 × 107 )2 /230
26/1
Caso bancário
Avaliação:
Ordem do Bubblesort: O(n2 )
Elementos a ordenar: número de transações n = 4 × 107
Operações necessárias: (4 × 107 )2
Capacidade do computador: 230 operações por segundo
Tempo necessário em minutos: (4 × 107 )2 /230
26/1
Caso bancário
Avaliação:
Ordem do Bubblesort: O(n2 )
Elementos a ordenar: número de transações n = 4 × 107
Operações necessárias: (4 × 107 )2
Capacidade do computador: 230 operações por segundo
Tempo necessário em minutos: (4 × 107 )2 /230
= 17 dias, 4 horas, 55 minutos e 16 segundos
26/1
Notação de complexidade
Função de complexidade (de tempo ou espaço)
Para um problema de tamanho n, buscamos uma função f (n) que
descreve o componente principal do nosso custo
Conflito de interesses
Frequentemente, quando a complexidade de tempo diminui, a
complexidade de espaço aumenta
27/1
Notação
Melhor caso: Ω
Menor custo de um algoritmo (tempo ou espaço) para todas as
entradas (problema) de tamanho n
Pior caso: O
Maior custo possı́vel de um algoritmo (tempo ou espaço) para
todas as entradas (problema) de tamanho n.
28/1
Notação
Melhor caso: Ω
Menor custo de um algoritmo (tempo ou espaço) para todas as
entradas (problema) de tamanho n
Pior caso: O
Maior custo possı́vel de um algoritmo (tempo ou espaço) para
todas as entradas (problema) de tamanho n.
O custo nunca é menor que no melhor caso e nunca maior do que
no pior caso.
28/1
Caso médio
Caso médio ou esperado
O conjunto de entradas n é descrito por uma distribuição de
probabilidades.
Qual é a função de custo, considerando a probabilidade de cada
entrada de tamanho n?
29/1
Exemplos
Problema
Verificar se um dado número está em um vetor.
Entrada: vetor com n números.
Saı́da: Afirmativo, se número buscado está entre os n números do
vetor. Negativo, caso contrário.
30/1
Exemplos
Problema
Verificar se um dado número está em um vetor.
Entrada: vetor com n números.
Saı́da: Afirmativo, se número buscado está entre os n números do
vetor. Negativo, caso contrário.
Algoritmo
Comparar cada número do vetor com o número buscado. Dar a
resposta afirmativa assim que encontrá-lo.
30/1
Análise de casos
Casos
Melhor caso: notação Ω
31/1
Análise de casos
Casos
Melhor caso: notação Ω
f (n) = 2 operações
31/1
Análise de casos
Casos
Melhor caso: notação Ω
f (n) = 2 operações
Ω(n) = 1, i.e., f (n) ≥ c ∗ Ω(n)
31/1
Análise de casos
Casos
Melhor caso: notação Ω
f (n) = 2 operações
Ω(n) = 1, i.e., f (n) ≥ c ∗ Ω(n)
Pior caso: notação O
31/1
Análise de casos
Casos
Melhor caso: notação Ω
f (n) = 2 operações
Ω(n) = 1, i.e., f (n) ≥ c ∗ Ω(n)
Pior caso: notação O
f (n) = 2n + 1 operações
31/1
Análise de casos
Casos
Melhor caso: notação Ω
f (n) = 2 operações
Ω(n) = 1, i.e., f (n) ≥ c ∗ Ω(n)
Pior caso: notação O
f (n) = 2n + 1 operações
O(n) = n, i.e., f (n) ≤ c ∗ O(n)
31/1
Análise de casos
Casos
Melhor caso: notação Ω
f (n) = 2 operações
Ω(n) = 1, i.e., f (n) ≥ c ∗ Ω(n)
Pior caso: notação O
f (n) = 2n + 1 operações
O(n) = n, i.e., f (n) ≤ c ∗ O(n)
Notação Θ: quando O(n) = Ω(n)
31/1
Análise de casos
Casos
Melhor caso: notação Ω
f (n) = 2 operações
Ω(n) = 1, i.e., f (n) ≥ c ∗ Ω(n)
Pior caso: notação O
f (n) = 2n + 1 operações
O(n) = n, i.e., f (n) ≤ c ∗ O(n)
Notação Θ: quando O(n) = Ω(n)
Caso médio: distribuição de probabilidade uniforme
31/1
Análise de casos
Casos
Melhor caso: notação Ω
f (n) = 2 operações
Ω(n) = 1, i.e., f (n) ≥ c ∗ Ω(n)
Pior caso: notação O
f (n) = 2n + 1 operações
O(n) = n, i.e., f (n) ≤ c ∗ O(n)
Notação Θ: quando O(n) = Ω(n)
Caso médio: distribuição de probabilidade uniforme
1+2+3+4+...+n
n
31/1
Análise assintótica
Casos
Notação limitante inferior Ω
32/1
Análise assintótica
Casos
Notação limitante inferior Ω
f (n) = 1 operação
32/1
Análise assintótica
Casos
Notação limitante inferior Ω
f (n) = 1 operação
Ω(n) = 1, i.e., f (n) ≥ c ∗ n
32/1
Análise assintótica
Casos
Notação limitante inferior Ω
f (n) = 1 operação
Ω(n) = 1, i.e., f (n) ≥ c ∗ n
Notação limitante superior O
32/1
Análise assintótica
Casos
Notação limitante inferior Ω
f (n) = 1 operação
Ω(n) = 1, i.e., f (n) ≥ c ∗ n
Notação limitante superior O
f (n) = 5n operações
32/1
Análise assintótica
Casos
Notação limitante inferior Ω
f (n) = 1 operação
Ω(n) = 1, i.e., f (n) ≥ c ∗ n
Notação limitante superior O
f (n) = 5n operações
O(n) = n, i.e., f (n) ≤ cn
32/1
Análise assintótica
Casos
Notação limitante inferior Ω
f (n) = 1 operação
Ω(n) = 1, i.e., f (n) ≥ c ∗ n
Notação limitante superior O
f (n) = 5n operações
O(n) = n, i.e., f (n) ≤ cn
Notação limitante superior e inferior iguais
32/1
Análise assintótica
Casos
Notação limitante inferior Ω
f (n) = 1 operação
Ω(n) = 1, i.e., f (n) ≥ c ∗ n
Notação limitante superior O
f (n) = 5n operações
O(n) = n, i.e., f (n) ≤ cn
Notação limitante superior e inferior iguais
c1 ∗ Θ(n) ≤ f (n) ≤ c2 ∗ Θ(n)
32/1
Análise assintótica
Casos
Notação limitante inferior Ω
f (n) = 1 operação
Ω(n) = 1, i.e., f (n) ≥ c ∗ n
Notação limitante superior O
f (n) = 5n operações
O(n) = n, i.e., f (n) ≤ cn
Notação limitante superior e inferior iguais
c1 ∗ Θ(n) ≤ f (n) ≤ c2 ∗ Θ(n)
não há no caso de busca de número em vetor
32/1
Análise assintótica
Casos
Notação limitante inferior Ω
f (n) = 1 operação
Ω(n) = 1, i.e., f (n) ≥ c ∗ n
Notação limitante superior O
f (n) = 5n operações
O(n) = n, i.e., f (n) ≤ cn
Notação limitante superior e inferior iguais
c1 ∗ Θ(n) ≤ f (n) ≤ c2 ∗ Θ(n)
não há no caso de busca de número em vetor
Não utiliza-se notação para casos médios
32/1
Exemplo: avaliação assintótica
Exemplo 1
f (n) = n2 + n + c
n2 = g (n) = O(f (n))
n2 domina assintoticamente os outros termos
33/1
Exemplo: avaliação assintótica
Exemplo 1
f (n) = n2 + n + c
n2 = g (n) = O(f (n))
n2 domina assintoticamente os outros termos
Exemplo 2
f (n) = n + log (n) + c
O(n)
n domina assintoticamente os outros termos
33/1
Exemplo: avaliação assintótica
Exemplo 1
f (n) = n2 + n + c
n2 = g (n) = O(f (n))
n2 domina assintoticamente os outros termos
Exemplo 2
f (n) = n + log (n) + c
O(n)
n domina assintoticamente os outros termos
Exemplo 3
f (n) = n! + n2 + c
O(n!)
n! domina assintoticamente os outros termos
33/1
Orientações
Desprezar constantes
f (n) = 100000000 ∗ n + 999999999
O(f (n)) = n
Desprezar termos de menor grandeza
Atenção
Complexidade assintótica menor não indica que o algoritmo sempre
é o melhor. Se as constantes forem significativas, na prática é
melhor considerá-las.
34/1
Classes de problemas
O(1) < O(log (n)) < O(n) < O(nlog (n)) < O(n2 ) < O(n3 ) <
O(2n )
O(1): ordem constante
35/1
Classes de problemas
O(1) < O(log (n)) < O(n) < O(nlog (n)) < O(n2 ) < O(n3 ) <
O(2n )
O(1): ordem constante
O(log (n)): ordem logaritmica
35/1
Classes de problemas
O(1) < O(log (n)) < O(n) < O(nlog (n)) < O(n2 ) < O(n3 ) <
O(2n )
O(1): ordem constante
O(log (n)): ordem logaritmica
O(n): ordem linear
35/1
Classes de problemas
O(1) < O(log (n)) < O(n) < O(nlog (n)) < O(n2 ) < O(n3 ) <
O(2n )
O(1): ordem constante
O(log (n)): ordem logaritmica
O(n): ordem linear
O(nlog (n)): ordem tı́pica de soluções em “pedaços”, e.g.,
árvores
35/1
Classes de problemas
O(1) < O(log (n)) < O(n) < O(nlog (n)) < O(n2 ) < O(n3 ) <
O(2n )
O(1): ordem constante
O(log (n)): ordem logaritmica
O(n): ordem linear
O(nlog (n)): ordem tı́pica de soluções em “pedaços”, e.g.,
árvores
O(n2 ): ordem quadrática. “um laço dentro de outro”
35/1
Classes de problemas
O(1) < O(log (n)) < O(n) < O(nlog (n)) < O(n2 ) < O(n3 ) <
O(2n )
O(1): ordem constante
O(log (n)): ordem logaritmica
O(n): ordem linear
O(nlog (n)): ordem tı́pica de soluções em “pedaços”, e.g.,
árvores
O(n2 ): ordem quadrática. “um laço dentro de outro”
O(2n ): ordem exponencial. Impraticável.
35/1
Classes de problemas
O(1) < O(log (n)) < O(n) < O(nlog (n)) < O(n2 ) < O(n3 ) <
O(2n )
O(1): ordem constante
O(log (n)): ordem logaritmica
O(n): ordem linear
O(nlog (n)): ordem tı́pica de soluções em “pedaços”, e.g.,
árvores
O(n2 ): ordem quadrática. “um laço dentro de outro”
O(2n ): ordem exponencial. Impraticável.
O(n!): ordem fatorial. Pior que exponencial.
35/1
Exercı́cio: maior valor de um vetor
Qual é a função que descreve o custo e a ordem de crescimento de
pior caso do seguinte algoritmo?
1
2
3
4
5
6
7
8
9
10
11
12
13
// E n t r a d a : v e t o r com n úmeros i n t e i r o s
// S aı́ d a : m a i o r v a l o r do v e t o r
i n t max ( i n t a [ ] ) {
i n t i , maior ;
maior = a [ 0 ] ;
f o r ( i = 1 ; i < a . l e n g t h ; i ++){
i f ( maior < a [ i ] ) {
maior = a [ i ] ;
}
}
r e t u r n ( maior ) ;
}
36/1
Exercı́cio: busca número em vetor
Qual é a função que descreve o custo e a ordem de crescimento de
pior caso do seguinte algoritmo?
1 // E n t r a d a : a [] − v e t o r o r d e n a d o de n úmeros i n t e i r o s , n
− número s e n d o buscado , i n f − l i m i t e i n f e r i o r de
b u s c a no v e t o r a [ ] , s u p − l i m i t e s u p e r i o r de b u s c a
no v e t o r a [ ]
2 // S aı́ d a : f a l s e s e não e n c o n t r o u , t r u e c a s o c o n t r á r i o
3 p u b l i c s t a t i c boolean busca ( i n t a [ ] , i n t n , i n t i n f ,
i n t sup ) {
4 i f ( i n f > sup ) {
5
return ( false ) ;
6 } else {
7
i n t m = ( i n t ) ( i n f+s u p ) / 2 ;
8
i f ( a [m] == n )
9
return ( true ) ;
10
11
i f ( n> a [m] ) {
12
r e t u r n ( b u s c a ( a , n , m+1 , s u p ) ) ;
13
} else {
14
r e t u r n ( b u s c a ( a , n , i n f , m−1) ) ;
15
}
16
}
17 }
18 }
37/1