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

Notação O - Principais Classes de
Problemas
• O (1) : constante – mais rápido,
impossível
• O (log log n) : super-rápido
• O (log n) : logarítmico – muito bom
• O (n) : linear – é o melhor que se
pode esperar se algo não pode ser
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
Notação O - Principais Classes de
Problemas
• O (1) : constante – mais rápido,
impossível
• O (log log n) : super-rápido
• O (log n) : logarítmico – muito bom
• O (n) : linear – é o melhor que se
pode esperar se algo não pode ser
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
1/19/2016
• f(n) = O(log n).
– Um algoritmo de complexidade O(log
n) é dito ter complexidade
logarítmica.
– Típico em algoritmos que transformam
um problema em outros menores.
– Pode-se considerar o tempo de
execução como menor que uma
constante grande.
– Quando n é mil, log2n 10, quando n é
1 milhão, log2n 20.
7
• f(n) = O(n).
– Um algoritmo de complexidade O(n) é
dito ter complexidade linear.
– Em geral, um pequeno trabalho é
realizado sobre cada elemento de
entrada.
– É a melhor situação possível para um
algoritmo que tem de
processar/produzir n elementos de
entrada/saída.
– Cada vez que n dobra de tamanho, o
tempo de execução dobra.
8
4

Notação O - Principais Classes de
Problemas
• O (1) : constante – mais rápido,
impossível
• O (log log n) : super-rápido
• O (log n) : logarítmico – muito bom
• O (n) : linear – é o melhor que se
pode esperar se algo não pode ser
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
Notação O - Principais Classes de
Problemas
• O (1) : constante – mais rápido,
impossível
• O (log log n) : super-rápido
• O (log n) : logarítmico – muito bom
• O (n) : linear – é o melhor que se
pode esperar se algo não pode ser
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
1/19/2016
• f(n) = O(n log n).
– Típico em algoritmos que quebram um
problema em outros menores,
resolvem cada um deles
independentemente e ajuntando as
soluções
depois.
– Quando n é 1 milhão, nlog2n é cerca de
20 milhões.
– Quando n é 2 milhões, nlog2n é cerca
de 42 milhões, pouco mais do que
o dobro.
9
• f(n) = O(n2).
– Um algoritmo de complexidade O(n2) é
dito ter complexidade
quadrática.
– Ocorrem quando os itens de dados são
processados aos pares, muitas
vezes em um anel dentro de outro.
– Quando n é mil, o número de
operações é da ordem de 1 milhão.
– Sempre que n dobra, o tempo de
execução é multiplicado por 4.
– Úteis para resolver problemas de
tamanhos relativamente pequenos.
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,
impossível
• O (log log n) : super-rápido
• O (log n) : logarítmico – muito bom
• O (n) : linear – é o melhor que se
pode esperar se algo não pode ser
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!
• f(n) = O(nk)
⁻ Algoritmo polinomial no tempo de
execução tem função de
complexidade O(p(n)), onde p(n) é
um polinômio.
⁻ A distinção entre estes dois tipos de
algoritmos torna-se significativa
quando o tamanho do problema a
ser resolvido cresce.
⁻ Os algoritmos polinomiais são mais
úteis na prática que os exponenciais.

Ana Maria Moura 12

6
 1/19/2016

Notação O - Principais Classes de

Problemas
• O (1) : constante – mais rápido, impossível
• O (log log n) : super-rápido
• O (log n) : logarítmico – muito bom
• O (n) : linear – é o melhor que se pode
esperar se algo não pode ser 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!
• f(n) = O(2n).
– Um algoritmo de complexidade O(2n) é dito ter
complexidade exponencial.
– Geralmente não são úteis sob o ponto de vista
prático.
– Ocorrem na solução de problemas quando se
usa força bruta para resolvê-los.
– Quando n é 20, o tempo de execução é cerca de
1 milhão. Quando n dobra, o tempo fica elevado
ao quadrado.
• f(n) = O(n!).
– Um algoritmo de complexidade O(n!) é dito ter
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