Análise e Técnicas de Algoritmos

Análise assintótica
Tiago Massoni
Jorge Figueiredo
 Quanto consome?

20 km/litro

2 km/litro

válido
apenas
para
comparação...tempos
especificos
podem

variar
Sorting
 Insertion sort
1 j n
A:
ORDENADO
chave

Qual é a cara da entrada?

pior

melhor
7

ESQUEçam caso medio, vamos olhar para o pior - qual é o maximo onde podemos chegar.
e melhor: qual é o minimo de tempo que levaremos?
 Contando as instruções executadas

InsertionSort(A, n) custo vezes

for j ← 2 to n do c1 n
chave ← A[j] c2 n-1
▶ insere A[j] na parte ordenada A[1..j-1] 0 n-1
i ← j-1 c4 n-1
while i >0 e A[i]>chave do c5 ∑j=2..n tj
A[i+1] ← A[i] c6 ∑j=2..n (tj –1)
i ← i-1 c7 ∑j=2..n (tj –1)
A[i+1] ← chave c8 n –1

tj é o número de vezes que o teste do laço na

linha 5 é executado para j
T(n) = soma de custo × vezes, para total de
linhas
instruções consecutivas
cmd1;cmd2;
custo(cmd1 + cmd2)
if then else
custo(teste) + max (custo(then), custo(else))
laços
n * custo(bloco) + (n+1) * custo(teste)
 Calculando...
Melhor caso: laço while não
é executado nenhuma vez
Θ(n)
Pior caso: laço while é
executado j vezes
Θ(n2)
 Notação assintótica
f(n) = Ο(g(n))

f(n) = Ω(g(n))

f(n) = Θ(g(n))

mencionar que cada um dos simbolos representa um conjunto de funcoes

 Exercícios
6n3 = O(n2) ?
n / 1000 = O(n) ?

definicoes

O(g(n)) = {f(n) | ∃c:R, n0:N | 0 ≤ f(n) ≤ cg(n), n ≥ n0}

Ω(g(n)) = {f(n) | ∃c:R, n0:N | 0 ≤ cg(n) ≤ f(n), n ≥ n0}

prova por contradicao
6n^3 <= c2n^2
6n <= c2
n <=c2/6 (contradiz, porque c2 é uma constante)
 Taxas de Crescimento Mais Comuns

1 log n n n2 n3 ... nk ... 2n

constante logarítmica polinomial exponencial

2n
n2

log n
c
n
 Mergesort: divisão e
conquista

Fase de Fase de
Divisão top- Conquista
down bottom up

Its
worst‐case
running
:me
has
a
lower
order
of
growth
than
inser:on
sort.
Mergesort
MergeSort
(A,
inicio,
fim)
if
inicio
<
fim
then

 meio
←

(inicio
+
fim)/2


 MergeSort(A,
inicio,
meio)

 MergeSort(A,
meio
+
1,
fim)

 Merge(A,
inicio,
meio,
fim)


 Merge

recebe vetor que vai estar ordenado no final

•
p
≤
q
<
r
.
•
Subarray
A[p
.
.
q]
is
sorted
and
subarray
A[q
+
1
.
.
r
]
is
sorted.
By
the
restric:ons
on
p,
q,
r
,
neither
subarray
is
empty.
 Análise do MergeSort
Melhor caso = Caso médio = Pior caso

T(n) = divisão + solução +

combinação
divisão: tempo constante
solução: 2T(n/2)
combinação: ordem n

por que sao iguais?

ordenado ou não, ele vai até o final!

 Recorrência

na verdade Θ(n lgn)

Como calcular?
 Árvore de recursão
– verifique se o resultado é ordem
nlgn
– dicas
• calcule a altura da árvore
• n como potência de dois

13

lembre-se: uma árvore fornece um chute para ser provado pela substituicao
T(n)
 Tamanho do problema
em cada nível

nível 0: n
nível 1: n/2
nível 2: n/4
...
nível i: 1 = n/2i

pela equação: i = lg n
altura árvore: lgn
n. níveis: lgn + 1

Θ(nlgn)

caso
base
theta(1):
constante

c
Método Mestre
Resolve recorrências aT(n/b) + f(n), a ≥ 1, b > 1
Casos
1. Se f(n) ∈ O(nlogba- ε), para algum ε > 0, temos que:
T(n) ∈ Θ(nlogba)

1. Se f(n) ∈ Θ(nlogba), temos que:

T(n) ∈ Θ(nlogba.log n)

2. Se f(n) ∈ Ω(nlogba + ε), para algum ε > 0 e se a.f(n/b)≤c.f(n)

para algum c < 1 e n suficientemente grande, temos que:
T(n) ∈ Θ(f(n))
Método Mestre – Exemplo 1
MergeSort:
T(n) = 2.T(n/2) + n
a=b=2
f(n) = n
logba= 1. Cai no caso 2.
Logo, T(n) = Θ(n.log n)
 Exercício

T(n) = 9.T(n/3) + n
T(n)= 5T(n/2) + n3

a = 9, b = 3

f(n) = n

logba= 2. Se ε = 1, Cai no caso 1.

Logo, T(n) = Θ(n2)

segundo

a.f(n/b)≤c.f(n) para algum c < 1 e n suficientemente

grande
 Heapsort

Uma árvore binária completa em array

MAX-HEAP
filhos de i em 2i e 2i + 1
pai de i está em piso(i/2)

A representação é extremamente compacta

Permite caminhar pelos nós da árvore facilmente
 MAX-HEAPIFY
Custo

pior caso para uma heap com raiz em i e n elementos: 2n/3 elementos (qualquer subarvore
escolhida tem no maximo 2n/3 nos (metade cheia no ultima nivel))
Considera que i é um elemento raiz de duas subarvores já heapified
Exercicio: pelo metodo mestre, a = 1, b = 3/2, caso 2: T(n) = theta(lgn)
Exercicio: qual é o efeito de se chamar max-heapify para i > heapsize[A]/2
 BUILD-MAX-HEAP

Custo
Cada chamada MAX-HEAPIFY = O(lgn)
número de chamadas = n/2 = O(n)
Assim: T(n) = O(nlgn)
Correto, mas não é o mais apertado…

Invariante do laço: cada nó i+1, i+2, …, n é raiz de uma max-heap

 Custo para o BUILD-MAX-HEAP
• O tempo do MAX-HEAPIFY varia de acordo com o nível
corrente
• Propriedades assumidas
– altura = lgn
– Há no máximo n/2h+1 nós de altura h (h é contado de
baixo para cima)

h=0, n ≤ 1, máximo 1 nó em h=0

h=1, n ≤ 3, máximo 2 nós em h=0

h=2, n ≤ 7, máximo 4 nós em h=0

demora menos, menos chamadas recursivas para baixo (chega mais rapido no folha)

lembre-se: conta altura h debaixo para cima (de cima para baixo é profundidade)
 Custo para o BUILD-MAX-HEAP
Tempo requerido pela chamada do MAX-
HEAPIFY é O(lgn) = O(h)
Assim, custo total de BUILD-MAX-HEAP é
limitado por lg n
n
∑2 h +1
× O(h)
h= 0

simplificação

lg n lg n
h h
O(n€∑ h ) = O(n ∑ h )
h= 0 2 × 2 h= 0 2

demora menos, menos chamadas recursivas para baixo (chega mais rapido no folha)
para cada nós, execute MAXHEAPIFY, que tem custo O(h)…somatório me dá o número de nós na árvore toda, a partir do numero
de nós em cada nível

€
já simplifiquei eliminando os pisos e tetos
 Custo para o BUILD-MAX-HEAP
lg n ∞
h 1 h
O(n ∑ h ) = O(n ∑ h( ) )
h= 0 2 h= 0 2

k=hex=½
(½)/ (1 - ½)€
2=2

Resultado

Limite superior
mais apertado (linear)
8

demora menos, menos chamadas recursivas para baixo (chega mais rapido no folha)

esta
formula
de
somatorio
com
modulo
de
x
menor
que
1
soh
funciona
para
PGS
que
convergem
(soma
definida
por
esta
convergencia)
 Algoritmo heapsort

O(n): construir a estrutura heap

n -1 chamadas a MAX-HEAPIFY (O(lgn))
Custo = O (n) + O(nlgn) = O(nlgn)
9

1. Construir
o
heap
2. Troque
o
item
na
posição
1
do
vetor
(raiz
do
heap)
com
o
item
da
posição
n
3. Use
max‐heapify
para
recons:tuir
o
heap
para
os
itens
v[1],
v[2],
.
.
.
,
v[n
−
1]
4. Repita
os
passos
2
e
3
com
os
n
−
1
itens
restantes,
depois
com
os
n
−
2,
até
que
reste
apenas
um
item
 QuickSort
Divisão: escolher um pivô. dividir o array em duas
partes em torno do pivô
Conquista: Recursivamente ordenar os dois sub-arrays
Combinação: Trivial
pivô

Estado inicial não testados p

≤p >p não testados p

durante

Estado final ≤p p >p

11

Proposto por C.A.R. Hoare em 1962

Como o MergeSort, utiliza uma estratégia de divisão-e-conquista
Ao contrário do MergeSort, ordena in place
 Pior caso
• Quando o pivô é a menor (ou a maior) de todas
as chaves e esta situação se repete para todos os
níveis de particionamento
n
Número
de
Comparações:
0n-1

T(n)
=
(n
‐
1)
+
(n
‐
2)
+
(n
‐
3)

0n-2
+
…
+
1
0n-3
. T(n)
=
(n2
‐
n)
/
2
=
O(n2)
.
1

16

Pior caso: quando já está em ordem crescente, no caso da chave ser o

ultimo elemento
 Melhor caso
Dois subproblemas com tamanhos
similares
T (n/2) e T(n/2 - 1)
Recorrência
T(n) ≤ 2 T(n/2) + Θ(n)
Teorema mestre (caso 2)
Caso 2: O(nlgn)

17

-1 (pivo nao entra)

na pratica, melhor que o merge – caso médio é muito bom

 Caso médio
Mais próximo no melhor do que
do pior caso
Exemplo (parece
desbalanceado…)
T(n) ≤ T(9n/10) + T(n/10) + Θ(n)

18
árvore do quicksort

.
.

.
.
 Caso médio
T(n) = cn(log10n + 1) + algo menor que cn(log10/9n + 1)

T(n) ≤ cn(log10n + 1) + cn(log10/9n + 1)

[ignorar bases]
T(n) ≤ cn(lgn + 1) + cn(lgn + 1)
T(n) ≤ cnlgn + cnlgn + 2cn
T(n) = O(nlgn) Igual ao melhor caso!
20
Análise e Técnicas de Algoritmos

Análise assintótica
Tiago Massoni
Jorge Figueiredo
 Funções uteis

• Piso e teto
x : para qualquer x real, representa o
maior inteiro menor ou igual a x
x : para qualquer x real, representa o
menor inteiro maior ou igual a x
x – 1 < x ≤ x ≤ x < x + 1
n/2 + n/2 = n
a mod b = a - a/b b 26

5 mod 2 = 5 – piso(2,5)2 = 5 – 4 =
1
Funções uteis
Para qualquer a,b,c > 0
• Logaritmos
a = blogba
logb a = x  bx = a logc (ab) = logc a + logc b
logb an = n logb a
lg n = log2 n logc (a/b) = logc a - logc
b
lg n + k= lg(n) + k
logb a = logc a / logc b
lgk n = (lg n) k logb(1/a) = - logb a
log n = log10 n logb a = 1 / loga b
alogbc = clogba
27
 Somatórios

Série infinita: se o limite existir, a série

converge

If
the
limit
does
not
exist,
the
series
diverges;
otherwise,
it
converges.
The
terms
of
a
convergent
series
cannot
always
be
added
in
any

order.
 Somatórios

If
the
limit
does
not
exist,
the
series
diverges;
otherwise,
it
converges.
The
terms
of
a
convergent
series
cannot
always
be
added
in
any

order.
 Somatórios

para |x| < 1

soma
de
pg:
qual
a

razao?
Somatórios
 Análise assintótica

Previsão
aproximação

descrição de alto nível dos algoritmos

todas as possíveis entradas

independente do hardware e ambiente de

software
máquina idealizada com instruções básicas conhecidas

Metodologia para analisar tempo de execução de algoritmos

em vez de testar uma de suas implementações
 Algoritmos eficientes

Programas eficientes Melhor uso de

hardware

Vendem melhor

POR QUE ESTUDAR??

 The best
rápidos e econômicos
POR QUE ESTUDAR??
 Algoritmo

Partition
– Primeiro ou último elemento do vetor
– Elemento mediano do vetor
– Elemento que mais ocorre no vetor
– Elemento mais próximo da média aritmética dos elementos do vetor

12

A chamada inicial é QuickSort(A, 1,

length[A])
 FINAL

Fazer no quadro, usar exemplo do livro