Complexidade de Algoritmos e Recursividade

Complexidade de
Algoritmos
1
Complexidade de Algoritmos

Uma característica importante de qualquer
algoritmo é seu tempo de execução
–
–

2
é possível determiná-lo através de métodos
empíricos, considerando-se entradas diversas
é também possível obter este tempo a partir de
métodos analíticos
A análise dos algoritmos de ordenação e a
busca encontra-se entre as mais conhecidas e
utilizadas nos sistemas de computação
Complexidade de Algoritmos

Com freqüência, não se avalia a eficiência de
tempo de uma ordenação por unidades de tempo,
mas sim pelo número de operações críticas
efetuadas:
–
–
–

5
comparação de chaves
movimentação de elementos
troca de elementos
As operações críticas escolhidas são as que
consomem mais tempo
Complexidade de Algoritmos

Métodos analíticos
–
–
–
objetivo: determinar uma expressão matemática
que traduz o comportamento de tempo de um
algoritmo.
o resultado é uma fórmula dando o tempo médio
(ou o número de operações) para ordenar um
conjunto de tamanho n.
o tempo de execução independente:
 do
7
computador utilizado
 da linguagem e compiladores empregados
 e das condições locais de processamento
Complexidade de Algoritmos

Exemplo: Inversão de uma seqüência
fim = n/2;
for (i=0; i<fim; i++)
{ temp = S[i];
S[i] = S[n-1-i];
S[n-1-i] = temp;
}
9
Complexidade de Algoritmos

n = 5  troca S[i] por S[n-1-i]
–
–
–
fim = 2
i = 0  troca S[0] por S[5-1-0] (S[4])
i = 1  troca S[1] por S[5-1-1] (S[3])
inicial
0
10
1
final
2
3
4
0
1
2
3
4
M A R
I
A
A I
R
A M
Complexidade de Algoritmos

n = 6  troca S[i] por S[n-1-i]
–
–
–
–
fim = 3
i = 0  troca S[0] por S[6-1-0] (S[5])
i = 1  troca S[1] por S[6-1-1] (S[4])
i = 2  troca S[2] por S[6-1-2] (S[3])
inicial
11
final
0
1
2
3
4 5
E
S
T
A D O
0
1
2
O D A
3
4
5
T S
E
Complexidade de Algoritmos

n = 50  troca S[i] por S[n-1-i]
fim = 25
– i = 0  troca S[0] por S[50-1-0] (S[49])
– i = 1  troca S[1] por S[50-1-1] (S[48])
– i = 2  troca S[2] por S[50-1-2] (S[47])
.........
– i = 23  troca S[23] por S[50-1-23] (S[26])
– i = 24  troca S[24] por S[50-1-24] (S[25])
–
12
Complexidade de Algoritmos

O algoritmo executa exatamente as mesmas
operações para seqüências de tamanho n
–
cada passo corresponde à troca de posição
entre dois elementos da seqüência
a
13
execução das três atribuições
–
o número de passos é igual ao número de
vezes que executa o bloco for  n/2, n>1
–
Função: f(n) = 1 + 3(n)
Complexidade Constante - O(1)

Independe do tamanho de N (entradas)

É Executado em um número fixo de vezes
Function Inicializa( tp_pilha *pilha) {
pilha->topo = -1;
}
16
Complexidade Linear - O(n)

Um número de operações será executado
para cada N (entradas)
function display(int X) {
int i = 1;
while (i<=X) {
printf(“%d”, i*5); }
17
}
Complexidade Quadrática O(n2)
Itens são processados aos pares, geralmente
com um loop dentro do outro

function display(int X, int Y) {
int i, j;
for (i=1; i<=X;i++)
for (j=1; j<= Y; j++){
printf(“%d”, i+j); }
18
}
A notação O

Complexidade
–
desprezar algumas operações
interesse assintótico - termos de menor grau podem ser
desprezados: n2 + n será aproximado para n2
 6n3 + 4n - 9 será aproximado para n3


A função O atua como um limite superior
assintótico da função f:
–
–
–
19
–
f
f
f
f
=
=
=
=
n2 -1
403
5+2logn +3log2n
5*2n +5*n10




f
f
f
f
=
=
=
=
O(n2)
O(1)
O(log2n)
O(2n)
A notação O

Algoritmo de inversão de seqüência:
–
o número de passos se mantém o mesmo
para o mesmo valor de n
variável independente é n
efetua sempre n/2 passos
–
complexidade é O(n)
–
–
20
Alguns conceitos








21
T (n) =
T (n) =
T (n) =
T (n) =
T (n) =
T (n) =
T (n) =
T (n) =
O (1) : constante
O (log log n) : super-rápido
O (log n) : logarítmico – muito bom
O (n) : linear – toda a entrada é visitada
O (n log n) : limite de muitos problemas
O (n2) : quadrático
O (nk) : polinomial no tamanho da entrada
O (kn), O (n!), O (nn) : exponencial – ruim!
Gráfico comparativo
22
Recursividade
23
Recursividade


Um módulo recursivo é aquele que contém
uma ou mais chamadas a si mesmo
Programas recursivos:
–
–
–
24
são mais concisos e normalmente menores
podem ficar mais lentos por usar muitas posições
de memória
principal vantagem: poder utilizar funções
recursivas para criar versões mais claras e
simples, principalmente buscas e ordenações
Recursividade

Todo processo recursivo consiste de
duas partes:
–
–
25
Solução Trivial: é conseguida por definição,
ou seja, não é necessário fazer uso de
recursividade para obtê-la
Solução Geral: solução genérica que
funciona em uma parte menor do problema
original, mas que pode ser aplicada
integralmente ao problema original
Recursividade
Exemplo: Fatorial
1, se n=0 (solução trivial)
 n! =
n * (n-1)!, se n>0 (solução geral)

26
4!
3!
2!
1!
0!
=
=
=
=
=
4
3
2
1
1
*
*
*
*
3!
2!
1!
0!
recursão
recursão
recursão
não recursão
não recursão
Exemplo - Fatorial
#include <stdio.h>
int fat (int n);
main( ) {
int n, res;
scanf("%d", &n);
res=fat(n);
printf("Fatorial: %d\n", res);
}
int fat (int n) {
if (n) /* (n != 0) */
return n * fat(n-1);
else
return 1;
27
}
(1) res
?
(2) res
?
(3) res
?
?
fat
3
n
?
?
?
?
fat
0
1
2
3
n
(4) res
?
(5) res
6
1
?
?
?
fat
0
1
2
3
n
1
1
2
6
fat
0
1
2
3
n