Escolar Documentos
Profissional Documentos
Cultura Documentos
Departamento de Computao
Ouro Preto
14 de novembro de 2008
Sumrio
1 Introduo 1
2 Mtodos de Ordenao 2
2.1 Mtodos de Ordenao Interna . . . . . . . . . . . . . . . . . . . . . 3
2.1.1 Implementao dos mtodos . . . . . . . . . . . . . . . . . . . 3
2.2 BubbleSort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.2.1 Implementao . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.2.2 Estudo da Complexidade . . . . . . . . . . . . . . . . . . . . . 8
2.2.3 Anlise do algoritmo . . . . . . . . . . . . . . . . . . . . . . . 9
2.3 InsertSort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.3.1 Implementao . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.3.2 Estudo da Complexidade . . . . . . . . . . . . . . . . . . . . . 12
2.3.3 Anlise do algoritmo . . . . . . . . . . . . . . . . . . . . . . . 13
2.4 SelectSort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.4.1 Implementao . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.4.2 Estudo da Complexidade . . . . . . . . . . . . . . . . . . . . . 16
2.4.3 Anlise do algoritmo . . . . . . . . . . . . . . . . . . . . . . . 16
2.5 ShellSort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
2.5.1 Implementao . . . . . . . . . . . . . . . . . . . . . . . . . . 19
2.5.2 Estudo da Complexidade . . . . . . . . . . . . . . . . . . . . . 20
2.5.3 Anlise do algoritmo . . . . . . . . . . . . . . . . . . . . . . . 20
2.6 QuickSort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.6.1 Implementao . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.6.2 Estudo da Complexidade . . . . . . . . . . . . . . . . . . . . . 23
2.6.3 Anlise do algoritmo . . . . . . . . . . . . . . . . . . . . . . . 24
2.7 HeapSort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
2.7.1 Implementao . . . . . . . . . . . . . . . . . . . . . . . . . . 27
2.7.2 Estudo da Complexidade . . . . . . . . . . . . . . . . . . . . . 28
2.7.3 Anlise do algoritmo . . . . . . . . . . . . . . . . . . . . . . . 28
2.8 MergeSort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
2.8.1 Implementao . . . . . . . . . . . . . . . . . . . . . . . . . . 30
2.8.2 Estudo da Complexidade . . . . . . . . . . . . . . . . . . . . . 31
2.8.3 Anlise do algoritmo . . . . . . . . . . . . . . . . . . . . . . . 31
3 Testes 32
3.1 Metodologia dos Testes . . . . . . . . . . . . . . . . . . . . . . . . . . 32
3.2 Resultados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
3.2.1 Vetor ordenado em ordem crescente . . . . . . . . . . . . . . . 34
2
3.2.2 Vetor ordenado em ordem decrescente . . . . . . . . . . . . . . 37
3.2.3 Vetor parcialmente ordenado . . . . . . . . . . . . . . . . . . . 40
3.2.4 Vetor aleatrio . . . . . . . . . . . . . . . . . . . . . . . . . . 43
3.3 Anlise dos Resultados . . . . . . . . . . . . . . . . . . . . . . . . . . 46
3.3.1 Vetor ordenado em ordem crescente . . . . . . . . . . . . . . . 46
3.3.2 Vetor ordenado em ordem decrescente . . . . . . . . . . . . . . 48
3.3.3 Vetor parcialmente ordenado . . . . . . . . . . . . . . . . . . . 50
3.3.4 Vetor aleatrio . . . . . . . . . . . . . . . . . . . . . . . . . . 52
4 Concluso 54
A CTimer 56
B Operations 57
C Arquivos de sada contendo os resultados 60
3
Lista de Tabelas
2.1 Vantagens e desvantagens do Mtodo BubbleSort. . . . . . . . . . . . 9
2.2 Vantagens e desvantagens do Mtodo InsertSort. . . . . . . . . . . . . 13
2.3 Vantagens e desvantagens do Mtodo SelectSort. . . . . . . . . . . . . 17
2.4 Vantagens e desvantagens do Mtodo ShellSort. . . . . . . . . . . . . 20
2.5 Vantagens e desvantagens do Mtodo QuickSort. . . . . . . . . . . . . 24
2.6 Vantagens e desvantagens do Mtodo HeapSort. . . . . . . . . . . . . 28
2.7 Vantagens e desvantagens do Mtodo MergeSort. . . . . . . . . . . . 31
3.1 Quantidade de comparaes e movimentos dos testes no vetor OrdC. 34
3.2 Tempo gasto pelos testes no vetor OrdC. . . . . . . . . . . . . . . . . 34
3.3 Quantidade de comparaes e movimentos dos testes no vetor OrdD. 37
3.4 Tempo gasto pelos testes no vetor OrdD. . . . . . . . . . . . . . . . . 37
3.5 Quantidade de comparaes e movimentos dos testes no vetor OrdP. . 40
3.6 Tempo gasto pelos testes no vetor OrdP. . . . . . . . . . . . . . . . . 40
3.7 Quantidade de comparaes e movimentos dos testes no vetor OrdA. 43
3.8 Tempo gasto pelos testes no vetor OrdA. . . . . . . . . . . . . . . . . 43
4
Lista de Figuras
2.1 Exemplo de ordenao Estvel e Instvel. . . . . . . . . . . . . . . . . 2
2.2 Ilustrao do funcionamento do algoritmo BubbleSort. . . . . . . . . 6
2.3 Fluxograma do algoritmo BubbleSort. . . . . . . . . . . . . . . . . . . 7
2.4 Ilustrao do funcionamento do algoritmo InsertSort. . . . . . . . . . 10
2.5 Fluxograma do algoritmo InsertSort. . . . . . . . . . . . . . . . . . . 10
2.6 Ilustrao do funcionamento do algoritmo SelectSort. . . . . . . . . . 14
2.7 Ilustrao do funcionamento do algoritmo ShellSort. . . . . . . . . . . 18
2.8 Ilustrao do funcionamento do algoritmo QuickSort. . . . . . . . . . 21
2.9 Ilustrao de um Heap mximo. . . . . . . . . . . . . . . . . . . . . . 25
2.10 Ilustrao do funcionamento do algoritmo HeapSort. . . . . . . . . . . 27
2.11 Ilustrao do funcionamento do algoritmo MergeSort. . . . . . . . . . 29
3.1 Nmero de comparaes e movimentaes do teste aplicado em um
vetor de 100 posies do tipo OrdC. . . . . . . . . . . . . . . . . . . . 35
3.2 Nmero de comparaes e movimentaes do teste aplicado em um
vetor de 1000 posies do tipo OrdC. . . . . . . . . . . . . . . . . . . 35
3.3 Nmero de comparaes e movimentaes do teste aplicado em um
vetor de 10000 posies do tipo OrdC. . . . . . . . . . . . . . . . . . 36
3.4 Nmero de comparaes e movimentaes do teste aplicado em um
vetor de 100000 posies do tipo OrdC. . . . . . . . . . . . . . . . . . 36
3.5 Nmero de comparaes e movimentaes do teste aplicado em um
vetor de 100 posies do tipo OrdD. . . . . . . . . . . . . . . . . . . . 38
3.6 Nmero de comparaes e movimentaes do teste aplicado em um
vetor de 1000 posies do tipo OrdD. . . . . . . . . . . . . . . . . . . 38
3.7 Nmero de comparaes e movimentaes do teste aplicado em um
vetor de 10000 posies do tipo OrdD. . . . . . . . . . . . . . . . . . 39
3.8 Nmero de comparaes e movimentaes do teste aplicado em um
vetor de 100000 posies do tipo OrdD. . . . . . . . . . . . . . . . . . 39
3.9 Nmero de comparaes e movimentaes do teste aplicado em um
vetor de 100 posies do tipo OrdP. . . . . . . . . . . . . . . . . . . . 41
3.10 Nmero de comparaes e movimentaes do teste aplicado em um
vetor de 1000 posies do tipo OrdP. . . . . . . . . . . . . . . . . . . 41
3.11 Nmero de comparaes e movimentaes do teste aplicado em um
vetor de 10000 posies do tipo OrdP. . . . . . . . . . . . . . . . . . . 42
3.12 Nmero de comparaes e movimentaes do teste aplicado em um
vetor de 100000 posies do tipo OrdP. . . . . . . . . . . . . . . . . . 42
3.13 Nmero de comparaes e movimentaes do teste aplicado em um
vetor de 100 posies do tipo OrdA. . . . . . . . . . . . . . . . . . . . 44
5
3.14 Nmero de comparaes e movimentaes do teste aplicado em um
vetor de 1000 posies do tipo OrdA. . . . . . . . . . . . . . . . . . . 44
3.15 Nmero de comparaes e movimentaes do teste aplicado em um
vetor de 10000 posies do tipo OrdA. . . . . . . . . . . . . . . . . . 45
3.16 Nmero de comparaes e movimentaes do teste aplicado em um
vetor de 100000 posies do tipo OrdA. . . . . . . . . . . . . . . . . . 45
3.17 Curva de desempenho dos 7 mtodos. . . . . . . . . . . . . . . . . . . 46
3.18 Tempo gasto pelos mtodos nos quatro tamanhos de vetores propostos. 46
3.19 Curva de desempenho dos 7 mtodos. . . . . . . . . . . . . . . . . . . 48
3.20 Tempo gasto pelos mtodos nos quatro tamanhos de vetores propostos. 48
3.21 Curva de desempenho dos 7 mtodos. . . . . . . . . . . . . . . . . . . 50
3.22 Tempo gasto pelos mtodos nos quatro tamanhos de vetores propostos. 50
3.23 Curva de desempenho dos 7 mtodos. . . . . . . . . . . . . . . . . . . 52
3.24 Tempo gasto pelos mtodos nos quatro tamanhos de vetores propostos. 52
6
Lista de Programas e Arquivos
2.1 Estrutura do tipo Item. . . . . . . . . . . . . . . . . . . . . . . . . . . 2
2.2 Estrutura da classe SortMethods. . . . . . . . . . . . . . . . . . . . . 4
2.3 Mtodo para zerar valores. . . . . . . . . . . . . . . . . . . . . . . . . 4
2.4 Mtodos de consulta s variveis de medida. . . . . . . . . . . . . . . 5
2.5 Mtodo BubbleSort. . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.6 Mtodo InsertSort. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.7 Mtodo SelectSort. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.8 Mtodo SelectSort. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
2.9 Mtodo Partition utilizado pelo QuickSort. . . . . . . . . . . . . . . . 22
2.10 Mtodo MethodQuick. . . . . . . . . . . . . . . . . . . . . . . . . . . 22
2.11 Mtodo QuickSort. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
2.12 Operaes com Heap necessrias ao HeapSort. . . . . . . . . . . . . . 26
2.13 Mtodo HeapSort. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
2.14 Mtodo Merge responsvel pela intercalao. . . . . . . . . . . . . . . 30
2.15 Mtodo MergeSort. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
3.1 Exemplo de um arquivo de entrada para teste. . . . . . . . . . . . . . 32
A.1 Implementao dos mtodos da classe CTimer. . . . . . . . . . . . . . 56
B.1 Implementao dos mtodos da classe Operations. . . . . . . . . . . . 57
C.1 Resultados do testes utilizando BubbleSort. . . . . . . . . . . . . . . 61
C.2 Resultados do testes utilizando InsertSort. . . . . . . . . . . . . . . . 62
C.3 Resultados do testes utilizando SelectSort. . . . . . . . . . . . . . . . 63
C.4 Resultados do testes utilizando ShellSort. . . . . . . . . . . . . . . . . 64
C.5 Resultados do testes utilizando QuickSort. . . . . . . . . . . . . . . . 65
C.6 Resultados do testes utilizando HeapSort. . . . . . . . . . . . . . . . 66
C.7 Resultados do testes utilizando MergeSort. . . . . . . . . . . . . . . . 67
7
Captulo 1
Introduo
Em vrios momentos do dia a dia, o homem depara-se com a necessidade de con-
sultar dados ordenados. Como exemplo, pode-se citar uma lista telefnica. Imagine
como seria consultar o telefone de uma pessoa se os nomes no estivessem classica-
dos em ordem alfabtica. Por isso uma das atividades mais utilizada na computao
a ordenao.
As ordens mais utilizadas so as nmericas e as lexicogrcas.
Existem diversos algoritmos para ordenao interna. No presente trabalho ser
apresentada a implementao e os testes de sete destes mtodos.
BubbleSort
InsertSort
SelectSort
ShellSort
QuickSort
HeapSort
MergeSort
1
Captulo 2
Mtodos de Ordenao
Ordenar corresponde ao processo de rearranjar um conjunto de objetos
em ordem ascendente ou descendente. O objetivo principal da ordenao
facilitar a recuperao posterior de itens do conjunto ordenado. ...A
atividade de colocar as coisas em ordem est presente na maioria das
aplicaes em que os objetos armazenados tm de ser pesquisados e re-
cuperados... [19]
A comparao feita atravs de uma determinada chave, para este trabalho a
chave escolhida foi um valor inteiro. O Programa 2.1 apresenta a estrutura do tipo
Item (implementado na classe Types) que armazenado pelos Vetores.
Programa 2.1: Estrutura do tipo Item.
typedef long TKey ;
TKey Key ;
} TItem ;
Um mtodo dito estvel se a ordem relativa dos itens com a mesma chave no
se altera durante o processo de ordenao. A Figura 2.1 exemplica os mtodos
estveis e instveis de ordenao.
2
Os mtodos de ordenao so classicados em dois grandes grupos: ordenao
interna e externa.
1. Ordenao Interna: So os mtodos que no necessitam de uma memria
secundria para o processo, a ordenao feita na memria principal do com-
putador;
2. Ordenao Externa: Quando o arquivo a ser ordenado no cabe na
memria principal e, por isso, tem de ser armazenado em ta ou disco.
A principal diferena entre os dois grupos que no mtodo de ordenao interna
qualquer registro pode ser acessado diretamente, enquanto no mtodo externo
necessrio fazer o acesso em blocos [5].
3
Programa 2.2: Estrutura da classe SortMethods.
#ifndef
#define
_SORTMETHODS_
_SORTMETHODS_
class SortMethods {
private
double
:
double
mComparations ;
double
mMoviments ;
void
mTime ;
i , j A) ;
void long long
Partition ( Left , Right , , TItem
Array ) ;
void long
ReMake ( Left , Right , TItem
void long long
B u i l d ( TItem Array , n) ;
A) ;
void long long long
MethodQuick ( Left , Right , TItem
public :
void long
SortMethods ( ) ;
Array ,
void long
B u b b l e S o r t ( TItem n) ;
Array ,
void long
S e l e c t S o r t ( TItem n) ;
I n s e r t S o r t ( TItem A r r a y ,
void long
n) ;
S h e l l S o r t ( TItem A r r a y ,
void long
n) ;
Q u i c k S o r t ( TItem A r r a y ,
void long
n) ;
H e a p S o r t ( TItem A r r a y ,
void long
n) ;
M e r g e S o r t ( TItem A r r a y ,
double
n) ;
double
getTime ( ) ;
double
getComparations ( ) ;
getMoviments ( ) ;
#endif
};
this
>m C o m p a r a t i o n s = 0;
this
>mMoviments = 0;
>mTime = 0;
4
double getComparations(): Retorna o nmero de comparaes entre
chaves;
double getMoviments(): Retorna o nmero de movimentaes (trocas) re-
alizadas entre os itens;
>mTime ;
double
return this
SortMethods : : getComparations ( ) {
>m C o m p a r a t i o n s ;
double
return this
SortMethods : : getMoviments ( ) {
>mMoviments ;
5
2.2 BubbleSort
6
A seguir na Figura 2.3 mostrado o uxograma do algoritmo.
2.2.1 Implementao
i , j ;
new
TItem aux ;
Timer
this
CTimer = CTimer ( ) ;
>C l e a r A l l ( ) ;
for
Timer >s t a r t ( ) ;
1 ;
for
( i = 0 ; i < n i++ ){
n i
this
( j = 1 ; j < ; j++ ){
if
>m C o m p a r a t i o n s++;
this
aux = Array [ j ] ;
>mMoviments++;
1];
this
Array [ j ] = Array [ j
>mMoviments++;
1]
this
Array [ j = aux ;
>mMoviments++;
>s t o p ( )
this
Timer ;
7
O Programa 2.5 mostra a implementao do algoritmo para um conjunto de n
itens, implementado como um vetor do tipo TItem.
O algoritmo procede da seguinte forma:
1. Zera os valores das vriveis de medio atravs do mtodo ClearAll();
2. Inicia a contagem de tempo com a funo start();
3. Percorre o vetor, trazendo para o incio o menor elemento encontrado;
4. A cada comparao incrementa a varivel mComparations e a cada movimen-
tao incrementa a varivel mMoviments;
5. Pausa a contagem de tempo e calcula o tempo gasto armazenando o valor na
varivel mTime;
Uma maneira mais eciente de implementao do BubbleSort consiste em parar
o processo logo que se detecte que, ao longo de uma passagem no foram efetuadas
trocas de chaves [16].
n2 ni1
!
X X
C(n) = 1
i=0 j=1
n2
X
= (n i 1)
i=0
n2
X n2
X n2
X
= n i 1
i=0 i=0 i=0
(0 + n 2)(n 1)
= n(n 1) (n 1)
2
(n2 3n + 2)
= n2 n (n 1)
2
2n2 2n n2 + 3n 2 2n + 2
=
2
2
n n
=
2
(2.1)
Ordem de Complexidade: O(n2 )
8
M (n) = 3 C(n)
2
n n
= 3
2
2
3n 3n
=
2
(2.2)
Ordem de Complexidade: O(n2 )
9
2.3 InsertSort
10
2.3.1 Implementao
i , j ;
new
TItem aux ;
Timer
this
CTimer = CTimer ( ) ;
>C l e a r A l l ( ) ;
for
Timer >s t a r t ( ) ;
( i = 1; i < n; i ++){
this
aux = Array [ i ] ;
>mMoviments++;
this
j = i 1;
while
>m C o m p a r a t i o n s++;
this
Array [ j + 1] = Array [ j ] ;
>mMoviments++;
j ;
}
this
Array [ j + 1] = aux ;
>mMoviments++;
>s t o p ( )
this
Timer ;
Uma soluo melhor, mas que no ser utilizada durante os testes, a utilizao
de um registro sentinela: na posio zero do vetor coloca-se o prprio registro em
considerao. Assim evitando duas comparaes no anel mais interno do algoritmo,
porem seria necesrio uma implementao do vetor a partir do ndice 1, e no de 0
como proposto neste trabalho.
11
2.3.2 Estudo da Complexidade
n1 i
!
X X
C(n) = 1
i=1 j=1
n1
X
= (i)
i=1
(n 1)(1 + n 1
=
2
(n 1)(n)
=
2
2
n n
=
2
(2.3)
Ordem de Complexidade: O(n2 )
n1 i
!
X X
C(n) = 2+ 1
i=1 j=1
n1
X
= (2 + i)
i=1
n1
X n1
X
= 2+ i
i=1 i=1
(n 1)(1 + n 1
= 2(n 1) +
2
(n 1)(n)
= (2n 2) +
2
(n2 n)
= (2n 2) +
2
2
4n 4 + n n
=
2
n2 + 3n 4
=
2
2
n + 3n
= 2
2
(2.4)
Ordem de Complexidade: O(n2 )
12
2.3.3 Anlise do algoritmo
13
2.4 SelectSort
14
2.4.1 Implementao
i , j , Min ;
new
TItem aux ;
Timer
this
CTimer = CTimer ( ) ;
>C l e a r A l l ( ) ;
for
Timer >s t a r t ( ) ;
( i = 0; i < n 1; i ++){
for
Min = i ;
this
( j = i + 1 ; j < n; j ++){
if
>m C o m p a r a t i o n s++;
Min = j ;
this
aux = A r r a y [ Min ] ;
>mMoviments++;
this
A r r a y [ Min ] = Array [ i ] ;
>mMoviments++;
this
Array [ i ] = aux ;
>mMoviments++;
>s t o p ( )
this
Timer ;
15
2.4.2 Estudo da Complexidade
n2 ni1
!
X X
C(n) = 1
i=0 j=1
n2
X
= (n i 1)
i=0
n2
X n2
X n2
X
= n i 1
i=0 i=0 i=0
(0 + n 2)(n 1)
= n(n 1) (n 1)
2
2 (n2 3n + 2)
= n n (n 1)
2
2n2 2n n2 + 3n 2 2n + 2
=
2
n2 n
=
2
(2.5)
Ordem de Complexidade: O(n2 )
n1
X
C(n) = 3
i=1
= 3(n 1)
= 3n 3
(2.6)
Ordem de Complexidade: O(n)
16
Vantagens Desvantagens
- Fcil Implementao - O fato de o arquivo j estar ordenado
no inuencia em nada
- Pequeno nmero de movimentaes - Ordem de complexidade quadrtica
- Interessante para arquivos pequenos - Algoritmo no estvel
Tabela 2.3: Vantagens e desvantagens do Mtodo SelectSort.
17
2.5 ShellSort
18
2.5.1 Implementao
int
i , j ;
h = 1;
new
TItem aux ;
Timer
this
CTimer = CTimer ( ) ;
>C l e a r A l l ( ) ;
do
Timer >s t a r t ( ) ;
while
h = h 3 + 1;
do
} (h < n) ;
for
h /= 3;
( i = h ; i < n ; i++ ){
this
aux = Array [ i ] ;
>mMoviments++;
this
j = i ;
while
>m C o m p a r a t i o n s++;
this
( Array [ j h ] . Key > aux . Key ) {
>m C o m p a r a t i o n s++;
this
Array [ j ] = Array [ j h ];
>mMoviments++;
if
j = h;
break
( j < h)
this
Array [ j ] = aux ;
>mMoviments++;
while
}
} (h != 1) ;
this
Timer >s t o p ( ) ;
19
3. O algoritmo usa uma varivel auxiliar denominada distncia de comparao
(h);
4. O valor de h inicializado com um valor prximo de n/2;
5. A troca feita entre elementos que esto distanciados h posies (se estiverem
fora de ordem);
6. Aps todas as trocas de elementos cuja distancia h, o valor de h deve ser
reduzido: conforme Equao 2.7;
7. O algoritmo repetido at que a distncia de comparao h seja igual a um
(h = 1);
8. Para h = 1 (ultima passada) executado o algoritmo de insero;
9. A cada comparao incrementa a varivel mComparations e a cada movimen-
tao incrementa a varivel mMoviments;
10. Pausa a contagem de tempo e calcula o tempo gasto armazenando o valor na
varivel mTime;
20
2.6 QuickSort
2.6.1 Implementao
21
estar particionado em uma parte esquerda com chaves menores ou iguais ao piv e
outra maiores ou iguais [19].
A implementao do mtodo Partition apresentado no Programa 2.9, para
a escolha do piv foi implementada a variao mediana de trs, em que o pivo
escolhido usando a mediana entre a chave mais esquerda, a chave mais direita e
a chave central [18].
Programa 2.9: Mtodo Partition utilizado pelo QuickSort.
void SortMethods : : P a r t i t i o n ( long Left , long Right , long i , long j ,
TItem Array ) {
TItem aux1 , aux2 ;
i = Left ;
j = Right ;
j ) /2];
do
aux1 = Array [ ( i +
this
{
while
>m C o m p a r a t i o n s++;
this
( a u x 1 . Key > Array [ i ] . Key ) {
>m C o m p a r a t i o n s++;
( i ) ++;
this
}
while
>m C o m p a r a t i o n s++;
j
this
( a u x 1 . Key < Array [ ] . Key ) {
>m C o m p a r a t i o n s++;
( j ) ;
if
}
( i <= j ){
this
aux2 = Array [ i ];
>mMoviments++;
j
this
Array [ i ] = Array [ ];
>mMoviments++;
this
Array [ j ] = aux2 ;
>mMoviments++;
( i ) ++;
( j ) ;
while
}
} ( i <= j) ;
}
i , j ;
if
P a r t i t i o n ( Left , Right , &i , &j , Array ) ;
( Left < j )
if
MethodQuick ( L e f t , j , Array ) ;
( i < Right )
22
3. Escolha um elemento aux1 do vetor Array para ser o piv;
4. Usando aux1 divida o vetor Array em duas partes, da seguinte maneira:
Comeando com i = posio inicial, percorra o vetor em forma crescente
at que um elemento Array[i] = aux1 seja encontrado.
Comeando com j = posio nal, percorra o vetor em forma descendente
at que um elemento A[j] = X seja encontrado;
Se i <= j, troque Array[i] com Array[j];
Continue percorrendo o vetor procurando elementos Array[i] e Array[j]
at que os contadores i e j se cruzem (j < i).
5. Repita, recursivamente, os passos 3 e 4 para as duas partes
6. A cada comparao incrementa a varivel mComparations e a cada movimen-
tao incrementa a varivel mMoviments;
7. Pausa a contagem de tempo e calcula o tempo gasto armazenando o valor na
varivel mTime;
this
CTimer Timer = CTimer ( ) ;
>C l e a r A l l ( ) ;
this
Timer >s t a r t ( ) ;
>MethodQuick ( 0 , n 1 , A r r a y ) ;
this
Timer >s t o p ( ) ;
recursivas cerca de n. Entretanto o pior caso pode ser evitado empregando-se mod-
icaes na escolha do piv [10, 19, 18]. A melhor situao possvel ocorre quando
cada partio divide o arquivo em duas partes iguais. Logo, a Equao 2.8 demon-
stra o calculo da funo de complexidade em relao ao nmero de comparaes.
23
C(n) = n log n n + 1
(2.8)
No caso mdio o nmero de compaes apresentado na Equao 2.9, signi-
cando assim que a sua ordem de complexidade O(n log n).
24
2.7 HeapSort
25
Programa 2.12: Operaes com Heap necessrias ao HeapSort.
void long long Array ) {
long
S o r t M e t h o d s : : ReMake ( Left , Right , TItem
long
i = Left ;
j ;
TItem aux ;
j = i 2;
while
aux = Array [ i ] ;
if
( j <= Right ) {
this
( j < Right ) {
if
>m C o m p a r a t i o n s++;
j ++;
this
}
if
>m C o m p a r a t i o n s++;
break
( aux . Key >= A r r a y [ j ] . Key )
Array [ i ] = Array [ j ] ;
i = j ;
this
j = i 2 ;
>mMoviments++;
this
Array [ i ] = aux ;
>mMoviments++;
void long
}
Array ,
long
S o r t M e t h o d s : : B u i l d ( TItem n){
Left ;
while
Left = n / 2 + 1;
( Left > 1)
Left ;
ReMake ( L e f t , n, Array ) ;
Left , Right ;
new
TItem aux ;
Timer
this
CTimer = CTimer ( ) ;
>C l e a r A l l ( ) ;
this
Timer >s t a r t ( ) ;
>B u i l d ( A r r a y , n) ;
Left = 0;
1;
while
Right = n
( Right > 0) {
aux = Array [ 0 ] ;
this
Array [ Right ] = aux ;
>mMoviments++;
this
Right ;
this
Timer >s t o p ( ) ;
26
Depois pega-se o item na posio 0 do vetor(raiz do heap ) e troca-se com o
item que est na posio n do vetor, como apresentado no Programa 2.13. A seguir,
basta usar o mtodo ReMake com o restante dos itens. A Figura 2.10 ilustra o
funcionamento deste mtodo.
2.7.1 Implementao
27
7. A cada comparao incrementa a varivel mComparations e a cada movimen-
tao incrementa a varivel mMoviments;
8. Pausa a contagem de tempo e calcula o tempo gasto armazenando o valor na
varivel mTime;
28
2.8 MergeSort
outro algoritmo de ordenao do tipo dividir para conquistar. Sua idia bsica
criar uma sequncia ordenada a partir de duas outras tambm ordenadas. Para
isso, ele divide a sequncia original em pares de dados, ordena-as; depois as agrupa
em sequncias de quatro elementos, e assim por diante, at ter toda a sequncia
dividida em apenas duas partes, como ilustrado na Figura 2.14 [15].
29
2.8.1 Implementao
sizeof
) {
ArrayAux ) malloc L e f t )
long
TItem = ( TItem ( ( Right ( TItem ) ) ;
i , j ,k;
i = Left ;
j = Means ;
while
k = 0;
this
( i < Means && j < Right ) {
this
>mMoviments++;
if
>m C o m p a r a t i o n s++;
else
ArrayAux [ k++] = Array [ i ++];
while
}
( i < Means ) {
this
ArrayAux [ k++] = Array [ i ++];
>mMoviments++;
while
}
( j < Right ) {
this
ArrayAux [ k++] = Array [ j ++];
>mMoviments++;
for
}
L e f t
this
Array [ i ] = ArrayAux [ i ];
>mMoviments++;
free ( ArrayAux ) ;
30
Programa 2.15: Mtodo MergeSort.
void long
new
S o r t M e t h o d s : : M e r g e S o r t ( TItem Array , n){
this
CTimer Timer = CTimer ( ) ;
>C l e a r A l l ( ) ;
long
Timer >s t a r t ( ) ;
long
Left , Right ;
while
Means = 1 ;
while
Left = 0;
Means ;
if
Right = Left + 2
( Right > n)
this
Right = n;
Means = 2 Means ;
}
>s t o p ( )
this
Timer ;
31
Captulo 3
Testes
Neste captulo so apresentados os resultados dos testes realizados com 4 tipos
de vetores e 4 tamanhos diferentes. A anlise dos resultados so feitos na Seo 3.3
32
3.2 Resultados
Foram testados os sete mtodos de ordenao, para cada mtodo foi testado um
tamanho diferente de vetor (100, 1000, 10000, 100000) e para cada tamanho um
tipo diferente (Ordenado Crescente, Ordenado Decrescente, Ordenado Aleatrio e
parcialmente Aleatrio). Para o tipo Aleatrio o teste foi realizado para 10 vetores
diferentes, assim o resultado aqui apresentado a mdia dos valores. Os resultados
dos 364 testes sero apresentados em quatro grupos, divididos pelo tipo do Vetor.
Os mtodos sero numerados para apresentao na tabela, conforme a lista abaixo:
1. BubbleSort
2. InsertSort
3. SelectSort
4. ShellSort
5. QuickSort
6. HeapSort
7. MergeSort
33
3.2.1 Vetor ordenado em ordem crescente
A seguir as Figuras 3.1, 3.2, 3.3 e 3.4 apresentam os grcos em funo do nmero
de comparaes e movimentos para os quatro tamanhos de vetores testados.
34
Figura 3.1: Nmero de comparaes e movimentaes do teste aplicado em um vetor
de 100 posies do tipo OrdC.
35
Figura 3.3: Nmero de comparaes e movimentaes do teste aplicado em um vetor
de 10000 posies do tipo OrdC.
36
3.2.2 Vetor ordenado em ordem decrescente
A seguir as Figuras 3.5, 3.6, 3.7 e 3.8 apresentam os grcos em funo do nmero
de comparaes e movimentos para os quatro tamanhos de vetores testados.
37
Figura 3.5: Nmero de comparaes e movimentaes do teste aplicado em um vetor
de 100 posies do tipo OrdD.
38
Figura 3.7: Nmero de comparaes e movimentaes do teste aplicado em um vetor
de 10000 posies do tipo OrdD.
39
3.2.3 Vetor parcialmente ordenado
40
Figura 3.9: Nmero de comparaes e movimentaes do teste aplicado em um vetor
de 100 posies do tipo OrdP.
41
Figura 3.11: Nmero de comparaes e movimentaes do teste aplicado em um
vetor de 10000 posies do tipo OrdP.
42
3.2.4 Vetor aleatrio
Vetor Aleatrio
100 1000 10000 100000
Comp. Mov. Comp. Mov. Comp. Mov. Comp. Mov.
1 4950 2628 499500 242827 49995000 25160491 4999950000 2499136980
2 99 2387 999 253364 9999 25012754 99999 2500402956
3 4950 297 499500 2997 49995000 29997 4999950000 299997
4 818 1160 14364 19821 236735 311978 3711435 4670697
5 997 570 12852 8136 181203 103575 2114943 1310586
6 1205 817 18837 11556 255288 149150 3220006 1825075
7 558 1376 8744 19968 123685 272640 1566749 3385984
Tabela 3.7: Quantidade de comparaes e movimentos dos testes no vetor OrdA.
Vetor Aleatrio
100 1000 10000 100000
1 0,000076 0,008084 0,858684 114,840058
2 0,000027 0,002531 0,323982 31,500937
3 0,000050 0,004834 0,561589 58,300695
4 0,000016 0,000290 0,006158 0,104286
5 0,000031 0,000403 0,004987 0,084427
6 0,000034 0,000420 0,009227 0,087964
7 0,00015 0,001598 0,019384 0,231564
Tabela 3.8: Tempo gasto pelos testes no vetor OrdA.
43
Figura 3.13: Nmero de comparaes e movimentaes do teste aplicado em um
vetor de 100 posies do tipo OrdA.
44
Figura 3.15: Nmero de comparaes e movimentaes do teste aplicado em um
vetor de 10000 posies do tipo OrdA.
45
3.3 Anlise dos Resultados
Figura 3.18: Tempo gasto pelos mtodos nos quatro tamanhos de vetores propostos.
Conforme os grcos podemos observar que:
O InsertSort a escolha ideal para um vetor que ja est ordenado, indepen-
dente do seu tamanho;
46
BubbleSort e SelectSort so os piores para vetores j ordenados.
47
3.3.2 Vetor ordenado em ordem decrescente
Figura 3.20: Tempo gasto pelos mtodos nos quatro tamanhos de vetores propostos.
48
BubbleSort , InsertSort e SelectSort so os piores para vetores j ordena-
dos inversamente.
Dentre os algoritmos ecientes o MergeSort o que tem o pior tempo de
execuo.
49
3.3.3 Vetor parcialmente ordenado
Figura 3.22: Tempo gasto pelos mtodos nos quatro tamanhos de vetores propostos.
Conforme os grcos podemos observar que:
O ShellSort e QuickSort so os melhores para este tipo de vetor em qualquer
tamanho, porm para arquivos pequenos existe uma vantagem do InsertSort .
BubbleSort e SelectSort so os piores para este tipo de vetor, independente
do tamanho.
50
Dentre os algoritmos ecientes o MergeSort o que tem o pior tempo de
execuo.
At 1000 elementos o InsertSort apresentou compotamento n log n, acima
disto ele apresentou-se como quadrtico.
51
3.3.4 Vetor aleatrio
Figura 3.24: Tempo gasto pelos mtodos nos quatro tamanhos de vetores propostos.
Conforme os grcos podemos observar que:
Para pequenos arquivos o ShellSort foi o melhor, para os maiores o Quick-
Sort apresentou o melhor tempo de execuo.
Os algoritmos quadrticos foram os piores neste teste, sendo o InsertSort o
que apresentou um vantagem entre eles.
52
Dentre os algoritmos ecientes o MergeSort o que tem o pior tempo de
execuo.
53
Captulo 4
Concluso
Foram apresentados sete mtodos de ordenao interna mediante a compara-
o de chaves. A Seo 3 aprentou os dados de 364 testes realizados utilizando
esses mtodos. Aps o estudo desses resultados e dos algoritmos, so apresentadas
observaes sobre cada um dos mtodos.
1. BubbleSort :
2. InsertSort :
3. SelectSort :
54
No arquivo parcialmente ordenado ele foi o melhor.
5. QuickSort :
6. HeapSort :
55
Apndice A
CTimer
Implementao da classe CTimer utilizada para a medio do tempo de execuo
dos algoritmos de ordenao.
Programa A.1: Implementao dos mtodos da classe CTimer.
#include " s t d a f x . h"
#include "CTimer . h"
CTimer : : CTimer ( ) {
t S t a r t . QuadPart = 0;
t S t o p . QuadPart = 0;
double L I T o S e c s (LARGE_INTEGER L) {
LARGE_INTEGER frequency ;
((
) L >QuadPart /( ) f r e q u e n c y . QuadPart ) ;
void
this
CTimer : : s t a r t ( ) {
Q u e r y P e r f o r m a n c e C o u n t e r (& >t S t a r t ) ;
void
this
CTimer : : s t o p ( ) {
Q u e r y P e r f o r m a n c e C o u n t e r (& >t S t o p ) ;
double CTimer : : g e t E l a p s e d T i m e ( ) {
this this
LARGE_INTEGER time ;
return
t i m e . QuadPart = >t S t o p . QuadPart >t S t a r t . QuadPart ;
L I T o S e c s (& t i m e ) ;
56
Apndice B
Operations
Foi implementado 3 mtodos auxiliares para a realizao dos testes. So eles:
#include
using namespace
<i o s t r e a m >
std ;
long int
sizeof
TItem GeneratingArray ( mItens , Type ) {
int
TItem Array = ( TItem ) malloc ( ( TItem ) mItens ) ;
srand ( ( ) t i m e (NULL) ) ;
57
switch
case
( Type ) {
for long
0:{
break
A r r a y [ i ] . Key = i ;
case
} ;
int
1:{
for long
p =0;
( i =m I t e n s 1; i >=0; i )
break
A r r a y [ p + + ] . Key = i ;
case
} ;
for long
2:{
long
( i =0; i <m I t e n s ; i ++)
break
A r r a y [ i ] . Key = ( ) rand ( ) % mItens ;
case
} ;
for long
3:{
if
( i =0; i <m I t e n s ; i ++){
do
( i %10==0)
long
while
A r r a y [ i ] . Key = ( ) rand ( ) % mItens ;
else
( A r r a y [ i ] . Key == i ) ;
A r r a y [ i ] . Key = i ;
return
}
Array ;
void long
P r i n t A r r a y ( TItem Array , mItens ) {
"=================================="
for long
cout << ;
cout . width ( 6 ) ;
return
Print ) ;
CommandTemp ;
return
( p F i l e==NULL)
char
TCommand Command ;
buffer [200];
sprintf ( buffer , "%12s %12s %12s %14s %14s %12s \n\n" , "Method" ,
"Quant" , "Type" , "mComp. " , "mMovim . " , "mTime" ) ;
58
int
fputs ( buffer , pFile2 ) ;
int
type ;
new
i =1;
Sort
while
SortMethods = SortMethods ( ) ;
Command = ProcessCommand ( b u f f e r ) ;
else if
type = 0;
else if
type = 1;
else if
type = 2;
type = 3;
if ( Command . P r i n t )
P r i n t A r r a y ( Array , Command . m I t e n s ) ;
S o r t > I n s e r t S o r t ( A r r a y , Command . m I t e n s ) ;
S o r t > S e l e c t S o r t ( A r r a y , Command . m I t e n s ) ;
S o r t > S h e l l S o r t ( A r r a y , Command . m I t e n s ) ;
S o r t >Q u i c k S o r t ( A r r a y , Command . m I t e n s ) ;
S o r t >H e a p S o r t ( A r r a y , Command . m I t e n s ) ;
S o r t >M e r g e S o r t ( A r r a y , Command . m I t e n s ) ;
if ( Command . P r i n t )
P r i n t A r r a y ( Array , Command . m I t e n s ) ;
sprintf ( buffer , "%12s %12d %12s %14.0 f %14.0 f %12 f \n" , Command
. Method , Command . m I t e n s , Command . TypeArray , S o r t >
g e t C o m p a r a t i o n s ( ) , S o r t >g e t M o v i m e n t s ( ) , S o r t >g e t T i m e ( ) ) ;
f c l o s e ( pFile ) ;
f c l o s e ( pFile2 ) ;
59
Apndice C
Arquivos de sada contendo os
resultados
Arquivos do tipo texto contendo os resultados dos seguintes testes realizados.
60
Arquivo C.1: Resultados do testes utilizando BubbleSort.
Method Quant Type mComp . mMovim . mTime
61
Arquivo C.2: Resultados do testes utilizando InsertSort.
Method Quant Type mComp . mMovim . mTime
62
Arquivo C.3: Resultados do testes utilizando SelectSort.
Method Quant Type mComp . mMovim . mTime
63
Arquivo C.4: Resultados do testes utilizando ShellSort.
Method Quant Type mComp . mMovim . mTime
64
Arquivo C.5: Resultados do testes utilizando QuickSort.
Method Quant Type mComp . mMovim . mTime
65
Arquivo C.6: Resultados do testes utilizando HeapSort.
Method Quant Type mComp . mMovim . mTime
66
Arquivo C.7: Resultados do testes utilizando MergeSort.
Method Quant Type MComp . MMovim . MTime
67
Referncias Bibliogrcas
[1] Ricardo Annes. Ordenao por seleo, 2008. http://pucrs.campus2.br/
~annes/alg3_ord_sel.
[2] Jos Elias C. Arroyo. Inf111 - programao ii, aulas 11, 12, 13 - ordenao,
2007. www.dpi.ufv.br/disciplinas/inf111/2006_2/Ordenacao1.pdf.
[3] Julio Cesar de Andrade Vieira Lopes. Heap, 2005. www.abusar.org/ftp/pub/
pitanga/Heap.pdf.
[4] Thales Castelo Branco de Castro. Mtodos de ordenao, 2008.
http://www.nuperc.unifacs.br/Members/thales.castro/arquivos/
aulas/Ordenacao%20Interna.ppt.
[5] Alvaro Borges de Oliveira. Mtodos de Ordenao Interna. Visual Book, So
Paulo, 1st edition, 2002.
[6] Paulo Feolo. Projeto de algoritmos: Quicksort, 1998. http://www.ime.usp.
br/~pf/algoritmos/aulas/quick.html.
[7] David Menotti Gomes. Ordenao, 2008. http://www.decom.ufop.br/prof/
menotti/aedI/slides/aula14-Ordenacao.ppt.
[8] David Menotti Gomes. Ordenao - heapsort, 2008. http://www.decom.ufop.
br/prof/menotti/aedI/slides/aula17-HeapSort.ppt.
[9] David Menotti Gomes. Ordenao - mergesort, 2008. http://www.decom.
ufop.br/prof/menotti/aedI/slides/aula18-MergeSort.ppt.
[10] David Menotti Gomes. Ordenao - quicksort, 2008. http://www.decom.ufop.
br/prof/menotti/aedI/slides/aula16-QuickSort.ppt.
[11] David Menotti Gomes. Ordenao - shellsort, 2008. http://www.decom.ufop.
br/prof/menotti/aedI/slides/aula15-ShellSort.ppt.
[12] Michael Lamont. Shell sort, 2008. http://linux.wku.edu/~lamonml/algor/
sort/shell.html.
[13] H. W. Lang. Insertion sort, 2008. http://www.inf.fh-flensburg.de/lang/
algorithmen/sortieren/insert/insertionen.htm.
[14] Ronaldo S. Mello. Ordenao de dados(iii), 2002. www.dcc.ufam.edu.br/
~alf/MATERIAL%20AED2/HEAPSORT.pdf.
68
[15] Marcus Ritt. Algoritmos e complexidade - notas de aula, 2007. www.inf.
ufrgs.br/~buriol/cursos/complexidade07/Aula-cap5-n1.pdf.
[16] Roslia Rodrigues. Mtodos de programao, 2002. http://www2.mat.ua.pt/
rosalia/arquivo/MP/acetatos9.pdf.
[17] Robert Sedgewick. Algorithms. Addison-Wesley, Massachussets, 2st edition,
1989.
[18] Hamid Reza Shahbazkia. Quicksort. http://w3.ualg.pt/~hshah/ped/Aula%
2014/Quick_final.html.
[19] Nivio Ziviani. Projeto de Algoritmos com implementao em C++ e Java.
THOMSON Learning, So Paulo, 1st edition, 2007.
69