Anlise de complexidade

Introduo

Algoritmo: sequncia de instrues necessrias para a resoluo de

um problema bem formulado (passveis de implementao em
computador)
Estratgia:
especificar (definir propriedades)
arquitectura (algoritmo e estruturas de dados)
anlise de complexidade (tempo de execuo e memria)
implementar (numa linguagem de programao)
testar (submeter entradas e verificar observncia das propriedades
especificadas)
 Anlise de complexidade
Anlise de algoritmos

Provar que um algoritmo est correcto

Determinar recursos exigidos por um algoritmo (tempo, espao,
etc.)
comparar os recursos exigidos por diferentes algoritmos que
resolvem o mesmo problema (um algoritmo mais eficiente exige
menos recursos para resolver o mesmo problema)
prever o crescimento dos recursos exigidos por um algoritmo
medida que o tamanho dos dados de entrada cresce
 Anlise de complexidade
Anlise de algoritmos

Que dados usar ?

dados reais: verdadeira medida do custo de execuo
dados aleatrios: assegura-nos que as experincias testam o
algoritmo e no apenas os dados especficos
Caso mdio
dados perversos: mostram que o algoritmo funciona com qualquer
tipo de dados
Pior caso!
dados benficos:
Melhor caso
 Anlise de complexidade
Complexidade espacial e temporal

Complexidade espacial de um programa ou algoritmo: espao de

memria que necessita para executar at ao fim
S(n) : espao de memria exigido em funo do tamanho n da entrada
Complexidade temporal de um programa ou algoritmo: tempo que
demora a executar (tempo de execuo)
T(n) : tempo de execuo em funo do tamanho n da entrada
Complexidade vs. Eficincia
Por vezes estima-se a complexidade para o melhor caso (pouco
til), o pior caso (mais til) e o caso mdio (igualmente til)
 Anlise de complexidade
Complexidade temporal

Anlise precisa uma tarefa complicada

algoritmo implementado numa dada linguagem
a linguagem compilada e o programa executado num dado
computador
difcil prever tempos de execuo de cada instruo e antever
optimizaes
muitos algoritmos so sensveis aos dados de entrada
muitos algoritmos no so bem compreendidos
Para prever o tempo de execuo de um programa
apenas necessrio um pequeno conjunto de ferramentas
matemticas
 Anlise de complexidade
Crescimento de funes

O tempo de execuo geralmente dependente de um nico

parmetro n
ordem de um polinmio
tamanho de um ficheiro a ser processado, ordenado, etc.
ou medida abstracta do tamanho do problema a considerar
(usualmente relacionado com o nmero de dados a processar)
Quando h mais do que um parmetro
procura-se exprimir todos os parmetros em funo de um s
faz-se uma anlise em separado para cada parmetro
 Anlise de complexidade
Ordens de complexidade mais comuns

Os Algoritmos tm tempo de execuo proporcional a

1 : muitas instrues so executadas uma s vez ou poucas vezes (se
isto acontecer para todo o programa diz-se que o seu tempo de
execuo constante)
log n : tempo de execuo logartmico (cresce ligeiramente
medida que n cresce; quando n duplica log n aumenta mas muito
pouco; apenas duplica quando n aumenta para n2)
n : tempo de execuo linear (tpico quando algum processamento
feito para cada dado de entrada; situao ptima quando necessrio
processar n dados de entrada, ou produzir n dados na sada)
 Anlise de complexidade
Ordens de complexidade mais comuns

n log n : tpico quando se reduz um problema em subproblemas, se

resolve estes separadamente e se combinam as solues (se n igual
a 1 milho, n log n perto de 20 milhes)
n2 : tempo de execuo quadrtico (tpico quando necessrio
processar todos os pares de dados de entrada; prtico apenas em
pequenos problemas, ex: produto de vectores)
n3 : tempo de execuo cbico (para n = 100, n3 = 1 milho,
ex: produto de matrizes)
2n : tempo de execuo exponencial (provavelmente de pouca
aplicao prtica; tpico em solues de fora bruta; para n = 20,
2n = 1 milho; se n duplica, o tempo passa a ser o quadrado)
Anlise de complexidade
Ordens de complexidade mais comuns
 Anlise de complexidade
Notao de O grande

Na prtica, difcil (seno impossvel) prever com rigor o tempo de

execuo de um algoritmo ou programa
Para obter o tempo a menos de:
constantes multiplicativas (normalmente estas constantes so tempos
de execuo de operaes atmicas)
parcelas menos significativas para valores grandes de n
Identificam-se as operaes dominantes (mais frequentes ou muito
mais demoradas) e determina-se o nmero de vezes que so
executadas (e no o tempo de cada execuo, que seria uma
constante multiplicativa)
Exprime-se o resultado com a notao de O grande
 Anlise de complexidade
Notao de O grande

Definio: T(n) = O(f(n)) (l-se: T(n) de ordem f(n)) se e s se

existem constantes positivas c e n0 tal que T(n) c.f(n) para todo

o n > n0
Esta notao usada com trs objectivos:
limitar o erro que feito ao ignorar os termos menores nas frmulas
matemticas
limitar o erro que feito na anlise ao desprezar parte do programa
que contribui de forma mnima para o custo/complexidade total
permitir-nos classificar algoritmos de acordo com limites superiores
no seu tempo de execuo
 Anlise de complexidade
Notao de O grande

Exemplos:
ck nk+ ck-1 nk-1 +...+ c0 = O(nk)
(ci - constantes)

log2 n = O(log n)
(no se indica a base porque mudar de base multiplicar por uma
constante)
4 = O(1)
(usa-se 1 para ordem constante)
 Anlise de complexidade
Metodologia para determinar a complexidade

Considere-se o seguinte cdigo:

for i = 1:1:n
instrues;
end;
A contabilizao do nmero de instrues simples:
n iteraes e, em cada uma, so executadas um nmero
constante de instrues O(n)
 Anlise de complexidade
Metodologia para determinar a complexidade

Considere-se o seguinte cdigo:

for i = 1:1:n
for j = 1:1:n
instrues;
end;
end;
A contabilizao do nmero de instrues ainda simples:
o ciclo interno (for j) O(n) e executado n vezes O(n2)
 Anlise de complexidade
Eficincia da Pesquisa Sequencial
function [resultado] = PesquisaSequencial_1 (Elem, V, tam)
i = 1;
resultado = -1; % resultado = posio onde esta Elem em V (-1 = nao existe)
while i <= tam & resultado == -1
if Elem == V(i)
resultado = i;
elseif V(i) < Elem
i = i + 1;
else
resultado = -2;
end;
end;
 Anlise de complexidade
Eficincia da Pesquisa Sequencial
Eficincia temporal:
A operao realizada mais vezes o teste da condio de
continuidade do ciclo while, que no mximo n+1 vezes (no caso
de no encontrar x o pior caso)
Se x existir no vetor, o teste realizado aproximadamente
n/2 vezes (no caso mdio) e,
1 vez (no melhor caso)
Logo, T(n) = O(n) (linear) no pior caso e no caso mdio
 Anlise de complexidade
Eficincia da Pesquisa Binria Iterativa
function [k] = PesquisaBinariaIt (Elem, V, tam)
inicio = 1;
fim = tam;
k = -1;
while inicio <= fim & k == -1
meio = floor((inicio + fim) / 2);
if Elem == V(meio)
k = meio;
elseif Elem < V(meio)
fim = meio - 1;
else
inicio = meio + 1;
end;
end;
 Anlise de complexidade
Eficincia da Pesquisa Binria
Eficincia temporal:
Em cada iterao, o tamanho do subvetor a analisar dividido por um
fator de aproximadamente igual a 2
Ao fim de k iteraes, o tamanho do subvetor a analisar
aproximadamente igual a n/2k
Se no existir no vetor o valor procurado, o ciclo s termina quando
n/2k 1 log2 n - k 0 k log2 n
No pior caso, o nmero de iteraes aproximadamente igual a
log2 n. Logo, T(n) = O(log n) (logartmico)
 Anlise de complexidade
Eficincia da Ordenao por Borbulhagem

function [V] = OrdenarBorbulhagem (V, N)

Num_trocas = 1;
while Num_trocas ~= 0
Num_trocas = 0;
for k = 1:N-1
if V(k) > V(k+1)
aux = V(k);
V(k) = V(k+1);
V(k+1) = aux;
Num_trocas = Num_trocas + 1;
end;
end;
end;
 Anlise de complexidade
Eficincia da Ordenao por Borbulhagem
No melhor caso:
Apenas 1 execuo do ciclo for : n-1 comparaes e 0 trocas
No total : (n-1) operaes O(n)
No pior caso:
1 passagem pelo ciclo for : n1 comparaes e n1 trocas
2 passagem pelo ciclo for : n1 comparaes e n2 trocas
...
(n-1)-sima passagem pelo ciclo for: n-1 comparaes e 1 troca
Total de comparaes : (n-1)x(n-1) = n2 2n + 1
Total de trocas : (n-1) + (n-2) + ... + 1 = n(n-1)/2 = (n 2 n)/2
Total de operaes : (n2 2n + 1) + ((n2 n)/2) O(n2)
 Anlise de complexidade
Eficincia da Ordenao por Borbulhagem

function [V] = OrdenarBorbulhagem (V, N)

Num_trocas = 1;
while Num_trocas ~= 0
Num_trocas = 0;
for k = 1:N-1
if V(k) > V(k+1)
aux = V(k);
V(k) = V(k+1);
V(k+1) = aux;
Num_trocas = Num_trocas + 1;
end;
end;
end;
 Anlise de complexidade
Eficincia da Ordenao por Borbulhagem

No melhor caso:
Apenas 1 execuo do ciclo for : n-1 comparaes e 0 trocas
No total : (n-1) operaes O(n)
No pior caso:
1 passagem pelo ciclo for : n1 comparaes e n1 trocas
2 passagem pelo ciclo for : n2 comparaes e n2 trocas
...
(n-1)-sima passagem pelo ciclo for: 1 comparao e 1 troca
Total de comparaes : (n-1) + (n-2) + ... + 1 = n(n-1)/2
Total de trocas : (n-1) + (n-2) + ... + 1 = n(n-1)/2
Total de operaes : 2x(n(n1)/2) = n(n-1) = (n 2n) O(n2)