Você está na página 1de 9

1/19/2016

Algoritmos e Estruturas de Dados

Profa. Ana Maria Moura

Ana Maria Moura 1

INTRODUÇÃO A MEDIDA DE
COMPLEXIDADE DE ALGORITMOS

Ana Maria Moura 2

1
1/19/2016

Motivação
O tempo de execução de um algoritmo/programa não depende somente do algoritmo,
mas do conjunto de instruções do computador, a qualidade do compilador e a habilidade
do programador.

Por que analisar a eficiência de algoritmos se o hardware está cada dia mais rápido e com
mais capacidade de armazenamento ?
- O Hardware é um recurso finito e cada vez mais necessitamos resolver problemas te
tamanho muito extenso.

O mesmo problema pode ser resolvido por diferentes algoritmos. Como selecionar o mais
adequado?
- Para problemas de tamanho pequeno não há muita diferença na performance do
algoritmo, mas precisamos nos preocupar em selecionar o algoritmo adequado para
problemas maiores.

Ana Maria Moura 3

Como Medir?
• A complexidade pode ser calculada através de:
– Tempo de execução do algoritmo que pode ser determinado pelas instruções executadas, ou
seja, quanto “tempo” é necessário para computar o resultado para uma instância do problema
de tamanho n, onde n é o tamanho da entrada de dados;

– Espaço de memória utilizado pelo algoritmo que á a quantidade de “espaço de


memória/disco” que é preciso para armazenar a(s) estrutura(s) utilizada(s) pelo algoritmo.

• Complexidade é também chamada esforço requerido ou quantidade de trabalho.


– Complexidade no pior caso : Considera-se a instância que faz o algoritmo funcionar mais
lentamente;
– Complexidade média: Considera-se todas as possíveis instâncias e mede-se o tempo médio.
– Complexidade no melhor caso: Considera-se a instância que faz o algoritmo funcionar mais
rapidamente.

• Como esta medida fornece um nível de detalhamento muito grande, convém


adotar medidas de tempo assintótica que permitem entender o comportamento
do tempo de execução à medida que o tamanho da entrada aumenta.

Ana Maria Moura 4

2
1/19/2016

Como Medir?
• O esforço realizado por um algoritmo é calculado a partir
da quantidade de vezes que a operação fundamental é
executada.

• Para um algoritmo de ordenação, uma operação


fundamental é a comparação entre elementos quando à
ordem.

• Usando um medida assintótica como a Notação O em um


algoritmo com complexidade an2+bn+c, despreza-se os
termos de baixa ordem e ignoramos o coeficiente
constante. Logo o tempo de execução do algoritmo é igual
a n2, ou seja, O(n2).

Ana Maria Moura 5

Notação O - Principais Classes de


Problemas
• O (1) : constante – mais rápido, • f(n) = O(1).
impossível – Algoritmos de complexidade O(1) são
• O (log log n) : super-rápido ditos de complexidade constante.
• O (log n) : logarítmico – muito bom – Uso do algoritmo independe de n.
• O (n) : linear – é o melhor que se – As instruções do algoritmo são
pode esperar se algo não pode ser executadas um número fixo de vezes.
determinado sem examinar toda a
entrada
• O (n log n) : limite de muitos
problemas práticos, ex.: ordenar uma
coleção de números
• O (n2) : quadrático
• O (n3) : cúbico
• O (nk) : polinomial – ok para n
pequeno
• O (kn), O (n!), O (nn) : exponencial –
evite!

Ana Maria Moura 6

3
1/19/2016

Notação O - Principais Classes de


Problemas
• O (1) : constante – mais rápido, • f(n) = O(log n).
impossível – Um algoritmo de complexidade O(log
• O (log log n) : super-rápido n) é dito ter complexidade
• O (log n) : logarítmico – muito bom logarítmica.
• O (n) : linear – é o melhor que se – Típico em algoritmos que transformam
pode esperar se algo não pode ser um problema em outros menores.
determinado sem examinar toda a – Pode-se considerar o tempo de
entrada execução como menor que uma
• O (n log n) : limite de muitos constante grande.
problemas práticos, ex.: ordenar uma – Quando n é mil, log2n 10, quando n é
coleção de números 1 milhão, log2n 20.
• O (n2) : quadrático
• O (n3) : cúbico
• O (nk) : polinomial – ok para n
pequeno
• O (kn), O (n!), O (nn) : exponencial –
evite!

Ana Maria Moura 7

Notação O - Principais Classes de


Problemas
• O (1) : constante – mais rápido, • f(n) = O(n).
impossível – Um algoritmo de complexidade O(n) é
• O (log log n) : super-rápido dito ter complexidade linear.
• O (log n) : logarítmico – muito bom – Em geral, um pequeno trabalho é
• O (n) : linear – é o melhor que se realizado sobre cada elemento de
pode esperar se algo não pode ser entrada.
determinado sem examinar toda a – É a melhor situação possível para um
entrada algoritmo que tem de
• O (n log n) : limite de muitos processar/produzir n elementos de
problemas práticos, ex.: ordenar uma entrada/saída.
coleção de números – Cada vez que n dobra de tamanho, o
• O (n2) : quadrático tempo de execução dobra.
• O (n3) : cúbico
• O (nk) : polinomial – ok para n
pequeno
• O (kn), O (n!), O (nn) : exponencial –
evite!

Ana Maria Moura 8

4
1/19/2016

Notação O - Principais Classes de


Problemas
• O (1) : constante – mais rápido, • f(n) = O(n log n).
impossível – Típico em algoritmos que quebram um
• O (log log n) : super-rápido problema em outros menores,
• O (log n) : logarítmico – muito bom resolvem cada um deles
• O (n) : linear – é o melhor que se independentemente e ajuntando as
pode esperar se algo não pode ser soluções
determinado sem examinar toda a depois.
entrada – Quando n é 1 milhão, nlog2n é cerca de
• O (n log n) : limite de muitos 20 milhões.
problemas práticos, ex.: ordenar – Quando n é 2 milhões, nlog2n é cerca
uma coleção de números de 42 milhões, pouco mais do que
• O (n2) : quadrático o dobro.
• O (n3) : cúbico
• O (nk) : polinomial – ok para n
pequeno
• O (kn), O (n!), O (nn) : exponencial –
evite!

Ana Maria Moura 9

Notação O - Principais Classes de


Problemas
• O (1) : constante – mais rápido, • f(n) = O(n2).
impossível – Um algoritmo de complexidade O(n2) é
• O (log log n) : super-rápido dito ter complexidade
• O (log n) : logarítmico – muito bom quadrática.
• O (n) : linear – é o melhor que se – Ocorrem quando os itens de dados são
pode esperar se algo não pode ser processados aos pares, muitas
determinado sem examinar toda a vezes em um anel dentro de outro.
entrada – Quando n é mil, o número de
• O (n log n) : limite de muitos operações é da ordem de 1 milhão.
problemas práticos, ex.: ordenar uma – Sempre que n dobra, o tempo de
coleção de números execução é multiplicado por 4.
• O (n2) : quadrático – Úteis para resolver problemas de
• O (n3) : cúbico tamanhos relativamente pequenos.
• O (nk) : polinomial – ok para n
pequeno
• O (kn), O (n!), O (nn) : exponencial –
evite!

Ana Maria Moura 10

5
1/19/2016

Notação O - Principais Classes de


Problemas
• O (1) : constante – mais rápido, • f(n) = O(n3).
impossível – Um algoritmo de complexidade O(n3) é
• O (log log n) : super-rápido dito ter complexidade cúbica.
• O (log n) : logarítmico – muito bom – Úteis apenas para resolver pequenos
• O (n) : linear – é o melhor que se problemas.
pode esperar se algo não pode ser – Quando n é 100, o número de
determinado sem examinar toda a operações é da ordem de 1 milhão.
entrada – Sempre que n dobra, o tempo de
• O (n log n) : limite de muitos execução fica multiplicado por 8.
problemas práticos, ex.: ordenar uma
coleção de números
• O (n2) : quadrático
• O (n3) : cúbico
• O (nk) : polinomial – ok para n
pequeno
• O (kn), O (n!), O (nn) : exponencial –
evite!

Ana Maria Moura 11

Notação O - Principais Classes de


Problemas
• O (1) : constante – mais rápido, • f(n) = O(nk)
impossível ⁻ Algoritmo polinomial no tempo de
• O (log log n) : super-rápido execução tem função de
• O (log n) : logarítmico – muito bom complexidade O(p(n)), onde p(n) é
• O (n) : linear – é o melhor que se um polinômio.
pode esperar se algo não pode ser ⁻ A distinção entre estes dois tipos de
determinado sem examinar toda a algoritmos torna-se significativa
entrada quando o tamanho do problema a
• O (n log n) : limite de muitos ser resolvido cresce.
problemas práticos, ex.: ordenar uma ⁻ Os algoritmos polinomiais são mais
coleção de números úteis na prática que os exponenciais.
• O (n2) : quadrático
• O (n3) : cúbico
• O (nk) : polinomial – ok para n
pequeno
• O (kn), O (n!), O (nn) : exponencial –
evite!

Ana Maria Moura 12

6
1/19/2016

Notação O - Principais Classes de


Problemas
• O (1) : constante – mais rápido, impossível • f(n) = O(2n).
• O (log log n) : super-rápido – Um algoritmo de complexidade O(2n) é dito ter
• O (log n) : logarítmico – muito bom complexidade exponencial.
• O (n) : linear – é o melhor que se pode – Geralmente não são úteis sob o ponto de vista
esperar se algo não pode ser determinado prático.
sem examinar toda a entrada – Ocorrem na solução de problemas quando se
• O (n log n) : limite de muitos problemas usa força bruta para resolvê-los.
práticos, ex.: ordenar uma coleção de – Quando n é 20, o tempo de execução é cerca de
números 1 milhão. Quando n dobra, o tempo fica elevado
• O (n2) : quadrático ao quadrado.
• O (n3) : cúbico • f(n) = O(n!).
• O (nk) : polinomial – ok para n pequeno – Um algoritmo de complexidade O(n!) é dito ter
• O (kn), O (n!), O (nn) : exponencial – evite! complexidade exponencial, apesar de O(n!) ter
comportamento muito pior do que O(2n).
– Geralmente ocorrem quando se usa força bruta
na solução do problema.
– n = 20 ! -> 20! = 2432902008176640000, um
número com 19 dígitos.
– n = 40 ! -> um número com 48 dígitos.

Ana Maria Moura 13

Análise do Tempo de Execução


• Comando de atribuição, de leitura ou de escrita: O(1).
• Sequência de comandos: determinado pelo maior tempo de
execução de qualquer comando da sequência.
• Comando de decisão: tempo dos comandos dentro do comando
condicional, mais tempo para avaliar a condição, que é O(1).
• Laço: soma do tempo do corpo do laço mais o tempo de avaliar a
condição para terminação (geralmente O(1)), multiplicado pelo
número de iterações.
• Procedimentos não recursivos: cada um deve ser computado
separadamente um a um, iniciando com os que não chamam outros
procedimentos. Avalia-se então os que chamam os já avaliados
(utilizando os tempos desses). O processo é repetido até chegar no
programa principal.
• Procedimentos recursivos: associada uma função de complexidade
f(n) desconhecida, onde n mede o tamanho dos argumentos.

Ana Maria Moura 14

7
1/19/2016

Exemplos
• O(1) • O(log n)
X=5 While(x>1):
print(x) print(x)
x=x//2
• O(n) • O(n log n)
While(x<=n): For(y in range(1,n)):
print(x) x=y
x+=1 While(x>1):
print(x)
x=x//2

Ana Maria Moura 15

Exemplos
• O(n2) • O(n3)
While(x<=n):
While(x<=n):
while(y<=n):
while(y<=n): while(z<=n):
print(x*y) print(x*y*z)
z+=1
y+=1
y+=1
x+=1 x+=1

Ana Maria Moura 16

8
1/19/2016

Bibliografia
Ziviani, N. Projeto de Algoritmos Com Implementações em Pascal e C, Pioneira Thomson
Learning, 2004, segunda edição. (Livro Texto) -
http://www2.dcc.ufmg.br/livros/algoritmos/

Ana Maria Moura 17

Algoritmos e Estruturas de Dados

Profa. Ana Maria Moura

Ana Maria Moura 18