Documenti di Didattica
Documenti di Professioni
Documenti di Cultura
Campus de Ituiutaba
Engenharia da Computao
APOSTILA DE
ANLISE DE ALGORITMOS
2014
Anlise de Algoritmos
Sumrio
1 Desenvolvimento de Algoritmos ..................................................................................................................... 2
1.1 Introduo ................................................................................................................................................. 2
1.2 O que um algoritmo ............................................................................................................................... 2
1.3 Medidas de Complexidade ....................................................................................................................... 2
1.4 Anlise de Complexidade de um algoritmo .............................................................................................. 6
1.5 Notao O ................................................................................................................................................. 6
1.6 Convenes para as expresses de O........................................................................................................ 8
1.7 Exemplo de anlise da notao O ............................................................................................................. 8
1.8 Anlise de complexidade da Busca Linear ............................................................................................... 9
1.8.1 Pior Caso ......................................................................................................................................... 10
1.8.2 Caso Mdio...................................................................................................................................... 10
1.8.3 Melhor Caso .................................................................................................................................... 11
1.8.4 Um exemplo numrico .................................................................................................................... 11
1.9 Exerccios .............................................................................................................................................. 12
1.10 - Exerccio Prtico Algoritmo Busca a primeira ocorrncia: ................................................................... 13
2 Estratgias Bsicas ........................................................................................................................................ 14
2.1 Refinamento Sucessivo........................................................................................................................... 14
2.2 Modularizao ........................................................................................................................................ 14
2.3 Confiabilidade X Complexidade ............................................................................................................ 15
3 Diviso e Conquista ....................................................................................................................................... 16
3.1 Mximo e Mnimo de uma lista .............................................................................................................. 16
3.2 Exerccio MaxMin .................................................................................................................................. 20
3.3 Ordenao por Intercalao .................................................................................................................... 21
3.4 Ordenao por Concatenao ................................................................................................................. 23
3.5 Busca Binria.......................................................................................................................................... 25
3.6 Exerccio prtico de Busca Binria......................................................................................................... 26
3.7 - Lista de Exerccios da Unidade ............................................................................................................... 27
4 - Mtodos de Ordenao ................................................................................................................................... 29
4.1 - Mtodos de Ordenao Interna................................................................................................................ 29
4.2 - Mtodo de ordenao por Seleo........................................................................................................... 30
4.2.1 - Algoritmo de Ordenao por seleo: .............................................................................................. 30
4.2.2 - Anlise de complexidade ................................................................................................................. 30
4.3 - Mtodo de ordenao por Insero ......................................................................................................... 31
4.3.1 - Algoritmo de Ordenao por Insero ................................................................................................. 31
4.3.2 - Anlise de complexidade do algoritmo ................................................................................................ 32
4.4 - Mtodo de ordenao Quicksort.............................................................................................................. 33
4.4.1 - Algoritmo Partio ........................................................................................................................... 34
4.4.2 - Verso recursiva do Quicksort ......................................................................................................... 34
4.4.3 - Outra verso recursiva do Quicksort ................................................................................................ 34
4.4.4 - Verso iterativa do Quicksort ........................................................................................................... 35
4.4.5 - Concluso ......................................................................................................................................... 39
4.5 - Mtodo de ordenao Shellsort ............................................................................................................... 40
4.5.1 Algoritmo Shellsort ......................................................................................................................... 41
4.5.2 - Anlise do algoritmo ........................................................................................................................ 41
4.6 - Mtodo de ordenao Heapsort ............................................................................................................... 42
4.6.1 - Fila de prioridades ............................................................................................................................ 42
4.6.2 - Heaps................................................................................................................................................ 43
4.6.3 - Heapsort ........................................................................................................................................... 43
4.6.4 - Anlise de complexidade do Heapsort ............................................................................................. 45
4.6.5 - Concluso ......................................................................................................................................... 46
4.7 - Comparao entre os mtodos de ordenao........................................................................................... 46
4.8 - Exerccios ................................................................................................................................................ 48
4.9 Exerccio prtico de Ordenao .............................................................................................................. 50
4.9.1 Exerccio prtico com os algoritmos Insero e seleo .......................................................... 50
4.9.2 Exerccio prtico com os algoritmos de ordenao ......................................................................... 51
Pg. 1
Anlise de Algoritmos
1 Desenvolvimento de Algoritmos
1.1 Introduo
Pg. 2
Anlise de Algoritmos
Complexidade de tempo
A1
A2
n log 2 n
A3
n2
A4
n3
A5
2n
Complexidade de tempo
1 segundo
1 minuto
1 hora
A1
1.000
60.000
3.600.000
A2
n log 2 n
140
4893
200.000
A3
n2
31,6
244,9
1.897,4
A4
10
39,2
153,3
A5
2n
15
21
Clculos, A1:
T(n) = n * UT
1 = n * 10
T(n) = n * UT
-3
60 = n * 10
n = 1000
T(n) = n * UT
-3
3600 = n * 10-3
n = 36 * 105
n = 60000
A2:
T(n) = n log n* UT
1 = n log n * 10
-3
n log n = 103
n = 140
T(n) = n log n* UT
60 = n log n * 10
n log n= 6 * 104
n = 4893
-3
T(n) = n log n* UT
3600 = n log n * 10-3
n log n = 36 * 105
n = 2 * 105
Pg. 3
Anlise de Algoritmos
A3:
T(n) = n2 * UT
T(n) = n2 * UT
1 = n2 * 10-3
T(n) = n2 * UT
60 = n2 * 10-3
n = 31,6
n = 244,9
T(n) = n3 * UT
T(n) = n3 * UT
3600 = n2 * 10-3
n = 1897,4
A4:
T(n) = n3 * UT
1 = n3 * 10-3
60 = n3 * 10-3
3600 = n3 * 10-3
n = 10
n = 32,9
n = 153,3
A tabela apresenta uma comparao relativa de grandeza para vrias funes que podem ser
encontradas em algoritmos. Podemos ter a noo da ordem de crescimento dos algoritmos.
n
1
10
100
1000
Log 2 n
0
3,32
6,64
9,97
1
10
100
1000
Tipo de Funo
N log 2 n
n2
0
1
33
100
664
10.000
9970
1.000.000
n3
1
1000
1.000.000
109
2n
2
1024
1,268*1030
1,072*10301
Supondo que a prxima gerao de computadores seja dez vezes mais rpido que a atual. A
tabela abaixo mostra o aumento no tamanho do problema que o algoritmo possa resolver no
mesmo tempo.
Algoritmo
A1
A2
A3
A4
A5
Complexidade de tempo
n
n log 2 n
n2
n3
2n
Mximo atual
S1
S2
S3
S4
S5
Clculos:
A1
Atual: T(n) = S1 * 1 UT
Futuro: T(n) = ( n * 1UT) / 10
T(n) = T(n)
S1 * 1 UT = (n * 1UT) / 10
.n = 10 * S1
A3
Atual: T(n) = S3 * 1 UT
Futuro: T(n) = ( n2 * 1UT) / 10
T(n) = T(n)
S3 * 1 UT = (n2 * 1UT) / 10
. 2
n = 10 S3
.n 3 S3
A5
Atual: T(n) = 2S5 * 1 UT
Futuro: T(n) = ( 2n * 1UT) / 10
T(n) = T(n)
2S5 * 1 UT = ( 2n * 1UT) / 10
2S5 = 2n /10
2n = 10 * 2n = 10 * 2S5
.n = log2 10 + S5
.n = 3 + S5
20
0,0002 segundos
0,0009 segundos
0,004 segundos
0,08 segundos
10 segundos
580 minutos
Valor de n
40
0,0004 segundos
0,0021 segundos
0,016 segundos
0,64 segundos
127 dias
38550 sculos
60
0,0006 segundos
0,0035 segundos
0,036 segundos
2,16 segundos
3660 sculos
1,3*1014 sculos
Pg. 4
Anlise de Algoritmos
Complexidade
Tamanho n
10
20
30
40
50
0,00001 s
0,00002 s
0,00003 s
0,00004 s
0,00005 s
n2
0,0001 s
0,0004 s
0,0009 s
0,0016 s
0,0035 s
n3
0,001 s
0,008 s
0,027 s
0,064 s
0,125 s
2n
0,001 s
1s
17,9 minutos
12,7 dias
35,7 anos
3n
0,059 s
58 minutos
6,5 anos
3855 sculos
108 sculos
Computador atual
Computador 100
vezes mais rpido
Computador 100
vezes mais rpido
t1
100 t1
1000 t1
n2
t2
10 t2
31,6 t2
n3
t3
4,6 t3
10 t3
2n
t4
t4 + 6,6
t4 + 10
Pg. 5
Anlise de Algoritmos
Pg. 6
Anlise de Algoritmos
lim
n
f(n)
n2
= c ( c > 0)
Se, por exemplo, outro algoritmo para o mesmo problema tem funo de complexidade
f1(n) = O(n), podemos comparar f(n) e f1(n) e, em consequncia, comparar a eficincia dos
programas que os implementam. Em um deles, o tempo de execuo linear e no outro, o
tempo quadrtico.
Funo
1
n
n2
log n
nlog n
2n
Pg. 7
Anlise de Algoritmos
Nome
Constante
Logartmica
Log quadrado
Linear
n log n
Quadrtica
Cbica
Exponencial
Linha 1
enquanto (linha tamanho_da_matriz ) faa
col 1
enquanto (col tamanho_da_matriz ) faa
m3 [ linha, col ] m1 [ linha, col ] + m2 [ linha, col ]
col col + 1
fim-enquanto
linha linha + 1
fim-enquanto
Pg. 8
Anlise de Algoritmos
Pg. 9
Anlise de Algoritmos
W(n) = 1
n
Pg. 10
Anlise de Algoritmos
Valor
de j
A[j]
Comparao:
A[j] = x
Valor
de sinal
Quantidade de
comparaes
90
10
falso
90
20
falso
90
30
falso
90
30
falso
falso
Pode-se observar que para o pior caso, onde foi percorrida toda a lista, foram realizadas
quatro (4) comparaes, o que significa (n+1) comparaes, pois n = 3. Se a lista for maior,
vai crescer linearmente o nmero de comparaes.
Supondo uma lista com trs elementos (10, 20 e 30) e chave de busca igual a 10.
Montando os passos da execuo do algoritmo:
Passo do Chave
algoritmo
(x)
Valor
de j
A[j]
Comparao:
A[j] = x
10
10
verdade
10
10
verdade
Valor
de sinal
Quantidade de
comparaes
1
verdade
Pode-se observar que para o melhor caso, onde a chave procurada est na primeira
posio da lista, foram realizadas duas (2) comparaes, uma no lao e outra no teste para
confirmar se foi encontrado ou no a chave procurada, o que significa duas (2) comparaes.
Se a lista for maior, este valor ficar constante.
Pg. 11
Anlise de Algoritmos
1.9 Exerccios
1.9.1 - Considerando a comparao como operao elementar, determine a complexidade do
algoritmo abaixo:
a) MAIOR (N, A)
max A [ 1 ]
para i de 2 at N repita
Se max < A[ i ]
ento max A[ i ]
b) ORDENA ( N, A)
para i de 1 at (N 1) repita
para j de 1 at (n i ) repita
se A[ j ] > A[ j + 1 ]
ento
x A[ j ]
A[ j ] A[ j + 1 ]
A[ j + 1 ] x
c)
n1
enquanto (n 10) faa
k1
enquanto ( k 10 ) faa
... trecho de pseudocdigo
kK+1
fim-enquanto
nn+1
fim-enquanto
1.9.2 verifique se as funes abaixo so O(n):
a) f(n) = n
b) f(n) = 1045n
c) f(n) = n2 + 70
d) f(n) = 7n + 3
e) f(n) = Cn + D , onde C, D so constantes
f) f(n) = 8
g) f(n) = n3 + n + 1
h) f(n) = 4n + 2log n + 5
1.9.3 Obter o valor de O para as expresses de complexidade:
a) f(n) = 3n3 + n
b) f(n) = 3 log n + 5n
c) f(n) = 3n2 + 5n + 4
d) f(n) = 3n3 + n2 + 5n + 99
Pg. 12
Anlise de Algoritmos
delay(100);
...
fim = clock();
....
printf("\nTempo de execucao: %f.",(fim - inicio)/CLK_TCK);
//calculo do tempo total = fim - inicio
Pg. 13
Anlise de Algoritmos
Estratgias Bsicas
Pg. 14
Anlise de Algoritmos
mdulo B
mdulos muito dependentes
(alto acoplamento)
mdulo A
mdulo B
mdulos mais independentes
(baixo acoplamento)
Pg. 15
Anlise de Algoritmos
Diviso e Conquista
Pg. 16
Anlise de Algoritmos
Pg. 17
Anlise de Algoritmos
Melhor caso
Pior caso
Caso mdio
maxmim
2 (n 1)
2 (n 1)
2 (n 1)
maxmin2
n1
2 (n 1)
3n/2 3/2
maxmin3
3n/2 2
3n/2 2
3n/2 2
Pg. 18
Anlise de Algoritmos
Melhor caso
Pior caso
Caso mdio
maxmim
2 (n 1)
2 (n 1)
2 (n 1)
maxmin2
n1
2 (n 1)
3n/2 3/2
maxmin3
3n/2 2
3n/2 2
3n/2 2
maxmin4
3n/2 2
3n/2 2
3n/2 2
Pg. 19
Anlise de Algoritmos
Pg. 20
Anlise de Algoritmos
Pg. 21
Anlise de Algoritmos
T(1) = 0
T(n) = T(n/2) + T(n/2) + cn , para n > 1
Quando n uma potencia de 2, tal que n = 2k (para k > 0), por substituies sucessivas
temos:
T(n) = 2 T(n/2) + cn
= 2 [ 2 T(n/4) + cn/2] + cn
= 2k T(n/2k) + kcn
= cn lg n
Quando n no necessariamente uma potencia de 2, n satisfaz 2k+1 < n 2k (para algum k >
0). E como T(n) crescente com n, T(n) T(2k) e tem-se:
T(n) / (n lg n) c 2k k / ( n lg n)
c 2n (lg n + 1) / (n lg n)
2c
portanto,
T(n) = O(n lg n)
Concluso
Para uma lista de entrada de tamanho n, o algoritmo OrdInter tem rapidez pessimista
T(n) = O(n lg n)
Este problema de ordenao tem cota inferior (n lg n) e portanto o algoritmo timo
em termos de rapidez.
Tanto no algoritmo OrdInter quanto no algoritmo MaxMin da seo anterior, a estratgia
de diviso e conquista foi aplicada obtendo-se duas subinstancias de tamanhos
aproximadamente iguais. Isto no uma coincidencia, e foi feito de acordo com uma
orientao bsica que chamaremos de Princpio da Equipartio.
Para ilustrar o Princpio da Equipartio, suponhamos que as subinstancias sejam de
tamanho um e n-1 no algoritmo OrdInter. Ento, a frmula de recorrncia de T(n) passa a
ser:
T(1) = 0
T(n) = T(n-1) + cn, para n>1
que tem soluo T(n) = O(n2). Portanto, tem-se um algoritmo mais lento do que o
algoritmo estudado anteriormente.
Pg. 22
Anlise de Algoritmos
Pg. 23
Anlise de Algoritmos
Pg. 24
Anlise de Algoritmos
se n = 1
entao se x = Mn ento pare-com-saida (presente, n)
senao pare-com-saida (ausente, 0)
fim_se
senao
k
[ (n + 1) / 2]
se x < Mk entao (resposta, j)
BuscaBin(x, k1, M1, ..., Mk-1)
senao (respost, j)
BuscaBin(x, n-k+1, Mk, ..., Mn)
j
j+1
fim_se
pare-com-saida (resposta, j)
fim_se
Rapidez do BuscaBin
Seja T(n) a rapidez pessimista do BuscaBin para uma entrada (x, n, L = (M1, ..., Mn)).
Pode-se observar no algoritmo que, se n = 1, T(1) = 1, a comparao efetuada na linha 2.
Se n > 1, faz-se uma comparao na linha. Calculando k 1 e n k + 1 para os casos de n
ser par ou ser impar respectivamente, conclui-se que a execuo na linha 8 requer um tempo
Prof. Walteno Martins Parreira Jr
Pg. 25
Anlise de Algoritmos
T([n/2]), e a execuo na linha 10 requer T([n/2]). Pode-se observar que apenas uma das
opes ser executada.
Considerando a rapidez pessimista, e como T([n/2]) T([n/2]), tem-se a seguinte frmula
de recorrncia
T(1) = 1, T(n) = 1 + T([n/2]), para n > 1.
Quando n uma potencia de 2, pode-se facilmente deduzir que tem soluo T(n) = lg n.
Logo, tem-se que T(n) = O (lg n).
Atravs de uma rvore de deciso, pode-se provar que o problema de busca por
comparaes de um elemento numa lista ordenada tem cota inferior (lg n). Portanto, o
algoritmo BuscaBin tem rapidez tima.
Pg. 26
Anlise de Algoritmos
a) Se tivesse de escolher um algoritmo para usar, sem saber a situao inicial da lista, qual
usaria? justifique a resposta.
b) Se tivesse de escolher um algoritmo para usar, sabendo que a situao de pior caso em uma
lista muito grande e que tem possibilidade de continuar a crescer rapidamente, qual dos
algoritmos voce usaria? justifique a resposta.
c) Os tempos (valores) encontrados na tabela 2 so compatveis com o nmero de comparaes
apresentador na tabela 1? Justifique a resposta.
d) Para uma lista com N=30, qual seriam os valores que deveriam ser encontrados?
Pg. 27
Anlise de Algoritmos
Algoritmo
Caso mdio
maxmim4
maxmin3
maxmin2
maxmin
Pg. 28
Anlise de Algoritmos
4 - Mtodos
de Ordenao
Pg. 29
Anlise de Algoritmos
Ord (n, A)
Para i de n at 2 passo
1 repita
j i;
Para k de 1 at (i 1)
repita
Se A[j] < A[k]
Entao j k;
fim-para;
Se i j
Entao
aux A[i];
A[i] A[j];
A[j] aux;
fim-para.
operao entre as chaves feita no loop k, para cada valor de i so realizadas (i-1)
comparaes no loop, como i varia de 2 at n, o nmero total de comparaes para
ordenar a lista toda :
n
Pg. 30
Anlise de Algoritmos
O algoritmo de ordenao por seleo um dos mtodos de ordenao mais simples que
existem. Alm disso, o mtodo possui um comportamento espetacular quanto ao nmero de
movimentos de registros, cujo tempo de execuo linear no tamanho da entrada, o que
muito difcil de ser batido por qualquer outro mtodo. Consequentemente, este o algoritmo
a ser utilizado para arquivos com registros muito grandes. Em condies normais, com
chaves do tamanho de uma palavra, este mtodo bastante interessante para arquivos com
at 1000 registros. Como aspectos negativos cabe registrar que:
a) o fato do arquivo j estar ordenado no ajuda em nada, pois o custo continua
quadrtico;
b) o algoritmo no estvel, pois ele nem sempre deixa os registros com chaves iguais
na mesma posio relativa.
Pg. 31
Anlise de Algoritmos
6
A[j+1] A[j];
7
j j 1;
8
fim-enquanto;
9
A[j+1] x;
10 fim-para.
Pior caso:
O(n2)
Pg. 32
Anlise de Algoritmos
Pg. 33
Anlise de Algoritmos
Pg. 34
Anlise de Algoritmos
(chamada do Procedimento}
(chamada recursiva}
Pg. 35
Anlise de Algoritmos
Tamanho
j-p
uj
O Algoritmo Escolhe
O objetivo que aps a partio da sublista {Xp, ..., Xu} nas sub-listas
{Xp, ..., Xj-1}, {Xj}, {Xj+1, ..., Xu} de escolher a nova sublista a ser particionada, isto ,
redefinir os valores dos ndices p e u. Se no existir sub-lista a ser particionada o valor de p
igual a u. Inicialmente a pilha est vazia e topo igual a zero.
Entradas: p, u, j (inteiros)
Sadas: p, u (inteiros)
Escolhe (p, u, j)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
Pg. 36
Anlise de Algoritmos
Anlise de Complexidade
Vamos analisar a complexidade em relao operao de comparao. O movimento de
registros sempre inferior ao nmero de comparaes.
Qualquer que seja a entrada, aps a primeira partio so efetuadas no mximo (n+1)
comparaes, pois o elemento alocado quando i torna-se maior ou igual a j. Portanto,
C(n) (n + 1) + C(n1) + C(n2), com n1 + n2 = n 1
a) Pior caso
O pior caso ocorre para as entradas que correspondem s listas ordenadas ou invertidas,
em que sistematicamente, aps cada partio resulta uma sublista vazia.
Aps cada varredura n1 = 0 ou n2 = 0. Da pode-se escrever que:
C(n)
n + 1 + C(n 1)
C(n 1)
n + C(n 2)
C(n 2)
n 1 + C(n 3)
3 + C(1)
...
C(2)
Pg. 37
Anlise de Algoritmos
Pg. 38
Anlise de Algoritmos
/ (n + 1)
C(n)
/ (n+1)
n+1
n+1
i=3
/ (n + 1) + 2 / n + . . . + 2/3 = 2 1/i 2 dx / x
2 ln (n+1), isto C(n) (n+1) log(n+1)
Portanto, C(n) O(n log n)
4.4.5 - Concluso
O quicksort extremamente eficiente para ordenar arquivos de dados. O mtodo
necessita de apenas uma pequena pilha como memria auxiliar, e requer cerca de (n log n)
operaes em mdia para ordenar n itens. Como aspectos negativos tem-se:
O mtodo no estvel.
Uma vez desenvolvida uma implementao robusta para o quicksort, este deve ser o
algoritmo preferido para a maioria das aplicaes.
Pg. 39
Anlise de Algoritmos
Pg. 40
Anlise de Algoritmos
Pg. 41
Anlise de Algoritmos
Selecione o menor item do vetor e a seguir troque-o com o item que est na
primeira posio do vetor;
Repita estas duas operaes com os (n-1) itens restantes, depois com os (n-2) itens e
assim sucessivamente.
O custo para encontrar o menor (ou o maior) item entre os n itens custa (n-1)
comparaes. Este custo pode ser reduzido atravs da utilizao de uma estrutura de dados
denominada fila de prioridades.
4.6.1 - Fila de prioridades
Em vrias situaes necessrio ter uma estrutura de dados que suporte as operaes de
inserir um novo item e retirar o item com a maior chave.
Filas com prioridades so utilizadas em um grande nmero de aplicaes. Sistemas
operacionais usam filas de prioridades, onde as chaves representam o tempo em que os
eventos devem ocorrer. Alguns mtodos numricos interativos so baseados na seleo
repetida de um item com maior (ou menor) valor.
As operaes mais comuns so: Adicionar um novo item ao conjunto e extrair o item do
conjunto que contenha o maior (ou o menor) valor.
Um tipo abstrato de dados fila de prioridades, contendo registros com chaves numricas
(prioridades), deve suportar as operaes:
Substitui o maior item por um novo item, a no ser que o novo item seja maior;
Pg. 42
Anlise de Algoritmos
Esta estrutura conhecida como uma rvore binria completa: o primeiro nodo
chamado raiz, os nodos abaixo de cada nodo so chamados nodos filhos e o nodo acima
chamado de nodo pai. Uma rvore binria completa pode ser representada por um vetor.
Esta representao extremamente compacta e, permite caminhar pelos nodos da rvore
facilmente, onde os filhos de um nodo i esto na posio 2i e 2i+1, caso existam, e o pai de
um nodo i est na posio (i div 2).
4.6.3 - Heapsort
Um mtodo elegante e que no necessita de memria auxiliar foi apresentado por Floyd (
em 1964). dado um vetor A[1], A[2], ..., A[n], os itens A[n/2+1], A[n/2+2], ..., A[n] formam
um heap, porque neste intervalo do vetor no existem dois ndices i e j tais que j=2i ou
j=(2i+1). A construo do heap:
a) dada as chaves iniciais:
1
O
2
R
3
D
4
E
5
N
6
A
7
S
Pg. 43
Anlise de Algoritmos
b) estendendo o heap para a esquerda (Esq=3), englobando o item A[3], pai dos itens
A[6] e A[7], aqui a condio do heap violada e os itens A[3] e A[7] so trocados;
1
2
3
4
5
6
7
Esq = 3
O R
S
E N A D
c) a seguir o heap estendido novamente a esquerda (Esq=2) incluindo o item A[2], pai
dos itens A[4] e A[5], que atendem a condio do heap.
1
2
3
4
5
6
7
Esq = 2
O R
S
E N A D
d) finalmente, estendendo o heap a esquerda (Esq= 1), englobando o item A[1], pai dos
itens A[2] e A[3], a condio violada e os itens A[1] e A[3] so trocados,
encerrando o processo.
1
2
3
4
5
6
7
Esq = 1
S
R O E N A D
Entradas: Esq, Dir (inteiro), A (vetor de elementos)
Sada: A (vetor de elementos)
refaz(esq, dir, A)
1
i esq;
2
j 2 * i;
3
x A[i];
4
Enquanto j dir faca
5
Se j < dir
6
Ento Se A[j] < A[j+1]
7
Entao j j + 1;
8
Se x A[j]
9
Ento v para 999;
10
A[i] A[j];
11
i j;
12
j 2 * i;
13 fim-enquanto;
14 999: A[i] x;
Entrada e Sada: A (vetor de elementos)
Constroi(A)
1
Esq (n div 2) + 1;
2
Enquanto esq > 1 faca
3
Esq esq 1;
4
Refaz (esq, n, A);
5
fim-enquanto;
Usando o heap obtido pelo procedimento constri, pega-se o elemento na posio 1 do
vetor (raiz do heap) e troca com o item que est na posio n do vetor.Agora usando o
procedimento refaz para reorganizar o heap para os itens A[1], A[2], ..., A[n-1]. Repete-se as
duas operaes sucessivamente at que reste apenas um item.
Pg. 44
Anlise de Algoritmos
Pg. 45
Anlise de Algoritmos
4.6.5 - Concluso
Inicialmente o algoritmo no parece eficiente, pois as chaves so movimentadas vrias
vezes. Entretanto, o procedimento refaz gasta cerca de (log n) operaes no pior caso.
Portanto, heapsort gasta um tempo de execuo proporcional a (n log n) no pior caso.
Heapsort no recomendado para arquivos com poucos registros, por causa do tempo
necessrio para construir o heap, bem como porque o anel interno do algoritmo bastante
complexo, se comparado com o anel interno do quicksort.
O quicksort , em mdia, duas vezes mais rpido que o heapsort. Entretanto, o heapsort
melhor que o shellsort para grandes arquivos.
Deve-se observar que o comportamento do heapsort O(n log n) qualquer que seja a
entrada. Aplicaes que no podem tolerar um caso desfavorvel devem usar o heapsort.
Um aspecto negativo que o mtodo no estvel.
4.7 - Comparao entre os mtodos de ordenao
A ordenao interna usada quando todos os registros do arquivo (ou lista ou vetor)
cabem na memria principal.
Usando dois mtodos simples (seleo e insero) que requerem O(n2) comparaes e
trs mtodos eficientes (shellsort, quicksort e heapsort) que requerem O(n log n)
comparaes em seus casos mdios para uma lista com n elementos.
As tabelas abaixo apresentam quadros comparativos do tempo para ordenar arranjos com
500, 5000, 10000 e 30000 registros na ordem aleatria (4, 2, 9, 1, ..., n), na ordem
ascendente (1, 2, 3, ..., n), e na ordem descendente (n, n-1,..., 3, 2, 1). Em cada tabela, o
mtodo que gastou o menor tempo para executar o procedimento recebeu o valor 1 e os
outros valores so relativos a este.
Insero
Seleo
Shellsort
Quicksort
heapsort
30000
2
1
1.6
Insero
Seleo
Shellsort
Quicksort
heapsort
30000
1
8.1
7.1
24.6
30000
1.6
1
2.9
Pg. 46
Anlise de Algoritmos
Pg. 47
Anlise de Algoritmos
4.8 - Exerccios
1)
2)
3)
4)
Em qual situao ocorre o pior caso no mtodo Quicksort? Qual a estratgia para evitar
o pior caso?
5)
6)
7)
8)
9)
10)
11)
12)
13)
14)
15)
16)
Pg. 48
Anlise de Algoritmos
17)
18)
19)
Seleo
506
700
711
Insero
571
544
621
Pg. 49
Anlise de Algoritmos
500
3.3
1.3
1
10000
4.6
1
1.1
30000
5.1
1
1.3
Para a melhor situao foi dado o valor um, e aos outros resultados os valores so
proporcionais ao melhor caso.
Pg. 50
Anlise de Algoritmos
No programa-fonte deve conter o(s) nome(s) do(s) aluno(s) responsvel(ies), o que deve
ser feito quando mais de um aluno desenvolveu o programa, sendo aceito no mximo trs (3)
alunos. O programa fonte deve apresentar tambm comentrios explicando as principais
passagens desenvolvidas.
No arquivo texto deve estar os dados coletados para cada situao proposta e para cada uma
deve ter o nmero de comparaes e tempo gasto, e as concluses do aluno. Este arquivo
deve conter o nome do aluno, e a informao (quando necessria) de que o programa foi
desenvolvido juntamente com outros alunos (colocar os nomes) e em seguida os dados
coletados e as concluses. Observe que este arquivo individual e as execues para coleta
dos dados tambm devem ser individuais.
Pg. 51
Anlise de Algoritmos
BIBLIOGRAFIA:
KNUTH, D. E. The Art of Computer Programming. Massachusetts: Addison-Wesley Longman,
1997. v. 1 e 2.
SALVETTI, D. D. & BARBOSA L M. Algoritmos. So Paulo: Makron Books, 1998.
TERADA, R. Desenvolvimento de Algoritmo e Estruturas de Dados. So Paulo: Makron
Books, 1991.
ZIVIANI, N. Projeto de Algoritmos - Com Implementaes em PASCAL e C. So Paulo:
Editora Pioneira, 1999.
Nota do Professor:
Este trabalho um resumo do contedo da disciplina, para facilitar o desenvolvimento das
aulas, devendo sempre ser complementado com estudos nos livros recomendados e o
desenvolvimento dos exerccios indicados em sala de aula e a resoluo das listas de
exerccios propostas.
Pg. 52