Introduo Complexidade de Algoritmos

rea que visa determinar a complexidade (custo) de

um algoritmo, com isso possvel:
y Comparar algoritmos: existem algoritmos que
resolvem o mesmo tipo de problema.
y Determinar
D t i se o algoritmo
l it ti os algoritmos
timo: l it
apresentam um limite inferior para a sua
complexidade (definido matematicamente).
|Se a complexidade tima ento est abaixo
deste limite.

Fonte: UFPB (http://www.slideshare.net/alexandrend/anlise-de-complexidade-de-algoritmos)

Introduo Complexidade de Algoritmos

| Um algoritmo serve para resolver um determinado

problema, e todos os problemas tm sempre uma
entrada de dados
| O tamanho dessa entrada (N) tem geralmente
efeito direto no tempo de resposta de um algoritmo
| Dependendo do problema a ser resolvido
resolvido, j
existem algoritmos prontos ou que podem ser
adaptados

| O problema : qual algoritmo escolher?

Introduo Complexidade de Algoritmos

| Pode-se falar de dois tipos de complexidade de

algoritmos :
y Complexidade Espacial: Quantidade de recursos
utilizados p
para resolver o p
problema;;
y Complexidade Temporal: Quantidade de tempo utilizado.
| Pode ser vista tambm como o nmero de instrues
necessrias para resolver um determinado problema;
| Em ambos os casos, a complexidade medida de
acordo com o tamanho dos dados de entrada (n)
| Estamos mais interessados em calcular a
Complexidade Temporal de um algoritmo!
Introduo Complexidade de Algoritmos

| Existem trs perspectivas para anlise de

complexidade:
y Melhor Caso ()
y Caso Mdio ()
y Pior Caso (O)
| Nas trs perspectivas
perspectivas, a funo f(n) retorna a
complexidade de um algoritmo com entrada de
tamanho n
Introduo Complexidade de Algoritmos

ANLISE DO MELHOR CASO

| Definido pela letra grega (mega)

| Exprime o menor tempo de execuo de um
algoritmo
g p
para uma entrada de tamanho n
| pouco usado, por ter aplicao em poucos
casos.
casos
| Ex.:
y O algoritmo de pesquisa sequncial em um vetor tem
complexidade f(n) = (1)
y A anlise assume que o nmero procurado seria o
primeiro selecionado na lista.
| Abordagem otimista!
Introduo Complexidade de Algoritmos

ANLISE DO CASO MDIO

| Definido p
pela letra g
grega
g ((Theta))
| Deve-se obter a mdia dos tempos de execuo
de todas as entradas de tamanho n n, ou baseado
em probabilidade de determinada condio ocorrer
| Ex.:
Ex :
y O algoritmo de pesquisa sequncial em um vetor tem
complexidade f(n) = (n/2)
y Em mdia ser necessrio visitar n/2 elementos do vetor
at encontrar o elemento procurado
p
| Melhor aproximao
| Muito difcil de determinar na maioria dos casos
Introduo Complexidade de Algoritmos

ANLISE DO PIOR CASO

| Representado pela letra grega O (big O)

y Big O maisculo. Trata-se da letra grega micron
maiscula
| Baseia-se no maior tempo de execuo sobre
todas as entradas de tamanho n (ordem de
grandeza)
| o mtodo mais fcil de se obter ((o mais usado).
)
| Ex.:
y O algoritmo de pesquisa sequncial em um vetor tem
complexidade f(n) = O(n)
y No p
pior caso ser necessrio visitar todos os n
elementos do vetor at encontrar o elemento procurado
| Abordagem pessimista!
Introduo Complexidade de Algoritmos

A Notao
O
| Tempo (ou espao) contabilizado em nmero de
passos do algoritmo (unidade de armazenamento)
| Anlise do algoritmo determina uma funo que
depende do tamanho da entrada n n.
| medida que n aumenta, aumenta a
complexidade do algoritmo (esforo
computacional)

8
Introduo Complexidade de Algoritmos

A Notao
O
| Desprezar constantes aditivas ou multiplicativas
y Nmero de passos 3n ser aproximado para n
| Interesse assinttico
y termos de menor grau podem ser desprezados
| n2 + n ser aproximado para n2
| 6n3 + 4n - 9 ser aproximado para n3

9
Introduo Complexidade de Algoritmos

Clculo da complexidade
p do algoritmo
g
| Foi visto que, para calcular a complexidade de um
algoritmo, deve-se
deve se analisar o pior caso (O(x))
| A anlise deve ser feita de acordo com a tabela a
seguir

N
Nmero de
d Operaes
O C
Complexidade
l id d
f(n) O(f(n))
c x f(n) O(f(n))
f(n) + f(n) O(f(n))
f(n) + g(n) O(max(f(n),g(n))
f(n) x g(n) O(f(n) x g(n))
 Introduo Complexidade de Algoritmos

Tcnicas de anlise da complexidade do algoritmo

| Alguns princpios podem ser seguidos:
1. O tempo de execuo de um comando de atribuio, de
leitura ou de escrita pode ser considerado como O(1).
2. O tempo de execuo de um comando de deciso O(1);

3 O tempo para executar um looping a soma do tempo de

3.
execuo do corpo do looping, multiplicado pelo nmero de
iteraes do looping
looping.
4. Quando o programa possui funes no recursivas, o tempo
de execuo de cada funo deve ser computado
separadamente um a um, iniciando com funes que no
chamam outras funes
funes.
Introduo Complexidade de Algoritmos

Clculo da complexidade
p do algoritmo
g Ex1

f(x)=1
f(x) 1+1+1+n*(n*(n*(1+1+1+3
)))
3+n*n* n*6
3 + 6n3 Desprezou-
se os
f(x) = O(n3) termos de
menor grau
ORDENS DE ALGORITMOS
| Complexidade Constante
| Complexidade Linear

| Complexidade Logartmica

| Complexidade Log Linear

| Complexidade Quadrtica

| Complexidade Cbica

| Complexidade Exponencial

| Complexidade Fatorial
COMPLEXIDADE CONSTANTE - O(1)
| So os algoritmos onde a complexidade independe
do tamanho n de entradas
| o nico em que as instrues dos algoritmos so
executadas um nmero fixo de vezes

if (condio == true) then { 1+(

realiza alguma operao em tempo constante 1
} )
else { 1+(
g
realiza alguma operao
p em tempo
p constante 1
} )

| f( ) = 1
f(x) 1+(1)*1+(1)
(1)*1 (1) = 4 => O(1)
COMPLEXIDADE LINEAR O(N)
| Uma operao realizada em cada elemento de
entrada, ex.: pesquisa de elementos em uma lista
for (i = 0; i < N; i++) { n*(
if (condio == true){ 1+(
comandos de leitura, escrita ou condicionais; 1
} )
else { 1+(
comandos de leitura, escrita ou condicionais; 1
} )
} )

| f(x) = n*(1+(1)*1+(1))=> n*(2*2) = n(4) =>O(n)

COMPLEXIDADE LOGARTMICA -
O(LOG2N)
| Ocorre tipicamente em algoritmos que dividem o problema em problemas
menores
int PesquisaBinaria ( int array[], int chave , int N){ (
int inf = 0; 1+
int sup = N - 1; 1+
int meio; 1
while (inf <= sup) { n*(
meio = (inf+sup)/2; 1+
if (chave == array[meio]){ 1+(
return meio; 1
} )
else{ 1+(
if (chave < array[meio]){ 1+(
sup = meio-1; 1
} )
else{ 1+(
inf = meio+1; 1
} )
} )
} )
return -1; // no encontrado 1
} )

| f(x) = (1+1+1*n*(1+1+(1)*1+(1+(1)*1+(1)))*1) = 3*n(6). Como Log2(6) = 3 => (Log2(n))

COMPLEXIDADE LOG LINEAR
O(NLOG2N)
| Ocorre tipicamente em algoritmos que dividem o
problema em problemas menores, porm juntando
posteriormente a soluo dos problemas menores.

void merge(int inicio, int fim) {

if (inicio < fim) {
int meio = (inicio + fim) / 2;
merge(inicio meio);
merge(inicio,
merge(meio + 1, fim);
mesclar(inicio, meio, fim);
}
}
COMPLEXIDADE QUADRTICA O(N)
| Itens so processados aos pares, geralmente com
um loop dentro do outro

void bubbleSort(int[] a) { (
for (int i = 0; i < a.length-1; i++) { n*(
for (int j = 0; j < a.length
a length-1;
1; jj++)) { n*((
n
if (a[j] > a[j+1]) { 1+(
swap(a, j, j+1); 3
} )
} )
} )
} )

| f(x) = (n*(n*(1+(3)))) = (n*(n+4)) = n2+4n => O(n2)

COMPLEXIDADE CBICA O(N)
| Itens so processados trs a trs, geralmente com
um loop dentro do outros dois

int dist[N][N]; 1
1+
int i, j, k; 1+

for ( k = 0; k < N; k++ ) n*(

f ( i = 0; i < N; i++ )
for n*(
*(
for ( j = 0; j < N; j++ ) n*(
dist[i][j] = min( dist[i][j], dist[i][k] + dist[k][j] ); 1)))

| f(x) = 1+1+n*(n*(n*(1))) = 4+n3 => O(n3)

COMPLEXIDADE EXPONENCIAL O(2N)
| Utilizao de Fora Bruta para encontrar a
soluo de um problema.
| A soluo geralmente baseada diretamente no
enunciado do problema e nas definies dos
conceitos envolvidos
| Ex.:
Ex :
y Utilizando apenas nmeros possvel criar 10n senhas
de n dgitos
y Um algoritmo de fora bruta para quebrar uma dessas
senhas tem complexidade O(2n)
COMPLEXIDADE FATORIAL O(N!)
| Tambm baseada na utilizao de fora bruta
para encontrar a soluo de um problema
| Consiste em testar todas as possveis
permutaes existentes na soluo procura da
soluo tima para o problema
| Ex.:
Ex : Problema do Caixeiro Viajante
y Encontrar a rota mnima para visitar vrias cidades sem
repetir nenhuma
y um problema base para o projeto de microchips,
sequnciamento de genma e muitas outras aplicaes
y No possui soluo exata eficiente (Problema NP)
y Utilizao de heursticas para aproximar a soluo tima 22
 ORDENS DE COMPLEXIDADE
| Imagine um computador que leva 1ms (0,00s) para
executar uma operao.
| A tabela abaixo indica o tempo aproximado de
execuo de um algoritmo com diferentes ordens
de complexidades para 3 tamanhos de entrada

n O(n) Log2(n) nLog2(n) O(n2) O(n3) O(2n) O(n!)

16 0.016s 0.004s 0.064s 0.256s 4s 1m5s 663 anos
32 0.032s 0.005s 0.16s 1s 33s 49 dias 1023 sec
512 0.512s 0.009s 4.608s 4m22s 37h
h 10143 sec ...

23
 Introduo Complexidade de Algoritmos

Exemplo de estudo comparativo da complexidade de algoritmos:

- Dado 3 algoritmos
algoritmos, verificar
erificar q
qual
al deles demanda maior ccusto,
sto
seguindo o princpio do pior caso.

| Algoritmo 1: Soma de vetores:

for(i=0;i<n;i++){
for(i 0;i n;i ){ n(
n*(
S[i] = X[i] + Y[i]; 1
} )

f(x) = n*(1) => f(x) = O(n)

E complexidade
Ento, l id d lilinear (O(
(O(n))
))
 Introduo Complexidade de Algoritmos

Exemplo de estudo comparativo da complexidade de algoritmos - continuao

| Algoritmo 2: Soma de matrizes:

for(i=0;i<n;i++){ n*(
for(j=0;j<n;j++){
for(j 0;j n;j ){ n*((
n
C[i,j] =A[i,j] + B[i,j]; 1
} )
} )
g(x) = n*(n*(1)) => h(x) = O(n2)
Ento, grau de complexidade quadrtica (O(n2))
 Introduo Complexidade de Algoritmos

Exemplo de estudo comparativo da complexidade de algoritmos - continuao

| Algoritmo 3: Produto de matrizes:

f (i 0 i< i++){
for(i=0;i<n;i++){ n*(
*(
for(j=0;j<n;j++){ n*(
P[i,j] =0; 1+
for(k=0;k<n;k++){
( ; ; ){ n*((
P[i,j] = P[i,j] + A[i,k] * B[k,j] 1
} )
} )
} )

h(x) = n*(n*(1+n*(1))) = n*(n*(1+n)) = n*(n+n2) = n*(n2)=>h(x)=

) >h(x) O(n3)
Ento, grau de complexidade cbica (O(n3))
 Introduo Complexidade de Algoritmos

Exemplo de estudo comparativo da complexidade de algoritmos - continuao

| Comparando agora os trs algoritmos dos

exemplos anteriores, temos:

| f(x)+g(x)+h(x)
f( )+ ( )+h( ) = max(O(n),O(n
(O( ) O( 2),O(n
) O( 3))
| Dessa forma, conclumos que o algoritmo que teve
o maior custo foi o do exemplo 3 (h(x) = O(n3)),
pois o expoente do grau de complexidade (n) o
maior
i o maior
i d deles
l ((expoente
t 3)
3).
| Ento, seu grau de complexidade resultante
cbico.
27
 Introduo Complexidade de Algoritmos

Exerccios
| Informe a complexidade dos algoritmos abaixo:
1. i t a,b,
int b aux;
scanf(%d%d,&a,&b);
aux = a;
a = b;
b = aux;
printf(%d , %d
%d,a,b);
a b);
 Introduo Complexidade de Algoritmos

Exerccios
2. float media, notas[100];
int ii, soma = 0
0, media;
for(i=0;i<=100;i++)
{
printf(entre com a nota);
scanf(%d,&notas[i]);
soma = soma + notas[i];
}
media
ed a = so
soma/100;
a/ 00;
printf(A media : %d, media);
 Introduo Complexidade de Algoritmos

Exerccios
3. for(i=0;i<=N_LIN1;i++)
{
for(j=0;j<=N_COL2;j++)
{
C[i,j] = 0;
for(k=0;k<=N_COL1;k++)
{
C[i,j] = C[i,j] + A[i,k] * B[k,j];
}
}
}
 Introduo Complexidade de Algoritmos

Exerccios
4. for(j=1;j<=n;j++){
for(k=1;k<=n;k++){
p=p+1;
}
}
 Introduo Complexidade de Algoritmos

Exerccios
| Faa agora um estudo comparativo e determine qual ou
quais dos 4 algoritmos do exerccios anterior tem a maior
complexidade
 Introduo Complexidade de Algoritmos

Exerccios
| Prova de concursos:
(ENADE-2005-Q15) - Considere o algoritmo que implementa o
seguinte processo: uma coleo desordenada de elementos
dividida em duas metades e cada metade utilizada como
argumento t para a reaplicao
li recursiva
i d do procedimento.
di t O Os
resultados das duas reaplicaes so, ento, combinados
pela intercalao dos elementos de ambas
ambas, resultando em
uma coleo ordenada. Qual a complexidade desse
algoritmo?
(A) O(n2)
(B) O(n2n)
(C) O(2n)
(D) O(log n log n)
(E) O(n log n)
 UNIDADE II
Introduo Complexidade
p de Algoritmos
g
FIM