Complexidade de Algoritmos

Adaptado por Dr. Ticongolo

(de Prof. Thales Castro)
Aula # 2 (Terica)

Complexidade de Algoritmos
Definio
A Complexidade de um Algoritmo consiste
na quantidade de trabalho necessria para
a sua execuo, expressa em funo das
operaes fundamentais, as quais variam de
acordo com o algoritmo, e em funo do
volume de dados
2

Complexidade de Algoritmos
Um algoritmo serve para resolver um
determinado problema, e todos os problemas
tm sempre uma entrada de dados (N)
O tamanho desse N afeta sempre diretamente
no tempo de resposta de um algoritmo
Dependendo do problema, j existem alguns
algoritmos prontos, ou que podem ser
adaptados
O problema : qual algoritmo a escolher?
3

Complexidade de Algoritmos
A complexidade de um algoritmo pode ser
dividido em:
Complexidade Espacial: Quantidade de recursos
utilizados para resolver o problema;
Complexidade Temporal: Quantidade de Tempo
utilizado. Pode ser visto tambm como o nmero de
instrues necessrias para resolver determinado
problema;

Em ambos os casos, a complexidade medida de

acordo com o tamanho dos dados de entrada (N)
4

Complexidade de Algoritmos
Existem trs escalas de complexidade:
Melhor Caso
Caso Mdio
Pior Caso

Nas trs escalas, a funo f(N) retorna a

complexidade de um algoritmo com entrada
de N elementos
5

Complexidade de Algoritmos
Melhor Caso
Definido pela letra grega (mega)
o menor tempo de execuo em uma entrada de
tamanho N
pouco usado, por ter aplicao em poucos casos.
Ex.:
Se tivermos uma lista de N nmeros e quisermos
encontrar algum deles assume-se que a complexidade
no melhor caso f(N) = (1), pois assume-se que o
nmero estaria logo na cabea da lista.
6

Complexidade de Algoritmos
Caso Mdio
Definido pela letra grega (Theta)
Dos trs, o mais difcil de se determinar
Deve-se obter a mdia dos tempos de execuo de todas as entradas de
tamanho N, ou baseado em probabilidade de determinada condio ocorrer
No exemplo anterior:

A complexidade mdia P(1) + P(2) + ... + P(N)

Para calcular a complexidade mdia, basta conhecer as probabilidades de Pi;
Pi = 1/N, 1 <= i <= N
Isso resulta em P(1/N) + P(2/N) + ... + P(N/N)
Que resulta em 1/N(1+2+...+N)
Que resulta em 1 N(N+1)
N
2
Que Complicao!!!
Que resulta em f(N) = (N+1)
2
7

Complexidade de Algoritmos
Pior Caso
Ser o caso utilizado durante esse curso
Representado pela letra grega O (O maisculo.
Trata-se da letra grega micron maiscula)
o mtodo mais fcil de se obter. Baseia-se no
maior tempo de execuo sobre todas as entradas
de tamanho N
Ex.:
Se tivermos uma lista de N nmeros e quisermos
encontrar algum deles, assume-se que a complexidade no
pior caso O (N), pois assume-se que o nmero estaria,
no pior caso, no final da lista.
8

Complexidade de Algoritmos
Mas como saber qual a complexidade de
um determinado algoritmo implementado?
Para resolver esse problema, dividiu-se os
algoritmos em Classes de Problemas, de
acordo com o parmetro que afeta o
algoritmo de forma mais significativa

Classes de Algoritmos

So elas:
1.
2.
3.
4.
5.
6.
7.

Complexidade Constante
Complexidade Linear
Complexidade Logartmica
NlogN
Complexidade Quadrtica
Complexidade Cbica
Complexidade Exponencial
10

Complexidade Constante
So os algoritmos de complexidade O(1)
Independe do tamanho N de entradas
o nico em que as instrues dos
algoritmos so executadas num tamanho
fixo de vezes
Function Vazia(Lista: TipoLista): Boolean;
Ex.:
Begin
Vazia := Lista.Primeiro = Lista.Ultimo;
End;

11

Complexidade Linear
So os algoritmos de complexidade O(N)
Uma operao realizada em cada elemento de
entrada, ex.: pesquisa de elementos em uma lista
Procedure Busca(Lista: TipoLista; x: TipoElem; Var pos: integer)

Var i: integer;
Begin

i:=1;
while Lista.Elemento[i] <> x do
i := i+1;
if i >= Lista.MaxTam then
pos := -1
else
pos := i;

End;

12

Complexidade Logartmica
So os algoritmos de complexidade O(logN)
Ocorre tipicamente em algoritmos que
dividem o problema em problemas menores
Ex.: O algoritmo de Busca Binria

13

Complexidade NLogN
Como o prprio nome diz, so algoritmos que
tm complexidade O(NlogN)
Ocorre tipicamente em algoritmos que
dividem o problema em problemas menores,
porm juntando posteriormente a soluo dos
problemas menores

14

Complexidade Quadrtica
So os algoritmos de complexidade O(N)
Itens so processados aos pares, geralmente
com um loop dentro do outro
Ex.:
Procedure SomaMatriz(Mat1, Mat2, MatRes: Matriz);

Var i, j: integer;
Begin
for i:=1 to n do
for j:=1 to n do
MatRes[i,j] := Mat1[i, j] + Mat2[i,j]; 15

Complexidade Cbica
So os algoritmos de complexidade O(N)
Itens so processados trs a trs, geralmente
com um loop dentro do outros dois
Ex.: Procedure SomaElementos_Vetor_Indices_Matriz
(mat: Matriz, vet: Vetor);
Var i, j: integer;
Begin
for i:=1 to n do
for j:=1 to n do
for k:=1 to n do
16

mat[i, j] := mat[i, j] + vet[k];

Complexidade Exponencial
So os algoritmos de complexidade O(2N)
Utilizao de Fora Bruta para resolv-los
(abordagem simples para resolver um
determinado problema, geralmente baseada
diretamente no enunciado do problema e nas
definies dos conceitos envolvidos)
Geralmente no so teis sob o ponto de vista
prtico
17

Ordens mais comuns

2n
(exponencial)

n2
(quadrtica)

n log n
f
n (linear)

log n (logartmica)
1 (constante)

18

A importncia da complexidade pode ser

observada no exemplo abaixo, que mostra 5
algoritmos A1 a A5 para resolver um mesmo
problema, de complexidades diferentes.
Supomos que uma operao leva 1 ms para
ser efectuada. A tabela seguinte d o tempo
necessrio por cada um dos algoritmos.
Tk(n) a complexidade do algoritmo.

T1(n)= n

T2(n)=nlog n

A2

A3
T3(n)=n2

A4
T4(n)=n3

A5
T5(n)=2n

16

0.016s

0.064s

0.256s

4s

1m4s

32

0.032s

0.16s

1s

33s

46 Dias

512

0.512s

9s

4m22s

1 Dia 13h

10137 Sculos

A1

Adaptado de Gonalo Madeira (Da Universidade do Algarve em Portugal)

20

Clculo da Complexidade
Foi visto que, para calcular a complexidade
de um algoritmo, deve-se analisar o pior
caso
A anlise deve ser feita no programa todo,
de acordo com a tabela a seguir

21

Algumas Operaes
com a Notao O

22

Alguns
Exemplos
Procedure Verifica_Item_Lista
(Lista: TipoLista; x: TipoItem; pos: integer);
Var i: integer;
Begin
O(1)
i:=1;
achou := false;
while (i <= Lista.Tamanho) and not achou do begin
inc(i);
if Lista.Item[i] = x then
achou := true;
end;
if achou then
O(1)
pos := i
else
pos := -1;

O(N)

f(N) = O(9 * O(1) + O(N)) = O(O(1) + (O(N)) = O(N) 23

Alguns Exemplos
Procedure Verifica_Item(Lista: TipoLista; x: TipoItem; pos: integer);
Var i: integer;
Begin
i:=1;
O(1)
achou := false;
while (i <= Lista.Tamanho) and not achou do
O(N)
if Lista.Item[i] = x then
achou := true;
O(1)
if achou then
pos := i
else
for i:= Lista.Tamanho +1 to MaxTam;
O(N)
Lista.Item[i] := x;
O(1)
24
f(N) = O(7 * O(1) + 2*O(N)) = O(O(1) + (O(N)) = O(N)

Alguns Exemplos - Recursividade

No caso da recursividade, depende da quantidade
de iteraes que se pode chegar
Ex.: se eu quiser saber os N primeiros termos de
um fatorial, a complexidade N
Function Fatorial (N: Integer): Integer;
Begin
If n=0 then Fatorial := 1
Else
Fatorial := N * Fatorial (N-1)
End;
25

Anlise de Recursividade
Fatorial
O(n) = 1,
= O(n-1) + 1,

se n = 0
se n > 1

mas quanto O(n-1) ?

26

Fatorial
= (O(n-1)) + 1
= (O(n-2) + 1) + 1
= O(n-2) + 2
= (O(n-3) + 1) + 2
= O(n-3) + 3
.....
forma geral, O(n) = O(n-k) + k, 1 k n
Como k o nmero do fatorial, fazendo n = k,
reduzimos a O(n) = n
27

Coclusao
A Complexidade de um Algoritmo consiste na
quantidade de trabalho necessria para a sua
execuo. Pode ser visto tambm como o nmero de
instrues necessrias ou tempo necessario para resolver
determinado problema;

Nesta cadeira, sempre que falar-se de

complixidade de algoritmos nos referimos ao pior
caso.

28

FIM
ISUTC
Maupto, Fevereiro de 2010

29