1.

Anlise de Complexidade de Algoritmos

1.1

Conceitos

Anlise de Algoritmos a rea da computao que visa determinar a

complexidade (custo) de um algoritmo, o que torna possvel:
Comparar algoritmos
Determinar se um algoritmo timo.
Custo de um algoritmo:
Tempo (nmero de passos)
Espao (memria)
Ex. 1: Organizar uma corda de tamanho T de maneira que ocupe o menor espao
possvel.
1. Enrolar no brao
(mesmo comprimento do lao)
2. Enrolar sobre si
(aumentando gradativamente o tamanho do lao)
3. Dobrar sucessivamente
(at que no seja mais possvel dobrar)
Qual o mtodo mais eficiente?
A complexidade de um algoritmo medida segundo um modelo matemtico
que supe que este vai trabalhar sobre uma entrada (massa de dados) de tamanho N.
O processo de execuo de um algoritmo pode ser dividido em etapas
elementares denominadas passos (nmero fixo de operaes bsicas, tempo
constante, operao de maior freqncia chamada dominante) . O nmero de
passos de um algoritmo considerado como o nmero de execues da operao
dominante em funo das entradas, desprezando-se constantes aditivas ou
multiplicativas.
Definimos a expresso matemtica de avaliao do tempo de execuo de
um algoritmo como sendo uma funo que fornece o nmero de passos efetuados
pelo algoritmo a partir de uma certa entrada.

Ex. 2: Soma de vetores

para I de 1 at N faa
S[I] X[I] + Y[I]
Fim para
Nmero de passos = nmero de somas (N)
Ex. 3: Soma de matrizes
Para I de 1 at N faa
Para J de1 at N faa
C[I,J] A[I,j] + B[I,J]
Fim para
Fim para
Nmero de passos = nmero de somas (N*N)
Ex. 4: Produto de matrizes
Para I de 1 at N faa
Para J de 1 at N faa
P[I,J] 0
Para K de 1 at N faa
P[I,J] P[I,J] + A[I,K] * B[K,J]
Fim para
Fim para
Fim para
Nmero de passos = Nmero de somas e produtos (N*N*N)
A complexidade pode ser qualificada quanto ao seu comportamento como:
Polinomial
A medida que N aumenta o fator que estiver sendo analisado (tempo ou
espao) aumenta linearmente.
Exponencial

A medida que N aumenta o fator que estiver sendo analisado (tempo ou

espao) aumenta exponencialmente.
Algoritmo com complexidade exponencial, no executvel para valores de
N muito grandes.

1.2

Notao

A notao O utilizada para expressar comparativamente o crescimento

assinttico (velocidade com que tende a infinito) de duas funes.
Por definio, f = O(g) se existe uma constante c > 0 e um valor n0 tal que
n > n0 f(n) c * g(n)
ou seja, g atua como limite superior para valores assintticos da funo f.
Funes elementares usadas como referncia: 1, n, lg n, n2, n lg n, 2n (lg indica
logaritmo na base 2)
Ex.:

f(n)

g(n)

2N + 5
N
127N * N + 457 * N
N*N*N+5

N
N
N*N
N*N*N

(f(n) = O(g(n))
Propriedades: Sejam f e g funes reais positivas e k uma constante. Ento
(i)
(ii)

O(f + g) = O(f) + O(g)

O(k * f) = k * O(f) = O(f)

A notao usada para exprimir limites superiores justos. Sejam f e g

funes reais positivas da varivel n.
f = (g) f = O(g) e g = O(f)

A notao exprime o fato de que duas funes possuem a mesma ordem de

grandeza assinttica.
Ex.: f = n2 1; g = n 2;
h = n3
ento
f O(g);
f O(h); g O(f) mas h no O(f).
Logo
f (g), mas f no (h).
A notao usada para exprimir limites inferiores assintticos.
Sejam f e g funes reais positivas da varivel n. Diz-se que f = (g) se
existe uma constante c >0 e um valor n0 tal que
n > n0 f(n) c * g(n)
Ex.: f = n2 1, ento so vlidas as igualdades:
f = (n) e
f= (1), mas no vale f = (n3).
1.3

Pior caso, melhor caso, caso mdio

Seja A um algoritmo, {E 1, ..., E m} o conjunto de todas as entradas possveis

de A. Seja t i o nmero de passos efetuados por A, quando a entrada for E i.
Definem-se:
complexidade do pior caso = max E i E{t i }
complexidade do melhor caso = min E i E{t i }
complexidade do caso mdio = 1 i m p i * t i
onde p i a probabilidade de ocorrncia da entrada E i .
1.4

Algoritmos timos

Seja P um problema. Um limite inferior par P uma funo l, tal que a

complexidade de pior caso de qualquer algoritmo que resolva P (l). Isto , todo
algoritmo que resolve P efetua, pelo menos, (l) passos. Se existir um algoritmo A,
cuja complexidade seja (l), ento A denominado algoritmo timo para P. Ou
seja, A apresenta a menor complexidade dentre todos os algoritmos que resolvem P.