tp3 Sol1

Universidade Federal de Ouro Preto Instituto de Cincias Exatas e Biolgicas Departamento de Computao
ALGORITMOS E ESTRUTURAS DE DADOS Mtodos de ordenao Interna.
Antonio Carlos de Nazar Jnior Professor - David Menotti Gomes
Ouro Preto 14 de novembro de 2008
Sumrio
1 Introduo 2 Mtodos de Ordenao 2.1 Mtodos de Ordenao Interna . . 2.1.1 Implementao dos mtodos 2.2 BubbleSort . . . . . . . . . . . . . 2.2.1 Implementao . . . . . . . 2.2.2 Estudo da Complexidade . . 2.2.3 Anlise do algoritmo . . . . 2.3 InsertSort . . . . . . . . . . . . . . 2.3.1 Implementao . . . . . . . 2.3.2 Estudo da Complexidade . . 2.3.3 Anlise do algoritmo . . . . 2.4 SelectSort . . . . . . . . . . . . . . 2.4.1 Implementao . . . . . . . 2.4.2 Estudo da Complexidade . . 2.4.3 Anlise do algoritmo . . . . 2.5 ShellSort . . . . . . . . . . . . . . . 2.5.1 Implementao . . . . . . . 2.5.2 Estudo da Complexidade . . 2.5.3 Anlise do algoritmo . . . . 2.6 QuickSort . . . . . . . . . . . . . . 2.6.1 Implementao . . . . . . . 2.6.2 Estudo da Complexidade . . 2.6.3 Anlise do algoritmo . . . . 2.7 HeapSort . . . . . . . . . . . . . . . 2.7.1 Implementao . . . . . . . 2.7.2 Estudo da Complexidade . . 2.7.3 Anlise do algoritmo . . . . 2.8 MergeSort . . . . . . . . . . . . . . 2.8.1 Implementao . . . . . . . 2.8.2 Estudo da Complexidade . . 2.8.3 Anlise do algoritmo . . . . 1 2 3 3 6 7 8 9 10 11 12 13 14 15 16 16 18 19 20 20 21 21 23 24 25 27 28 28 29 30 31 31 32 32 33 34
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3 Testes 3.1 Metodologia dos Testes . . . . . . . . . . . . . . . . . . . . . . . . . . 3.2 Resultados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.2.1 Vetor ordenado em ordem crescente . . . . . . . . . . . . . . .
3.2.2 Vetor ordenado em ordem decrescente . 3.2.3 Vetor parcialmente ordenado . . . . . . 3.2.4 Vetor aleatrio . . . . . . . . . . . . . 3.3 Anlise dos Resultados . . . . . . . . . . . . . 3.3.1 Vetor ordenado em ordem crescente . . 3.3.2 Vetor ordenado em ordem decrescente . 3.3.3 Vetor parcialmente ordenado . . . . . . 3.3.4 Vetor aleatrio . . . . . . . . . . . . .
4 Concluso A CTimer B Operations C Arquivos de sada contendo os resultados
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
37 40 43 46 46 48 50 52
54 56 57 60
Lista de Tabelas
2.1 2.2 2.3 2.4 2.5 2.6 2.7 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 Vantagens e desvantagens do Mtodo BubbleSort. Vantagens e desvantagens do Mtodo InsertSort. . Vantagens e desvantagens do Mtodo SelectSort. . Vantagens e desvantagens do Mtodo ShellSort. . Vantagens e desvantagens do Mtodo QuickSort. . Vantagens e desvantagens do Mtodo HeapSort. . Vantagens e desvantagens do Mtodo MergeSort. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9 13 17 20 24 28 31 34 34 37 37 40 40 43 43
Quantidade de comparaes e movimentos dos testes no vetor OrdC. Tempo gasto pelos testes no vetor OrdC. . . . . . . . . . . . . . . . . Quantidade de comparaes e movimentos dos testes no vetor OrdD. Tempo gasto pelos testes no vetor OrdD. . . . . . . . . . . . . . . . . Quantidade de comparaes e movimentos dos testes no vetor OrdP. . Tempo gasto pelos testes no vetor OrdP. . . . . . . . . . . . . . . . . Quantidade de comparaes e movimentos dos testes no vetor OrdA. Tempo gasto pelos testes no vetor OrdA. . . . . . . . . . . . . . . . .
Lista de Figuras
2.1 2.2 2.3 2.4 2.5 2.6 2.7 2.8 2.9 2.10 2.11 Exemplo de ordenao Estvel e Instvel. . . . . . . . . Ilustrao do funcionamento do algoritmo BubbleSort. Fluxograma do algoritmo BubbleSort. . . . . . . . . . . Ilustrao do funcionamento do algoritmo InsertSort. . Fluxograma do algoritmo InsertSort. . . . . . . . . . . Ilustrao do funcionamento do algoritmo SelectSort. . Ilustrao do funcionamento do algoritmo ShellSort. . . Ilustrao do funcionamento do algoritmo QuickSort. . Ilustrao de um Heap mximo. . . . . . . . . . . . . . Ilustrao do funcionamento do algoritmo HeapSort. . . Ilustrao do funcionamento do algoritmo MergeSort. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2 6 7 10 10 14 18 21 25 27 29
3.1 Nmero de comparaes e movimentaes do teste aplicado em um vetor de 100 posies do tipo OrdC. . . . . . . . . . . . . . . . . . . 3.2 Nmero de comparaes e movimentaes do teste aplicado em um vetor de 1000 posies do tipo OrdC. . . . . . . . . . . . . . . . . . 3.3 Nmero de comparaes e movimentaes do teste aplicado em um vetor de 10000 posies do tipo OrdC. . . . . . . . . . . . . . . . . 3.4 Nmero de comparaes e movimentaes do teste aplicado em um vetor de 100000 posies do tipo OrdC. . . . . . . . . . . . . . . . . 3.5 Nmero de comparaes e movimentaes do teste aplicado em um vetor de 100 posies do tipo OrdD. . . . . . . . . . . . . . . . . . . 3.6 Nmero de comparaes e movimentaes do teste aplicado em um vetor de 1000 posies do tipo OrdD. . . . . . . . . . . . . . . . . . 3.7 Nmero de comparaes e movimentaes do teste aplicado em um vetor de 10000 posies do tipo OrdD. . . . . . . . . . . . . . . . . 3.8 Nmero de comparaes e movimentaes do teste aplicado em um vetor de 100000 posies do tipo OrdD. . . . . . . . . . . . . . . . . 3.9 Nmero de comparaes e movimentaes do teste aplicado em um vetor de 100 posies do tipo OrdP. . . . . . . . . . . . . . . . . . . 3.10 Nmero de comparaes e movimentaes do teste aplicado em um vetor de 1000 posies do tipo OrdP. . . . . . . . . . . . . . . . . . 3.11 Nmero de comparaes e movimentaes do teste aplicado em um vetor de 10000 posies do tipo OrdP. . . . . . . . . . . . . . . . . . 3.12 Nmero de comparaes e movimentaes do teste aplicado em um vetor de 100000 posies do tipo OrdP. . . . . . . . . . . . . . . . . 3.13 Nmero de comparaes e movimentaes do teste aplicado em um vetor de 100 posies do tipo OrdA. . . . . . . . . . . . . . . . . . . 5
. 35 . 35 . 36 . 36 . 38 . 38 . 39 . 39 . 41 . 41 . 42 . 42 . 44
3.14 Nmero de comparaes e movimentaes do teste aplicado em um vetor de 1000 posies do tipo OrdA. . . . . . . . . . . . . . . . . . . 3.15 Nmero de comparaes e movimentaes do teste aplicado em um vetor de 10000 posies do tipo OrdA. . . . . . . . . . . . . . . . . . 3.16 Nmero de comparaes e movimentaes do teste aplicado em um vetor de 100000 posies do tipo OrdA. . . . . . . . . . . . . . . . . . 3.17 Curva de desempenho dos 7 mtodos. . . . . . . . . . . . . . . . . . . 3.18 Tempo gasto pelos mtodos nos quatro tamanhos de vetores propostos. 3.19 Curva de desempenho dos 7 mtodos. . . . . . . . . . . . . . . . . . . 3.20 Tempo gasto pelos mtodos nos quatro tamanhos de vetores propostos. 3.21 Curva de desempenho dos 7 mtodos. . . . . . . . . . . . . . . . . . . 3.22 Tempo gasto pelos mtodos nos quatro tamanhos de vetores propostos. 3.23 Curva de desempenho dos 7 mtodos. . . . . . . . . . . . . . . . . . . 3.24 Tempo gasto pelos mtodos nos quatro tamanhos de vetores propostos.
44 45 45 46 46 48 48 50 50 52 52
Lista de Programas e Arquivos

2.1 2.2 2.3 2.4 2.5 2.6 2.7 2.8 2.9 2.10 2.11 2.12 2.13 2.14 2.15 3.1 A.1 B.1 C.1 C.2 C.3 C.4 C.5 C.6 C.7 Estrutura do tipo Item. . . . . . . . . . . . . . . . Estrutura da classe SortMethods. . . . . . . . . . Mtodo para zerar valores. . . . . . . . . . . . . . Mtodos de consulta s variveis de medida. . . . Mtodo BubbleSort. . . . . . . . . . . . . . . . . Mtodo InsertSort. . . . . . . . . . . . . . . . . . Mtodo SelectSort. . . . . . . . . . . . . . . . . . Mtodo SelectSort. . . . . . . . . . . . . . . . . . Mtodo Partition utilizado pelo QuickSort. . . . . Mtodo MethodQuick. . . . . . . . . . . . . . . . Mtodo QuickSort. . . . . . . . . . . . . . . . . . Operaes com Heap necessrias ao HeapSort. . . Mtodo HeapSort. . . . . . . . . . . . . . . . . . . Mtodo Merge responsvel pela intercalao. . . . Mtodo MergeSort. . . . . . . . . . . . . . . . . . Exemplo de um arquivo de entrada para teste. . . Implementao dos mtodos da classe CTimer. . . Implementao dos mtodos da classe Operations. Resultados do testes utilizando BubbleSort. . . . Resultados do testes utilizando InsertSort. . . . . Resultados do testes utilizando SelectSort. . . . . Resultados do testes utilizando ShellSort. . . . . . Resultados do testes utilizando QuickSort. . . . . Resultados do testes utilizando HeapSort. . . . . Resultados do testes utilizando MergeSort. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2 4 4 5 7 11 15 19 22 22 23 26 26 30 31 32 56 57 61 62 63 64 65 66 67
Captulo 1 Introduo
Em vrios momentos do dia a dia, o homem depara-se com a necessidade de consultar dados ordenados. Como exemplo, pode-se citar uma lista telefnica. Imagine como seria consultar o telefone de uma pessoa se os nomes no estivessem classicados 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
cente, aleatrios e parcialmente ordenados com apenas 10% dos elementos fora da ordem ).
1. Nmero de comparaes entre chaves do vetor; 2. Nmero de movimentaes; 3. Contagem do tempo gasto durante a execuo do algoritmo;
Os testes foram realizados com vetores de nmeros inteiros de diferentes tamanhos (100, 1000, 10000 e 100000 ) e tipos (ordenados em ordem crescente e decres-
Como medidas para a comparao entre os mtodos foi colhido durante cada teste:
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 recuperados... [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.
typedef long typedef struct

TKey } TItem ; Key ;
Programa 2.1: Estrutura do tipo Item.

TItem {
TKey ;
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.
Figura 2.1: Exemplo de ordenao Estvel e Instvel. 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 computador; 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].
2.1 Mtodos de Ordenao Interna
Durante a escolha de um algoritmo de ordenao, deve-se observar um aspecto importante, o tempo gasto durante a sua execuo. Para algoritmos de ordenao interna, as medidas de complexidade relevantes contam o nmero de comparaes entre chaves e o nmero de movimentaes de itens do arquivo [19]. Uma outra medida que pesa na escolha a quantidade de memria extra utilizada pelo algoritmo. Metdos que realizam a permutao dos elementos no prprio vetor so chamados in situ , esses mtodos so os preferidos. Os mtodos que necessitam de memria extra para armazenar outra cpia do itens possuem menor importncia. Os mtodos de ordenao interna so classicados em dois subgrupos [4].
Mtodos simples:
1. BubbleSort 2. InsertSort 3. SelectSort

Mtodos ecientes:
1. 2. 3. 4.
2.1.1
ShellSort QuickSort HeapSort MergeSort
Implementao dos mtodos
Os mtodos foram implementados em uma nica classe SortMethods que responsvel pela ordenao dos vetores e pela medio do tempo, nmero de comparaes e nmero de movimentaes. A classe foi implementada utilizando programao orientada a objetos, pela necessidade do encapsulamento das variaveis que controlam as medidas de tempo, movimento e comparao. Para medio do tempo foi implementada a classe CTimer que apresentada no Apndice A. O Programa 2.2 apresenta a estrutura da classe SortMethods . 3
#ifndef #define #include #include class private double double double void void void void void void public
: :
Programa 2.2: Estrutura da classe SortMethods.
_ O T E H D _ S R M T O S _ O T E H D _ S R M T O S
"CTimer . h" " Types . h"
SortMethods {
mComparations ; mMoviments ; mTime ;
ClearAll () ; Partition (
ReMake (
B u i l d ( TItem
MethodQuick (
Merge ( TItem
long long long long long long long long

Left , Left , Array , Left , Array ,
Right ,
long
Right , n) ;
TItem
i , Array ) ;
long long
TItem
A) ;
Right ,
Left ,
long
TItem
A) ;
Means ,
Right ) ;
void void void void void void void double double double #endif
};
SortMethods ( ) ; B u b b l e S o r t ( TItem S e l e c t S o r t ( TItem
Array , Array , I n s e r t S o r t ( TItem A r r a y , S h e l l S o r t ( TItem A r r a y , Q u i c k S o r t ( TItem A r r a y , H e a p S o r t ( TItem A r r a y , M e r g e S o r t ( TItem A r r a y ,

getTime ( ) ; getComparations ( ) ; getMoviments ( ) ;
long long long long long long long
n) ; n) ; n) ; n) ; n) ;
n) ; n) ;
As variveis mComparations, mMoviments e mTime, tem como nalidade armazenar o nmero de comparaes, movimentos e tempo gasto, respectivamente, em cada execuo de um mtodo de ordenao. O procedimento ClearAll(), apresentada no Programa 2.3 chamado a cada vez que um mtodo iniciado. Esta funo zera os valores das variveis de medio.
void this this this

}
Programa 2.3: Mtodo para zerar valores.

= 0; 0;
SortMethods : : C l e a r A l l ( ) { >m C o m p a r a t i o n s >mMoviments = >mTime = 0;
Os demais mtodos Privates sero apresentados juntamente com os mtodos de ordenao que utilizam-os. A consulta das vriaveis de medidas da classe SortMethods feita atravs das seguintes funes que so mostrada no Programa 2.4:
double getTime(): Retorna o tempo em segundos gasto pelo algoritmo de
ordenao;
double getComparations():
chaves;
Retorna o nmero de comparaes entre
double getMoviments(): Retorna o nmero de movimentaes (trocas) re-
alizadas entre os itens;
double return this

}
Programa 2.4: Mtodos de consulta s variveis de medida.

>mTime ;
SortMethods : : getTime ( ) {
double return this

}
SortMethods : : getComparations ( ) { >m C o m p a r a t i o n s ;
double return this

}
SortMethods : : getMoviments ( ) { >mMoviments ;
Para os mtodos de ordenao a entrada ser a estrutura a ser ordenada (vetor) e o nmero de itens contido na estrutura. O calculo da funo de complexidade deste algoritmo ser denido em razo a duas grandezas: O nmero de movimentaes [M (n)] e o nmero de comparaes entre chaves [C(n)].
2.2
BubbleSort
o mtodo mais simples em termos de implementao, porm o menos eciente. A idia principal do algoritmo percorrer o vetor n 1 vezes, a cada passagem fazendo utuar para o inicio o menor elemento da sequncia. Essa movimentao, ilustrada na Figura 2.2, lembra a forma como as bolhas procuram seu prprio nvel, por isso o nome do algoritmo. Seu uso no recomendado para vetores com muitos elementos [7].
Figura 2.2: Ilustrao do funcionamento do algoritmo BubbleSort.
A seguir na Figura 2.3 mostrado o uxograma do algoritmo.
Figura 2.3: Fluxograma do algoritmo BubbleSort.

2.2.1 Implementao
void long
Programa 2.5: Mtodo BubbleSort.

Array ,
S o r t M e t h o d s : : B u b b l e S o r t ( TItem i , j ;
long
n){
TItem CTimer
aux ;
Timer (
this for for this if this this this

i = j 0 ( = ( aux } }
Timer
new
j <
CTimer ( ) ;
>C l e a r A l l ( ) ; >s t a r t ( ) ; ; i ; < n
1 ; n i
i+ + ;
){ ){
j+ +
>m C o m p a r a t i o n s++; A r r a y [ j ] . Key < = Array [ j ] ; Array [ j
1 ] . Key ) {
>mMoviments++; = Array [ j
Array [ j ]
1];
>mMoviments++;
Array [ j
1]
aux ;
>mMoviments++;
} Timer
this
>s t o p ( )
>mTime =
; Timer
>g e t E l a p s e d T i m e ( )
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 movimentao 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].
2.2.2 Estudo da Complexidade
A Equao 2.1 demonstra o calculo da funo de complexidade em relao ao nmero de comparaes. Ela a mesma para o melhor, pior e caso mdio.
n2 ni1
C(n) =
i=0 n2 j=1
=
i=0 n2
(n i 1)
n2 n2
=
i=0
n
i=0
i
i=0
= = = =
(0 + n 2)(n 1) (n 1) n(n 1) 2 (n2 3n + 2) n2 n (n 1) 2 2n2 2n n2 + 3n 2 2n + 2 2 2 n n 2 O(n2 )
(2.1)
Ordem de Complexidade:
Para a funo de complexidade em relao ao nmero de movimentos (Equao 2.2 basta multiplicar a funo C(n) por 3 que o nmero de movimentaes a cada iterao do algoritmo. Ela tambm ser a mesma para os 3 casos (mdio, pior e melhor). 8
M (n) = 3 C(n) n2 n = 3 2 2 3n 3n = 2
(2.2)
O(n2 )
2.2.3
Anlise do algoritmo
O BubbleSort um mtodo de simples implementao, porm a sua ecincia a menor entre os mtodos de ordenao interna [17]. Admite contudo vrios melhoramentos e tambm uma boa base para a construo de mtodos mais elaborados [16]. A Tabela 2.1 apresenta as principais vantagens e desvantagens deste mtodo.
Vantagens - Fcil Implementao; Desvantagens - O fato de o arquivo j estar ordenado no ajuda em nada [7]; - Ordem de complexidade quadrtica;
- Algoritmo Estvel;
Tabela 2.1: Vantagens e desvantagens do Mtodo BubbleSort.
2.3
InsertSort
InsertSort um algoritmo elementar de ordenao [13]. eciente quando aplicado um vetor com poucos elementos. Em cada passo, a partir de i = 2, o i-simo item da sequncia fonte apanhado e transferido para a sequncia destino, sendo inserido no seu lugar apropriado [19]. O algoritmo assemelha-se com a maneira que os jogadores de cartas ordenam as cartas na mo em um jogo, como o pquer, por exemplo. As Figuras 2.4 e 2.5 apresentam o seu funcionamento e o uxograma ilustrativo, respectivamente.
Figura 2.4: Ilustrao do funcionamento do algoritmo InsertSort.
Figura 2.5: Fluxograma do algoritmo InsertSort. 10
2.3.1
Implementao
A colocao do item no seu lugar correto na sequncia ordenanda, como demonstra o Programa 2.6, realizada movendo os ndices de maiores valores para direita e ento inserindo o item na posio vazia.
void long
Programa 2.6: Mtodo InsertSort.

Array ,
S o r t M e t h o d s : : I n s e r t S o r t ( TItem i , j ; aux ;
long
n){
TItem
Timer
this for this this while this

CTimer ( i = aux = j = i ( j } Array [ j
Timer
new
CTimer ( ) ;
>C l e a r A l l ( ) ; >s t a r t ( ) ; 1; i < n; i ++){
Array [ i ] ;
>mMoviments++; 1;
>m C o m p a r a t i o n s++; ( j + >= 1] 0 = ) & & ( aux . Key < A r r a y [ j ] . Key ) ){
Array [ j
Array [ j ] ;
>mMoviments++;
this
1]
aux ;
>mMoviments++;
} Timer
this
>s t o p ( )
>mTime =
; Timer
O algoritmo procede da seguinte maneira: 1. Zera os valores das vriveis de medio atravs do mtodo ClearAll(); 2. Inicia a contagem de tempo com a funo start(); 3. O primeiro lao de repetio tem a funo de controlar o tamanho da sequencia analisada; 4. O segundo lao responsvel de colocar o novo elemento da sequencia, em relao anterior, no lugar apropriado; 5. A cada comparao incrementa a varivel mComparations e a cada movimentao incrementa a varivel mMoviments; 6. Pausa a contagem de tempo e calcula o tempo gasto armazenando o valor na varivel mTime; 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
A Equao 2.3 demonstra o calculo da funo de complexidade em relao ao nmero de comparaes.

n1 i
C(n) =
i=1 n1 j=1
=
i=1
(i)
(n 1)(1 + n 1 = 2 (n 1)(n) = 2 2 n n = 2
(2.3)
O(n2 )
A seguir na Equao 2.4 apresentada a complexidade em funo do nmero de movimentaes;

n1 i
C(n) =
i=1 n1
2+
j=1
=
i=1 n1
(2 + i)
n1
=
i=1
2+
i=1
= 2(n 1) + = = = = =
(n 1)(1 + 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 O(n2 )
(2.4)
12
2.3.3
Anlise do algoritmo
O InsertSort tambm um mtodo de simples implementao, e tem a complexidade igual ao BubbleSort . Pode ser aprimorado com o uso de sentinela e outras tcnicas de algoritmos. o melhor mtodo para se utilizar quando os arquivos j esto quase ordenados [7]. A Tabela 2.2 apresenta as principais vantagens e desvantagens deste mtodo.
Vantagens Desvantagens - Fcil Implementao - Nmero grande de movimentaes - Algoritmo Estvel - Ordem de complexidade quadrtica - O vetor j ordenado favorece a orde- - Ineciente quando o vetor est ordenao nado inversamente;
Tabela 2.2: Vantagens e desvantagens do Mtodo InsertSort.
13
2.4
SelectSort
Tem como principio de funcionamento selecionar o menor item do vetor e a seguir troc-lo pela primeira posio do vetor. Isto ocorre para os n 1 elementos restantes, depois com os n 2 itens, at que reste apenas um elemento [19]. A principal diferena deste mtodos em relao aos dois j apresentados que ele realiza apenas uma troca por iterao. A Figura 2.6 apresenta o seu funcionamento.
Figura 2.6: Ilustrao do funcionamento do algoritmo SelectSort.
14
2.4.1
Implementao
A colocao do item no seu lugar correto na sequncia ordenanda, como demonstra o Programa 2.7 realizada trocando o item de menor valor pela primeira posio do vetor.
void long
Programa 2.7: Mtodo SelectSort.

Array ,
S o r t M e t h o d s : : S e l e c t S o r t ( TItem i , j , Min ;
long
n){
TItem CTimer
aux ;
Timer
this for for this if

( i = Min = ( j ( } aux
Timer
new
n
CTimer ( ) ;
>C l e a r A l l ( ) ; >s t a r t ( ) ; 0; i <
; j
1;
i ++){
i ; = i + 1 < n; j ++){
>m C o m p a r a t i o n s++; A r r a y [ j ] . Key < j ; A r r a y [ Min ] . Key )
Min =
A r r a y [ Min ]
Array [ i ]
this this this

=
A r r a y [ Min ] ;
>mMoviments++; = Array [ i ] ;
>mMoviments++; = aux ;
>mMoviments++;
} Timer
this
>s t o p ( )
>mTime =
; Timer
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. O primeiro lao determina a dimenso de busca do menor elemento; 4. O segundo lao responsvel por realizar a busca pelo menor elemento; 5. Feito a busca realizada a troca do menor elemento pelo primeiro elemento; 6. Aps a troca o processo realizado novamente para os n i itens restantes; 7. A cada comparao incrementa a varivel mComparations e a cada movimentao incrementa a varivel mMoviments; 8. Pausa a contagem de tempo e calcula o tempo gasto armazenando o valor na varivel mTime;
15
2.4.2
A Equao 2.5 mostra a equao da funo de complexidade em relao ao nmero de comparaes.

n2 ni1
C(n) =
i=0 n2 j=1
=
i=0 n2
(n i 1)
n2 n2
=
i=0
n
i=0
i
i=0
= = = =
(0 + n 2)(n 1) (n 1) n(n 1) 2 (n2 3n + 2) 2 n n (n 1) 2 2n2 2n n2 + 3n 2 2n + 2 2 n2 n 2 O(n2 )
(2.5)
A seguir a funo de complexidade do nmero de movimentaes apresentado pela Equao 2.6.

n1
C(n) =
i=1
= 3(n 1) = 3n 3
(2.6)
O(n)
2.4.3
Anlise do algoritmo
O SelectSort um mtodo muito simples. Alm disso, o algoritmo de seleo apesenta um comportamento espetacular quanto ao nmero de movimentos de registros, cujo tempo de execuo linear, esta particularidade dicilmente encontrada em outros algoritmos de ordenao [19]. o algoritmo ideal para arquivos com registros muito grandes [1]. A Tabela 2.3 apresenta as principais vantagens e desvantagens deste mtodo. 16
Vantagens - Fcil Implementao
- Pequeno nmero de movimentaes - Interessante para arquivos pequenos
Desvantagens - O fato de o arquivo j estar ordenado no inuencia em nada - Ordem de complexidade quadrtica - Algoritmo no estvel
Tabela 2.3: Vantagens e desvantagens do Mtodo SelectSort.
17
2.5
ShellSort
Este algoritmo uma extenso do mtodo InsertShort proposto por Donald Shell em 1959. O algoritmo de insero troca itens adjacentes quando est procurando o ponto de insero na sequncia destino. Se o menor item estiver na posio mais direita no vetor, ento o nmero de comparaes e movimentaes igual a n 1 para encontra o seu ponto de insero [11]. O ShellSort contorna este problema, pemitindo trocas de registros distantes um do outro [19]. De maneira geral ele passa vrias vezes no vetor dividindo-o em vetores menores, e nestes so aplicados o algoritmo de ordenao por insero tradicional [2]. A Figura 2.7 ilustra o seu funcionamento.
Figura 2.7: Ilustrao do funcionamento do algoritmo ShellSort. Dentre os programas de ordenao interna que tem ordem de complexidade quadrtica,o ShellSort o mais eciente. 18
2.5.1
Implementao
O diferencial do ShellSort a diviso em h intervalos que ele realiza para posteriomente aplicar o mtodo de insero. Vrias sequncias para h tm sido experimentadas. Knuth(1973) mostrou experimentalmente que a escolha do incremento para h, mostrada a seguir na Equao 2.7 dicil de ser batida em mais de 20% dos casos em ecincia no tempo de execuo [19].
h(s > 1) = 3h(s 1) + 1 h(s = 1) = 1
(2.7) A implementao utilizando este calculo para h apresentada no Programa 2.8. Programa 2.8: Mtodo SelectSort.
S o r t M e t h o d s : : S h e l l S o r t ( TItem i , h = j ; 1;
void int int
Array ,
long
n){
TItem CTimer
aux ;
this do while do for this this while this this if break

Timer { h = h 3 } (h < { h /= ( 3; i = h aux = j = i ; j = h; ( j }
Timer
new
CTimer ( ) ;
>C l e a r A l l ( ) ; >s t a r t ( ) ;
1;
n) ;
<
i+ +
){
Array [ i ] ;
>mMoviments++;
>m C o m p a r a t i o n s++; ( Array [ j
h ] . Key >
aux . Key ) {
>m C o m p a r a t i o n s++; = Array [ j
Array [ j ]
h ];
>mMoviments++;
< ;
h)
Timer
this while this

}
Array [ j ]
aux ;
>mMoviments++;
(h
!=
1) ;
>s t o p ( ) ; Timer
>mTime =
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(); 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 movimentao incrementa a varivel mMoviments; 10. Pausa a contagem de tempo e calcula o tempo gasto armazenando o valor na varivel mTime;
O estudo da complexidade deste algoritmo contm alguns problemas matemticos muito difceis, a comear pela prpria sequencia de incrementos para h. De acordo com testes empricos utilizando a Formula 2.7 para o calculo dos incrementos, a ordem de complexidade do ShellSort de aproximadamente O(n1 , 25) ou O(n(log n)2 ) [?].
2.5.3 Anlise do algoritmo
O ShellSort uma tima opo para arquivos de tamanho moderado, mesmo porque sua implementao simples e requer uma quantidade de cdigo pequena [19, 12]. A Tabela 2.4 apresenta as principais vantagens e desvantagens deste mtodo.
Vantagens - Cdigo Simples - Interessante para tamanho moderado Desvantagens - Algoritmo no estvel de - Tempo de execuo sensvel ordem inicial do arquivo [11]
arquivos
Tabela 2.4: Vantagens e desvantagens do Mtodo ShellSort.
20
2.6
QuickSort
o algoritmo mais rpido que se conhece entre os de ordenao interna para uma ampla variedade de situaes. Foi escrito em 1960 e publicado em 1962 por C. A. R. Hoare aps vrios renamentos [19]. Porm em raras instncias especiais ele lento [6]. Adotando a estratgia Dividir para conquistar o funcionamento resume-se a dividir o problema de ordenar um vetor de n posies em dois outros menores [2]. A Figura 2.8 ilustra o seu funcionamento.
Figura 2.8: Ilustrao do funcionamento do algoritmo QuickSort. O QuickSort provavelmente o mais utilizado, porm a sua implementao demanda um pouco mais de pacincia e cautela.
2.6.1 Implementao
A parte crucial do algoritmo o mtodo Partition quem tem a funo de rearranjar o vetor por meio da escolha de um piv, de tal forma que ao nal o vetor 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].
void
i j
Programa 2.9: Mtodo Partition utilizado pelo QuickSort.

SortMethods : : P a r t i t i o n (
TItem TItem = =
Array ) {
aux2 ;
long
Left ,
long
Right ,
long
long
aux1 , Left ; Right ;
do
aux1 {
Array [ (
j ) /2];
this while this

(
>m C o m p a r a t i o n s++; ( a u x 1 . Key > Array [
i ] . Key ) {
>m C o m p a r a t i o n s++;
i ) ++;
>m C o m p a r a t i o n s++; ( a u x 1 . Key < Array [
this while this

(
] . Key ) {
>m C o m p a r a t i o n s++;
j ) ;
(
if
<= =
j ){
i ];
aux2
Array [
Array [
this this this

( ( (
Array [
>mMoviments++; i ] = Array [
];
>mMoviments++; j ] = aux2 ;
>mMoviments++;
i ) ++; j ) ; i
<=
} }
while
}
j) ;
O Programa 2.11 apresenta o mtodo MethodQuick que o QuickSort propriamente dito.
void long if if
}
Programa 2.10: Mtodo MethodQuick.
S o r t M e t h o d s : : MethodQuick ( i , j ; Right , &i ,
long
Left ,
long
Right ,
TItem
Array ) {
P a r t i t i o n ( Left , ( Left < j )
&j ,
Array ) ;
MethodQuick ( L e f t , ( i < Right )
j ,
Array ) ;
MethodQuick ( i ,
Right ,
Array ) ;
O algoritmo procede da seguinte forma [2]: 1. Zera os valores das vriveis de medio atravs do mtodo ClearAll(); 2. Inicia a contagem de tempo com a funo start(); 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 movimentao incrementa a varivel mMoviments; 7. Pausa a contagem de tempo e calcula o tempo gasto armazenando o valor na varivel mTime; O QuickSort no foi implementado diretamente, por ser um mtodo recursivo, as variveis contadoras de movimentos, comparaes e tempo seriam reiniciadas a toda chamada recursiva da funo. Portanto o mtodo QuickSort foi implementado da maneira como o Programa 2.11 apresenta.
void this this this

CTimer Timer Timer }
Programa 2.11: Mtodo QuickSort.

Timer =
S o r t M e t h o d s : : Q u i c k S o r t ( TItem CTimer ( ) ;
new
Array ,
long
n){
>C l e a r A l l ( ) ; >s t a r t ( ) ;
>MethodQuick ( 0 , n >s t o p ( ) ; Timer
1 , A r r a y ) ;
;
>mTime =
2.6.2
Assim como ShellSort a anlise da complexidade deste algoritmo dicil devido a calculos matemticos complexos. O pior caso deste algoritmo quando o arquivo j est ordenado e a escolha do piv inadequada. Nesse caso as parties sero extremamente desiguais, e o mtodo MethodQuick ser chamado n vezes, eliminando apenas um item em cada chamada. Essa situao desastrosa, pois o nmero de 2 comparaes passa a cerca de n2 , e o tamanho da pilha necessria para as chamadas recursivas cerca de n. Entretanto o pior caso pode ser evitado empregando-se modicaes 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 demonstra 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, signicando assim que a sua ordem de complexidade O(n log n).
C(n) = 1, 386n log n 0, 84n
(2.9)
O QuickSort considerado o mtodo mais eciente e altamente recomendvel para arquivos grandes. Quanto mais o vetor estiver desordenado, maior ser sua vantagem em relao aos outros mtodos. A escolha correta do piv essencial para a garantia de ecincia do algoritmo. A Tabela 2.5 apresenta as principais vantagens e desvantagens deste mtodo.
Vantagens - Extremamente Eciente - Necessita apenas de um pequena pilha como memria extra - Complexidade n log n Desvantagens - Tem um pior caso de O(n2 ) - Implementao difcil
- No estvel
Tabela 2.5: Vantagens e desvantagens do Mtodo QuickSort.
24
2.7
HeapSort
Utilizando o mesmo princpio do SelectSort , o HeapSort um algoritmo que utiliza uma estrutura de dados conhecida como Heap binrio para manter o prximo item a ser selecionado [14]. Criado em 1964 por Robert W. Floyd e J.W.J. Williams, ele um algoritmo de Ordem de Complexidade O(n log n). Existem dois tipos de heaps: Os heaps de mximo (max heap), em que o valor de todos os ns so menores que os de seus respectivos pais; e os heaps de mnimo (min heap), em que o valor de todos os ns so maiores que os de seus respectivos pais. Assim, em um heap de mximo, o maior valor do conjunto est na raz da rvore, enquanto no heap de mnimo a raz armazena o menor valor existente [3]. Os heaps podem ser representados por arranjos, nesse caso a maior(menor) chave est sempre na posio 1 do vetor. A Figura 2.9 ilustra este tipo.
Figura 2.9: Ilustrao de um Heap mximo. Os algoritmos para implementar as operaes sobre o heap operam ao longo de um dos caminhos da rvore, a partir da raiz at o nvel mais profundo da rvore. Para o HeapSort so necesria apenas duas operaes com o heap : Remake, que refaz a estrutura e Build que a constroi. Eles so apresentados no Programa 2.12.
25
void long long

j = aux
Programa 2.12: Operaes com Heap necessrias ao HeapSort.
S o r t M e t h o d s : : ReMake ( i j ; aux ; = Left ;
long
Left ,
long
Right ,
TItem
Array ) {
TItem i =
( j
2;
while if this if
( j < }
Array [ i ] ; <= Right ) {
Right ) {
>m C o m p a r a t i o n s++; A r r a y [ j + 1 ] . Key )
( A r r a y [ j ] . Key <
j ++;
this if break
i j = = j ; i
>m C o m p a r a t i o n s++; A r r a y [ j ] . Key )
( aux . Key >= ; =
Array [ i ]
Array [ j ] ;
this
} }
>mMoviments++;
this void long while

Left { }
Array [ i ]
aux ;
>mMoviments++;
S o r t M e t h o d s : : B u i l d ( TItem Left ; / 2 + 1; 1)
Array ,
long
n){
= n
( Left
>
Left
;
n, Array ) ;
ReMake ( L e f t ,
O mtodo de Ordenao HeapSort iniciado com um heap obtido atravs do mtodo Build.
void long
Programa 2.13: Mtodo HeapSort.

Array ,
S o r t M e t h o d s : : H e a p S o r t ( TItem Left , aux ; Right ;
long
n){
TItem CTimer
Timer
this this
Left Right aux
Timer
new
CTimer ( ) ;
>C l e a r A l l ( ) ; >s t a r t ( ) ; n) ;
>B u i l d ( A r r a y , = 0;
while
= n
1;
> 0) {
( Right =
Array [ 0 ] ; = Array [ Right ] ; = aux ;
Array [ 0 ]
Timer
this this this

Right
Array [ Right ]
>mMoviments++; ; Right , Array ) ; }
>ReMake ( L e f t ,
>s t o p ( ) ; Timer
>mTime =
>g e t E l a p s e d T i m e ( ) ; }
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.
Figura 2.10: Ilustrao do funcionamento do algoritmo HeapSort.
2.7.1
Implementao
Como foi apresentado o mtodo HeapSort baseia-se em uma estrutura de dados. A implementao dos algoritmos das operaes necessrias ao heap e o mtodo propriamente dito, foram apresentadas pelos Programas 2.12 e 2.13 O algoritmo procede da seguinte forma [8]: 1. Zera os valores das vriveis de medio atravs do mtodo ClearAll(); 2. Inicia a contagem de tempo com a funo start(); 3. Constroi o heap atravs do mtodo Build; 4. Troca o item na posio 1 do vetor (raiz do heap) com o item da posio n. 5. Usa o procedimento ReMake para reconstituir o heap para os itens Array[1], Array[2], at Array[n 1]. 6. Repita os passos 4 e 5 com os n 1 itens restantes, depois com os n 2, at que reste apenas um item. 27
7. A cada comparao incrementa a varivel mComparations e a cada movimentao incrementa a varivel mMoviments; 8. Pausa a contagem de tempo e calcula o tempo gasto armazenando o valor na varivel mTime;
A anlise de complexidade deste algoritmo tambm complexa como os dois mtodos apresentados anteriormente. Porm, ser apresentado resultados de testes empricos [8].
O procedimento ReMake gasta cerca de log n operaes, no pior caso; O mtodo Build executa O(n) log n(ReMake); O lao interno do Programa 2.13 executa O(n) log n(ReMake); Logo, o Heapsort gasta um tempo de execuo proporcional a n log n, no pior
caso.
2.7.3
Anlise do algoritmo
primeira vista, o algoritmo no parece eciente, pois as chaves so movimentadas vrias vezes. Entretanto, ele gasta um tempo de execuo proporcional a n log n no pior caso [19]. Ele no recomendado para vetores com poucos elementos por causa do tempo gasto na construo do heap , sendo recomendado para aplicaes que no podem tolerar eventualmente um caso desfavorvel [8]. A Tabela 2.6 apresenta as principais vantagens e desvantagens deste mtodo.
Vantagens - Tempo n log n Desvantagens - O anel interno do algoritmo bastante complexo se comparado ao Quicksort . - No estvel
Tabela 2.6: Vantagens e desvantagens do Mtodo HeapSort.
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].
Figura 2.11: Ilustrao do funcionamento do algoritmo MergeSort. Os trs passos teis dos algoritmos dividir para conquistar, ou divide quer, que se aplicam ao MergeSort so: 1. Dividir: Dividir os dados em subsequncias pequenas; 2. Conquistar: Classicar as duas metades recursivamente aplicando o merge sort; 3. Combinar: Juntar as duas metades em um nico conjunto j classicado. 29
and con-
2.8.1
Implementao
Primeiramente ser apresentado pelo Programa 2.14 a implementao do mtodo Merge responsvel pela intercao do intervalo do vetor passado ele.
void
) i j
Programa 2.14: Mtodo Merge responsvel pela intercalao.

S o r t M e t h o d s : : Merge ( TItem {
Array ,
long
Left ,
TItem
long
=
ArrayAux
i , j ,k;
( TItem
) malloc
( ( Right
L e f t )
long sizeof
Means ,
long
Right
( TItem ) ) ;
Left ;
= Means ; 0;
k =
while this this if else while this while this for this
( i free
( i
<
Means & &
<
Right )
>mMoviments++; >m C o m p a r a t i o n s++; A r r a y [ j ] . Key )
( A r r a y [ i ] . Key <=
ArrayAux [ k++] =
Array [ i ++];
ArrayAux [ k++] = }
Array [ j ++];
( i
<
Means ) { Array [ i ++];
ArrayAux [ k++] =
>mMoviments++;
( j
<
Right ) { Array [ j ++];
ArrayAux [ k++] =
>mMoviments++;
Left ; =
<
Right ;
+ +i ) { ];
Array [ i ]
ArrayAux [ i
L e f t
>mMoviments++;
} ( ArrayAux ) ;
O algoritmo procede da seguinte forma: 1. criado um vetor auxiliar do tamanho do intervalo; 2. Copia os valores do intervalo para o vetor auxiliar, de forma ordenada; 3. Copia o vetor auxiliar para o intervalo corresondente ao vetor a ser ordenado. Para este trabalho o MergeSort foi implementado de uma forma no-recursiva. Esta implementao, Programa 2.15, favorece o desempenho do algoritmo, pois no necessrio o uso de uma pilha.
30
void this long long while while if this

CTimer Timer Left = Right Left } Means = } Timer
Programa 2.15: Mtodo MergeSort.

=
S o r t M e t h o d s : : M e r g e S o r t ( TItem Timer CTimer ( ) ;
new
Array ,
long
n){
>C l e a r A l l ( ) ; >s t a r t ( ) ; Right ;
Left ,
Means = 1 ; ( Means < 0; + Means < + n) 2 n){ n){
( Left =
Left >
Means ;
( Right
Right
= n; Left , L e f t+Means , Right ) ;
>Merge ( A r r a y , = Left + 2
Means ;
Means ;
; Timer
this
>s t o p ( )
>mTime =
2.8.2
O calculo da anlise de complexidade no ser apresentada, mas de acordo com [9] a ordem de complexidade do algoritmo recursivo deste mtodo O(n log n) .
A Tabela 2.7 apresenta as principais vantagens e desvantagens deste mtodo.

Vantagens Desvantagens - Passvel de ser transformado em es- - Utiliza memria auxiliar tvel - Fcil Implementao - Mais lento que o HeapSort - Complexidade O(n log n)
Tabela 2.7: Vantagens e desvantagens do Mtodo MergeSort.
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
3.1 Metodologia dos Testes
Os testes foram realizados em um Computador com as seguintes conguraes:

Processador Pentium D 2.8 Ghz FSB 800 Mhz; 1 GB de memria ram DDR 533 Mhz; Placa Me Asus P5ND2; Sistema Operacional Microsoft Windows XP Service Pack 3.
Os algoritmos de ordenao foram escritos na linguagem C/C++. O software utilizado para edio e compilao do cdigo foi o Microsoft Visual Studio Express 2008. Os grcos foram gerados utilizando os softwares Microsoft Oce Excel 2007 Service Pack 1 e R Project 2.8.0. Para a praticidade durante os testes foram implementados mtodos auxiliares que esto na classe Operations.h. Os detalhes da implementao desta classe apresentada no Apndice B. Para realizao dos testes em lotes foram utilizados arquivos textos de entrada e sada. Os arquivo de entrada, veja exemplo no Arquivo 3.1, contm as informaes para os testes: Mtodo a ser realizado, tamanho do vetor, tipo de vetor e a necessidade de exibio na tela ou no. Arquivo 3.1: Exemplo de um arquivo de entrada para teste.
Merge Bubble Quick Insert Insert 100 OrdC 0 1 10000 100 532 1000 OrdA 1 0 0 OrdP OrdD OrdA
Os arquivos de sada contendo os resultados esto no Apndice C 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 Tambm seram utilizados as seguintes abreviaes para os tipos de vetores:
OrdC: Vetor ordenado em ordem crescente; OrdD: Vetor ordenado em ordem decrescente; OrdP: Vetor parcialmente ordenado(10% aleatrio); OrdA: Vetor aleatrio;
33
3.2.1
Vetor ordenado em ordem crescente
A Tabela 3.1 apresenta a quantidade de comparaes e movimentos para o vetor do tipo OrdC, enquanto a Tabela 3.2 apresenta os resultados em funo do tempo.
Vetor Ordenado em Ordem Crescente 100 1000 10000 100000 Comp. Mov. Comp. Mov. Comp. Mov. Comp. Mov. 4950 4950 499500 499500 49995000 49995000 4999950000 4999950000 99 198 99 1998 9999 19998 99999 199998 4950 297 499500 2997 49995000 29997 4999950000 299997 342 684 5457 10914 75243 150486 967146 1934292 606 189 909 1533 125439 17712 1600016 196605 1265 884 19562 12192 264433 156928 3312482 1900842 372 1376 5052 19968 71712 272640 877968 3385984
1 2 3 4 5 6 7
Tabela 3.1: Quantidade de comparaes e movimentos dos testes no vetor OrdC.
Vetor Ordenado em 100 1000 1 0,000050 0,004822 2 0,000003 0,00002 3 0,000050 0,004834 4 0,000008 0,000108 5 0,000020 0,000191 6 0,000033 0,000412 7 0,000150 0,001487
Ordem Crescente 10000 100000 0,483164 48,373736 0,000193 0,001936 0,561589 58,300695 0,001453 0,018899 0,002403 0,028667 0,008299 0,083919 0,015855 0,205009
Tabela 3.2: Tempo gasto pelos testes no vetor OrdC. 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
36
3.2.2
Vetor ordenado em ordem decrescente
A Tabela 3.3 apresenta a quantidade de comparaes e movimentos para o vetor do tipo OrdD, enquanto a Tabela 3.4 apresenta os resultados em funo do tempo.
Vetor Ordenado 100 1000 Comp. Mov. Comp. Mov. 4950 4950 499500 499500 99 5148 999 501498 4950 297 499500 2997 572 914 9377 14834 610 336 9016 303 1125 747 17952 10811 316 1376 4932 19968 em Ordem Decrescente 10000 100000 Comp. Mov. Comp. Mov. 4999500 4999500 4999950000 4999950000 9999 50014998 9999 500014999 49995000 29997 4999950000 299997 128947 204190 1586800 2553946 125452 32712 1600030 346602 246705 141975 3131748 1747201 64608 272640 815024 3385984
1 2 3 4 5 6 7
Tabela 3.3: Quantidade de comparaes e movimentos dos testes no vetor OrdD.
Vetor Ordenado em Ordem Decrescente 100 1000 10000 100000 1 0,000077 0,007503 0,752961 79,834753 2 0,000056 0,004897 0,667281 64,038128 3 0,000050 0,004834 0,561589 58,300695 4 0,000011 0,000164 0,002120 0,037005 5 0,000022 0,000190 0,002531 0,029430 6 0,000032 0,000381 0,007504 0,084207 7 0,000141 0,001495 0,016313 0,219894
Tabela 3.4: Tempo gasto pelos testes no vetor OrdD. 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
39
3.2.3
Vetor parcialmente ordenado
A Tabela 3.5 apresenta a quantidade de comparaes e movimentos para o vetor do tipo OrdP, enquanto a Tabela 3.6 apresenta os resultados em funo do tempo.
Vetor Parcialmente Ordenado 100 1000 10000 100000 Comp. Mov. Comp. Mov. Comp. Mov. Comp. Mov. 4950 328 499500 35450 49995000 3154687 4999950000 359774720 99 528 99 34527 99 3410635 99 36093238 4950 297 499500 2997 49995000 29997 4999950000 299997 509 851 10857 16314 172528 247771 2214898 3182044 727 324 10725 3522 157689 66225 2251124 903300 1254 868 19525 12190 264737 156489 3294503 1887739 505 1376 7869 19968 114410 272640 1106062 3385984
1 2 3 4 5 6 7
Tabela 3.5: Quantidade de comparaes e movimentos dos testes no vetor OrdP.
1 2 3 4 5 6 7
Vetor 100 0,000052 0,000007 0,000050 0,000012 0,000029 0,000035 0,000143
Parcialmente Ordenado 1000 10000 100000 0,005348 0,526686 58,175386 0,000379 0,046328 4,601265 0,004834 0,561589 58,300695 0,000236 0,003399 0,055055 0,000309 0,003792 0,045093 0,000405 0,004734 0,088935 0,001518 0,023147 0,221169
Tabela 3.6: Tempo gasto pelos testes no vetor OrdP. A seguir as guras 3.9, 3.10, 3.11 e 3.12 apresentam os grcos em funo do nmero de comparaes e movimentos para os quatro tamanhos de vetores testados.
40
Figura 3.9: Nmero de comparaes e movimentaes do teste aplicado em um vetor de 100 posies do tipo OrdP.
41
42
3.2.4
Vetor aleatrio
A Tabela 3.7 apresenta a quantidade de comparaes e movimentos para o vetor do tipo OrdA, enquanto a Tabela ?? apresenta os resultados em funo do tempo.
Vetor Aleatrio 100 1000 10000 100000 Comp. Mov. Comp. Mov. Comp. Mov. Comp. Mov. 4950 2628 499500 242827 49995000 25160491 4999950000 2499136980 99 2387 999 253364 9999 25012754 99999 2500402956 4950 297 499500 2997 49995000 29997 4999950000 299997 818 1160 14364 19821 236735 311978 3711435 4670697 997 570 12852 8136 181203 103575 2114943 1310586 1205 817 18837 11556 255288 149150 3220006 1825075 558 1376 8744 19968 123685 272640 1566749 3385984
1 2 3 4 5 6 7
Tabela 3.7: Quantidade de comparaes e movimentos dos testes no vetor OrdA.
1 2 3 4 5 6 7
100 0,000076 0,000027 0,000050 0,000016 0,000031 0,000034 0,00015
Vetor Aleatrio 1000 10000 100000 0,008084 0,858684 114,840058 0,002531 0,323982 31,500937 0,004834 0,561589 58,300695 0,000290 0,006158 0,104286 0,000403 0,004987 0,084427 0,000420 0,009227 0,087964 0,001598 0,019384 0,231564
Tabela 3.8: Tempo gasto pelos testes no vetor OrdA. A seguir as guras 3.13, 3.14, 3.15 e 3.16 apresentam os grcos em funo do nmero de comparaes e movimentos para os quatro tamanhos de vetores testados.
43
Figura 3.13: Nmero de comparaes e movimentaes do teste aplicado em um vetor de 100 posies do tipo OrdA.
44
45
3.3
3.3.1
Anlise dos Resultados

Vetor ordenado em ordem crescente
Os dois grcos (Figuras 3.17 e 3.18) a seguir demonstram o comportamento dos mtodos em relao ao tempo gasto na ordenao de um vetor do tipo OrdC nos quatro tamanhos propostos.
Figura 3.17: Curva de desempenho dos 7 mtodos.
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. O algoritmo ShellSort apresenta a mesma velocidade dos algoritmos QuickSort , HeapSort e MergeSort , que so O(n log n).
47
3.3.2
Vetor ordenado em ordem decrescente
Os dois grcos (Figuras 3.19 e 3.20) a seguir demonstram o comportamento dos mtodos em relao ao tempo gasto na ordenao de um vetor do tipo OrdD nos quatro tamanhos propostos.
Para arquivos ordenados inversamente de at 10000 elementos o ShellSort
demonstrou se a melhor escolha, acima deste nmero a escolha perfeita o QuickSort . 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
Os dois grcos (guras 3.21 e 3.22) a seguir demonstram o comportamento dos mtodos em relao ao tempo gasto na ordenao de um vetor do tipo OrdP nos quatro tamanhos propostos.
O ShellSort e QuickSort so os melhores para este tipo de vetor em qualquer
tamanho, porm para arquivos pequenos existe uma vantagem do InsertSort . do tamanho.
BubbleSort e SelectSort so os piores para este tipo de vetor, independente
50
execuo.
At 1000 elementos o InsertSort apresentou compotamento n log n, acima
disto ele apresentou-se como quadrtico.
51
3.3.4
Vetor aleatrio
Os dois grcos (guras 3.23 e 3.24) a seguir demonstram o comportamento dos mtodos em relao ao tempo gasto na ordenao de um vetor do tipo OrdA nos quatro tamanhos propostos.
Para pequenos arquivos o ShellSort foi o melhor, para os maiores o QuickSort
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
execuo.
53
Captulo 4 Concluso
Foram apresentados sete mtodos de ordenao interna mediante a comparao 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. 2.
BubbleSort :
Apresentou-se como o pior mtodo de ordenao;

InsertSort :
Para arquivos pequenos o mais interessante, sendo mais vantajoso, neste caso, do que algoritmos n log n; Em arranjos j ordenados apresentou um comportamento linear, sendo
til para ordenao de um arquivo com poucos elementos fora da ordem. Com vetores aleatrios o melhor entre os de complexidade quadrtica. 3.
SelectSort :
Apresenta uma vantagem apenas no nmero de movimentaes, porm
seu tempo de execuo pior que o InsertSort ; A quantidade de movimentos e comparaes a mesma, independente do tipo de vetor a ser ordenado, variando apenas em funo do tamanho. A sua utilizao deve ser feita quando os registros dos arquivos forem grandes, em virtude da quantidade de movimentos que realizada para a operao. 4.
ShellSort :
Apresentou-se eciente em todos os testes; Em geral um mtodo que se adequa a todas as situaes; A sua relao com o QuickSort cresce medida que o nmero de ele-
mentos aumenta; Em todas as situae manteve-se prximo do algoritmo mais rpido do teste; 54
No arquivo parcialmente ordenado ele foi o melhor.
5.
QuickSort :
Obteve o melhor resultado na maioria dos testes; Teve um maior desempenho nos arquivos aleatrios; Obteve uma vantagem constante em relao ao HeapSort ; Sua ecincia foi identicada apenas nos grandes arquivos;
6.
HeapSort :
Seu desempenho no foi melhor em nenhum teste; O seu comportamento foi o mesmo para todos os tipos de vetores; Em arquivos aleatrios de grande tamanho o seu desempenho foi similar
ao ShellSort .
7.
MergeSort :
Apresentou os piores resultados entre os algoritmos de ordenao e-
cientes; Em todos testes com 100 elementos apresentou um tempo de execuo maior que os algoritmos O(n2 ); Pelos testes realizados, conclui-se que a escolha de um algoritmo de ordenao depende do tipo de vetor e tamanho a ser ordenado. Uma alternativa para obter um desempenho melhor a combinao de mtodos. Por exemplo, suponha um algoritmo de ordenao composto pelo mtodo QuickSort e InsertSort. O algoritmo verica o tamanho do vetor a ser ordenado e em seguida aplica o QuickSort se o arquivo for grande e aleatrio ou aplica o InsertSort se o arquivo for pequeno e parcialmente ordenado. Conclui-se tambm que mtodos ecientes, demandam uma implementao mais cautelosa do cdigo, pois so detalhes que denem a qualidade da operao de ordenao
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.
" s t d a f x . h" "CTimer . h"
#include #include
CTimer : : CTimer ( ) { t S t a r t . QuadPart t S t o p . QuadPart } = 0; 0;
double
}
L I T o S e c s (LARGE_INTEGER frequency ;
L) {
LARGE_INTEGER
return double
((
QueryPerformanceFrequency (
&f r e q u e n c y /(
) L >QuadPart
double
; ;
) f r e q u e n c y . QuadPart )
void
}
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 (&
this this
>t S t a r t ) ;
void
}
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 ( ) { time ; =
LARGE_INTEGER
return
t i m e . QuadPart
this
>t S t o p . QuadPart
this
>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:
GeneratingArray: Gera vetores no tamanho e tipo passados como argumento.
Os vetores podem ser do tipo:

OrdC(Type 0): OrdD(Type 1): OrdA(Type 2): OrdP(Type 3):
Ordenado em ordem crescente; Ordenado em ordem decrescente; Ordem aleatria; 10% desordenado;
PrintArray: Exibe o contedo de um vetor: ProcessCommand: Processa uma string e identica os argumentos, retornando um TDA Command com os seguintes campos:

Method: Mtodo de ordenao; mItens: Quantidade de elentos no vetor a ser criado; TypeArray: Tipo de vetor a ser criado; Print: Vericao de exibio ou no do vetor a ser testado;
ProcessFile: Processa as strings de comando de uma arquivo texto e guarda
os resultados dos testes realizados em um arquivo de sada: A seguir o programa B.1 apresenta o cdigo dos mtodos auxiliares.
#include " s t d a f x . h" #include " SortMethods . h" #include #include #include " O p e r a t i o n s . h" #include using namespace long int
< s t d l i b . h> <t i m e . h> <i o s t r e a m > std ; TItem GeneratingArray ( Array = TItem ( TItem srand ( ( ) t i m e (NULL) ) ;
Programa B.1: Implementao dos mtodos da classe Operations.
mItens ,
) malloc (
int sizeof
Type ) {
( TItem )
mItens ) ;
57
switch case for break case int for break case for break case for if
} } }
( Type ) { 0:{ (
long long long
i =0;
i <m I t e n s ; i ;
i ++)
A r r a y [ i ] . Key = ;
1:{ p =0; (
i =m I t e n s
1;
i ;
i >=0;
A r r a y [ p + + ] . Key = ;
2:{ (
i =0;
i <m I t e n s ; (
A r r a y [ i ] . Key = ;
long
i ++) % mItens ;
) rand ( )
long do while else

3:{ (
i =0;
i <m I t e n s ;
i ++){
( i %10==0)
A r r a y [ i ] . Key =
long
) rand ( ) i ) ;
mItens ;
( A r r a y [ i ] . Key = =
A r r a y [ i ] . Key = } } }
i ;
return
cout ( < <
Array ;
void long "==================================" for long

P r i n t A r r a y ( TItem Array , mItens ) { i =0; i <m I t e n s ; i ++){ cout . width ( 6 ) ; cout cout } cout } < < < < < < A r r a y [ i ] . Key ;
" |";
< < endl ;
"=================================="
TCommand
ProcessCommand (
char
StrCommand ) {
CommandTemp . Method , &
TCommand CommandTemp ; s s c a n f ( StrCommand ,
"%s %d %s %d" ,
CommandTemp . m I t e n s ,
CommandTemp . TypeArray ,
& CommandTemp .
return
}
Print ) ; CommandTemp ;
void if
ProcessFile (
FILE
pFile ; pFile2 ;
char
FileIn
char
FileOut ) {
f o p e n _ s (& p F i l e , FILE
FileIn ,
"r") ; "w" ) ;
f o p e n _ s (& p F i l e 2 ,
FileOut ,
TCommand Command ; buffer [200];
return char
( p F i l e= NULL) = ;
sprintf ( buffer ,
"%12s %12s %12s %14s %14s %12s \n\n" , "Method" , "Quant" , "Type" , "mComp. " , "mMovim . " , "mTime" ) ;
58
int int while
fputs ( buffer , type ; i =1;
pFile2 ) ;
SortMethods
Sort
new
SortMethods ( ) ;
( fgets ( buffer ,200 , pFile ) ){
Command = ProcessCommand ( b u f f e r ) ;
if else if else if else if

type type type type TItem
( s t r c m p ( Command . TypeArray , = 0;
"OrdC" )
= =
0)
( s t r c m p ( Command . TypeArray , = 1; ( s t r c m p ( Command . TypeArray , = 2; ( s t r c m p ( Command . TypeArray , = 3;
"OrdD" ) "OrdA" ) "OrdP" )
= =
0)
= =
0)
= =
0)
Array
G e n e r a t i n g A r r a y ( Command . m I t e n s ,
type ) ;
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 ) ;
if else else else else else else if
" B u b b l e " ) == 0 ) >B u b b l e S o r t ( A r r a y , Command . m I t e n s ) ; ( s t r c m p ( Command . Method , " I n s e r t " ) = = 0) 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 t r c m p ( Command . Method , " S e l e c t " )= = 0) 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 t r c m p ( Command . Method , " S h e l l " ) = = 0) 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 t r c m p ( Command . Method , " Quick " ) = = 0) Sort >Q u i c k S o r t ( A r r a y , Command . m I t e n s ) ; ( s t r c m p ( Command . Method , "Heap" ) = = 0) Sort >H e a p S o r t ( A r r a y , Command . m I t e n s ) ; ( s t r c m p ( Command . Method , "Merge" ) = = 0) Sort >M e r g e S o r t ( A r r a y , Command . m I t e n s ) ;
( s t r c m p ( Command . Method , Sort
if if if if if 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 , . Method ,
"%12s %12d %12s %14.0 f %14.0 f %12 f \n" , Command Command . TypeArray , Sort > getComparations ( ) , Sort >g e t M o v i m e n t s ( ) , S o r t >g e t T i m e ( ) ) ;
Command . m I t e n s ,
fputs ( buffer , pFile2 ) ;
cout
< <
"teste "
< <
i+ + < <
endl ;
} 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.
BubbleSort para 4 tipos de vetor e 4 tamanhos diferentes; InsertSort para 4 tipos de vetor e 4 tamanhos diferentes; SelectSort para 4 tipos de vetor e 4 tamanhos diferentes; ShellSort para 4 tipos de vetor e 4 tamanhos diferentes; QuickSort para 4 tipos de vetor e 4 tamanhos diferentes; HeapSort para 4 tipos de vetor e 4 tamanhos diferentes; MergeSort para 4 tipos de vetor e 4 tamanhos diferentes;
60
Arquivo C.1: Resultados do testes utilizando BubbleSort.

Method Quant Type mComp . mMovim . mTime Bubble Bubble Bubble Bubble Bubble Bubble Bubble Bubble Bubble Bubble Bubble Bubble Bubble Bubble Bubble Bubble Bubble Bubble Bubble Bubble Bubble Bubble Bubble Bubble Bubble Bubble Bubble Bubble Bubble Bubble Bubble Bubble Bubble Bubble Bubble Bubble Bubble Bubble Bubble Bubble Bubble Bubble Bubble Bubble Bubble Bubble Bubble Bubble Bubble Bubble Bubble Bubble 100 100 100 100 100 100 100 100 100 100 100 100 100 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 10000 10000 10000 10000 10000 10000 10000 10000 10000 10000 10000 10000 10000 100000 100000 100000 100000 100000 100000 100000 100000 100000 100000 100000 100000 100000 OrdC OrdD OrdP OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdC OrdD OrdP OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdC OrdD OrdP OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdC OrdD OrdP OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA 4950 4950 4950 4950 4950 4950 4950 4950 4950 4950 4950 4950 4950 499500 499500 499500 499500 499500 499500 499500 499500 499500 499500 499500 499500 499500 49995000 49995000 49995000 49995000 49995000 49995000 49995000 49995000 49995000 49995000 49995000 49995000 49995000 4999950000 4999950000 4999950000 4999950000 4999950000 4999950000 4999950000 4999950000 4999950000 4999950000 4999950000 4999950000 4999950000 0 4950 328 2628 2628 2628 2628 2628 2628 2628 2628 2628 2628 0 499500 35450 242827 242827 242827 242827 242827 242827 242827 242827 242827 242827 0 49995000 3154687 24768116 24768116 25320916 25087802 25011848 25160491 24831680 25022032 25022032 25333035 0 4999950000 359774720 2503337665 2499304061 2491137250 2498844837 2505224085 2496906642 2504213408 2498470030 2488891637 2499136980 0.000050 0.000077 0.000052 0.000074 0.000076 0.000076 0.000075 0.000076 0.000076 0.000076 0.000076 0.000075 0.000076 0.004822 0.007503 0.005348 0.008302 0.008245 0.008085 0.008087 0.008113 0.008084 0.008138 0.008082 0.008081 0.008237 0.483164 0.752961 0.526686 0.853146 0.851169 0.859995 0.856508 0.863044 0.858684 0.858342 0.854665 0.855867 0.857315 48.373736 79.834753 58.175386 107.334751 107.940812 110.872767 111.346239 110.317295 109.635236 108.712391 121.313059 120.359626 117.840058
61
Arquivo C.2: Resultados do testes utilizando InsertSort.

Method Quant Type mComp . mMovim . mTime Insert Insert Insert Insert Insert Insert Insert Insert Insert Insert Insert Insert Insert Insert Insert Insert Insert Insert Insert Insert Insert Insert Insert Insert Insert Insert Insert Insert Insert Insert Insert Insert Insert Insert Insert Insert Insert Insert Insert Insert Insert Insert Insert Insert Insert Insert Insert Insert Insert Insert Insert Insert 100 100 100 100 100 100 100 100 100 100 100 100 100 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 10000 10000 10000 10000 10000 10000 10000 10000 10000 10000 10000 10000 10000 100000 100000 100000 100000 100000 100000 100000 100000 100000 100000 100000 100000 100000 OrdC OrdD OrdP OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdC OrdD OrdP OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdC OrdD OrdP OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdC OrdD OrdP OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA 99 99 99 99 99 99 99 99 99 99 99 99 99 999 999 999 999 999 999 999 999 999 999 999 999 999 9999 9999 9999 9999 9999 9999 9999 9999 9999 9999 9999 9999 9999 99999 99999 99999 99999 99999 99999 99999 99999 99999 99999 99999 99999 99999 198 5148 528 2387 2387 2387 2387 2387 2387 2387 2387 2387 2387 1998 501498 34527 253364 253364 253364 253364 253364 253364 253364 253364 253364 253364 19998 50014998 3410635 24919368 25048430 25048430 25048430 25048430 24977078 24977078 24977078 25002784 25002784 199998 5000149998 360932382 2500686937 2502664733 2500905360 2500402956 2503185261 2496615174 2488758797 2494440950 2497932586 2502987729 0.000003 0.000056 0.000007 0.000027 0.000027 0.000027 0.000027 0.000027 0.000027 0.000027 0.000027 0.000027 0.000027 0.000020 0.004897 0.000379 0.002623 0.002568 0.002535 0.002533 0.002540 0.002532 0.002531 0.002531 0.002579 0.002554 0.000193 0.667281 0.046328 0.362001 0.325466 0.313694 0.332196 0.336111 0.323982 0.341779 0.320963 0.345760 0.325827 0.001936 64.038128 4.601265 31.768194 32.525120 31.451376 31.500937 31.822204 31.373653 31.469461 31.235527 31.412962 31.172520
62
Arquivo C.3: Resultados do testes utilizando SelectSort.

Method Quant Type mComp . mMovim . mTime Select Select Select Select Select Select Select Select Select Select Select Select Select Select Select Select Select Select Select Select Select Select Select Select Select Select Select Select Select Select Select Select Select Select Select Select Select Select Select Select Select Select Select Select Select Select Select Select Select Select Select Select 100 100 100 100 100 100 100 100 100 100 100 100 100 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 10000 10000 10000 10000 10000 10000 10000 10000 10000 10000 10000 10000 10000 100000 100000 100000 100000 100000 100000 100000 100000 100000 100000 100000 100000 100000 OrdC OrdD OrdP OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdC OrdD OrdP OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdC OrdD OrdP OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdC OrdD OrdP OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA 4950 4950 4950 4950 4950 4950 4950 4950 4950 4950 4950 4950 4950 499500 499500 499500 499500 499500 499500 499500 499500 499500 499500 499500 499500 499500 49995000 49995000 49995000 49995000 49995000 49995000 49995000 49995000 49995000 49995000 49995000 49995000 49995000 4999950000 4999950000 4999950000 4999950000 4999950000 4999950000 4999950000 4999950000 4999950000 4999950000 4999950000 4999950000 4999950000 297 297 297 297 297 297 297 297 297 297 297 297 297 2997 2997 2997 2997 2997 2997 2997 2997 2997 2997 2997 2997 2997 29997 29997 29997 29997 29997 29997 29997 29997 29997 29997 29997 29997 29997 299997 299997 299997 299997 299997 299997 299997 299997 299997 299997 299997 299997 299997 0.000050 0.000052 0.000051 0.000054 0.000055 0.000054 0.000055 0.000054 0.000054 0.000054 0.000054 0.000054 0.000054 0.004834 0.004845 0.006082 0.005201 0.005203 0.006150 0.005179 0.004896 0.004917 0.004914 0.004916 0.004897 0.004918 0.561589 0.588332 0.569411 0.554237 0.597913 0.556050 0.568910 0.609064 0.569972 0.589663 0.579552 0.576273 0.603351 58.300695 59.014263 58.884310 58.460898 58.640138 61.302155 60.813733 60.557073 60.472528 61.323460 61.482899 61.434110 61.445988
63
Arquivo C.4: Resultados do testes utilizando ShellSort.

Method Quant Type mComp . mMovim . mTime Shell Shell Shell Shell Shell Shell Shell Shell Shell Shell Shell Shell Shell Shell Shell Shell Shell Shell Shell Shell Shell Shell Shell Shell Shell Shell Shell Shell Shell Shell Shell Shell Shell Shell Shell Shell Shell Shell Shell Shell Shell Shell Shell Shell Shell Shell Shell Shell Shell Shell Shell Shell 100 100 100 100 100 100 100 100 100 100 100 100 100 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 10000 10000 10000 10000 10000 10000 10000 10000 10000 10000 10000 10000 10000 100000 100000 100000 100000 100000 100000 100000 100000 100000 100000 100000 100000 100000 OrdC OrdD OrdP OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdC OrdD OrdP OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdC OrdD OrdP OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdC OrdD OrdP OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA 342 572 509 818 818 818 818 818 818 818 818 818 818 5457 9377 10857 14364 14364 14364 14364 14364 14364 14364 14364 14364 14364 75243 128947 172528 236735 236735 236735 236735 236735 236735 236735 236735 236735 236735 967146 1586800 2214898 3702551 3702551 3702551 3702551 3720319 3720319 3720319 3720319 3720319 3720319 684 914 851 1160 1160 1160 1160 1160 1160 1160 1160 1160 1160 10914 14834 16314 19821 19821 19821 19821 19821 19821 19821 19821 19821 19821 150486 204190 247771 311978 311978 311978 311978 311978 311978 311978 311978 311978 311978 1934292 2553946 3182044 4669697 4669697 4669697 4669697 4687465 4687465 4687465 4687465 4687465 4687465 0.000008 0.000011 0.000012 0.000019 0.000016 0.000016 0.000017 0.000016 0.000016 0.000017 0.000015 0.000016 0.000016 0.000108 0.000164 0.000236 0.000293 0.000302 0.000300 0.000291 0.000289 0.000290 0.000297 0.000297 0.000296 0.000291 0.001453 0.002120 0.003399 0.004624 0.004745 0.007572 0.004385 0.004452 0.004395 0.004638 0.007667 0.004455 0.004624 0.018899 0.037005 0.055055 0.105380 0.100341 0.111791 0.104286 0.067776 0.075897 0.080078 0.077610 0.104269 0.097616
64
Arquivo C.5: Resultados do testes utilizando QuickSort.

Method Quant Type mComp . mMovim . mTime Quick Quick Quick Quick Quick Quick Quick Quick Quick Quick Quick Quick Quick Quick Quick Quick Quick Quick Quick Quick Quick Quick Quick Quick Quick Quick Quick Quick Quick Quick Quick Quick Quick Quick Quick Quick Quick Quick Quick Quick Quick Quick Quick Quick Quick Quick Quick Quick Quick Quick Quick Quick 100 100 100 100 100 100 100 100 100 100 100 100 100 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 10000 10000 10000 10000 10000 10000 10000 10000 10000 10000 10000 10000 10000 100000 100000 100000 100000 100000 100000 100000 100000 100000 100000 100000 100000 100000 OrdC OrdD OrdP OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdC OrdD OrdP OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdC OrdD OrdP OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdC OrdD OrdP OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA 606 610 727 997 997 997 997 997 997 997 997 997 997 9009 9016 10725 12852 12852 12852 12852 12852 12852 12852 12852 12852 12852 125439 125452 157689 181203 181203 181203 181203 181203 181203 181203 181203 181203 181203 1600016 1600030 2251124 2137184 2137184 2114943 2114943 2114943 2114943 2114943 2114943 2114943 2114943 189 336 324 570 570 570 570 570 570 570 570 570 570 1533 3030 3522 8136 8136 8136 8136 8136 8136 8136 8136 8136 8136 17712 32712 66225 103575 103575 103575 103575 103575 103575 103575 103575 103575 103575 196605 346602 903300 1311831 1311831 1310586 1310586 1310586 1310586 1310586 1310586 1310586 1310586 0.000020 0.000022 0.000029 0.000035 0.000033 0.000032 0.000032 0.000032 0.000032 0.000031 0.000031 0.000032 0.000032 0.000191 0.000197 0.000309 0.000409 0.000398 0.000404 0.000397 0.000403 0.000396 0.000404 0.000396 0.000404 0.000400 0.002403 0.002531 0.003792 0.004968 0.004840 0.004932 0.004946 0.004929 0.004967 0.005176 0.004931 0.004929 0.004987 0.028667 0.029437 0.045093 0.081911 0.069456 0.054217 0.055759 0.063946 0.062869 0.084427 0.097758 0.098938 0.090165
65
Arquivo C.6: Resultados do testes utilizando HeapSort.

Method Quant Type mComp . mMovim . mTime Heap Heap Heap Heap Heap Heap Heap Heap Heap Heap Heap Heap Heap Heap Heap Heap Heap Heap Heap Heap Heap Heap Heap Heap Heap Heap Heap Heap Heap Heap Heap Heap Heap Heap Heap Heap Heap Heap Heap Heap Heap Heap Heap Heap Heap Heap Heap Heap Heap Heap Heap Heap 100 100 100 100 100 100 100 100 100 100 100 100 100 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 10000 10000 10000 10000 10000 10000 10000 10000 10000 10000 10000 10000 10000 100000 100000 100000 100000 100000 100000 100000 100000 100000 100000 100000 100000 100000 OrdC OrdD OrdP OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdC OrdD OrdP OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdC OrdD OrdP OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdC OrdD OrdP OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA 1265 1125 1254 1205 1205 1205 1205 1205 1205 1205 1205 1205 1205 19562 17952 19525 18837 18837 18837 18837 18837 18837 18837 18837 18837 18837 264433 246705 264737 255288 255288 255288 255288 255288 255288 255288 255288 255288 255288 3312482 3131748 3294503 3220006 3220006 3220006 3220006 3220006 3220006 3220006 3220006 3220006 3220006 884 747 868 817 817 817 817 817 817 817 817 817 817 12192 10811 12190 11556 11556 11556 11556 11556 11556 11556 11556 11556 11556 156928 141975 156489 149150 149150 149150 149150 149150 149150 149150 149150 149150 149150 1900842 1747201 1887739 1825075 1825075 1825075 1825075 1825075 1825075 1825075 1825075 1825075 1825075 0.000033 0.000032 0.000035 0.000034 0.000035 0.000034 0.000034 0.000034 0.000033 0.000035 0.000034 0.000034 0.000034 0.000412 0.000381 0.000405 0.000422 0.000420 0.000420 0.000420 0.000423 0.000426 0.000419 0.000419 0.000419 0.000419 0.008299 0.007504 0.004734 0.005324 0.005187 0.008293 0.008269 0.009227 0.011361 0.009188 0.010626 0.010120 0.010692 0.083919 0.084207 0.088935 0.079565 0.099474 0.102175 0.087964 0.072352 0.077337 0.073631 0.089448 0.090158 0.070367
66
Arquivo C.7: Resultados do testes utilizando MergeSort.

Method Quant Type MComp . MMovim . MTime Merge Merge Merge Merge Merge Merge Merge Merge Merge Merge Merge Merge Merge Merge Merge Merge Merge Merge Merge Merge Merge Merge Merge Merge Merge Merge Merge Merge Merge Merge Merge Merge Merge Merge Merge Merge Merge Merge Merge Merge Merge Merge Merge Merge Merge Merge Merge Merge Merge Merge Merge Merge 100 100 100 100 100 100 100 100 100 100 100 100 100 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 1000 10000 10000 10000 10000 10000 10000 10000 10000 10000 10000 10000 10000 10000 100000 100000 100000 100000 100000 100000 100000 100000 100000 100000 100000 100000 100000 OrdC OrdD OrdP OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdC OrdD OrdP OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdC OrdD OrdP OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdC OrdD OrdP OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA OrdA 372 316 505 558 558 558 558 558 558 558 558 558 558 5052 4932 7869 8744 8744 8744 8744 8744 8744 8744 8744 8744 8744 71712 64608 114410 123685 123685 123685 123685 123685 123685 123685 123685 123685 123685 877968 815024 1106062 1566362 1566362 1566362 1566362 1566330 1566330 1566330 1566330 1566749 1566749 1376 1376 1376 1376 1376 1376 1376 1376 1376 1376 1376 1376 1376 19968 19968 19968 19968 19968 19968 19968 19968 19968 19968 19968 19968 19968 272640 272640 272640 272640 272640 272640 272640 272640 272640 272640 272640 272640 272640 3385984 3385984 3385984 3385984 3385984 3385984 3385984 3385984 3385984 3385984 3385984 3385984 3385984 0.000158 0.000141 0.000143 0.000148 0.000147 0.000147 0.000147 0.000151 0.000150 0.000150 0.000150 0.000150 0.000150 0.001487 0.001495 0.001518 0.001598 0.001597 0.001601 0.001598 0.001690 0.001609 0.001605 0.001601 0.001603 0.001599 0.015855 0.016313 0.023147 0.029013 0.017560 0.017046 0.017231 0.017340 0.024817 0.016881 0.018917 0.017271 0.019384 0.205009 0.219894 0.221169 0.265624 0.243212 0.227766 0.233699 0.203184 0.253517 0.258494 0.265600 0.231564 0.250193
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.
http://www.nuperc.unifacs.br/Members/thales.castro/arquivos/ aulas/Ordenacao%20Interna.ppt.
Mtodos de ordenao, 2008.
[5] Alvaro Borges de Oliveira. Paulo, 1st edition, 2002.
Mtodos de Ordenao Interna.
Visual Book, So
[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. 1989.
Algorithms.
Addison-Wesley, Massachussets, 2st edition,
[18] Hamid Reza Shahbazkia. Quicksort. http://w3.ualg.pt/~hshah/ped/Aula% 2014/Quick_final.html. [19] Nivio Ziviani. Projeto de Algoritmos com implementao THOMSON Learning, So Paulo, 1st edition, 2007.
em C++ e Java.
69

tp3 Sol1

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

tp3 Sol1

Enviado por

Direitos autorais:

Formatos disponíveis

Universidade Federal de Ouro Preto Instituto de Cincias Exatas e Biolgicas Departamento de Computao

ALGORITMOS E ESTRUTURAS DE DADOS Mtodos de ordenao Interna.

Antonio Carlos de Nazar Jnior Professor - David Menotti Gomes

Ouro Preto 14 de novembro de 2008

Lista de Programas e Arquivos

Captulo 2 Mtodos de Ordenao

typedef long typedef struct

Programa 2.1: Estrutura do tipo Item.

Figura 2.1: Exemplo de ordenao Estvel e Instvel. 2

1. BubbleSort 2. InsertSort 3. SelectSort

ShellSort QuickSort HeapSort MergeSort

Implementao dos mtodos

Programa 2.2: Estrutura da classe SortMethods.

"CTimer . h" " Types . h"

mComparations ; mMoviments ; mTime ;

long long long long long long long long

SortMethods ( ) ; B u b b l e S o r t ( TItem S e l e c t S o r t ( TItem

Array , Array , I n s e r t S o r t ( TItem A r r a y , S h e l l S o r t ( TItem A r r a y , Q u i c k S o r t ( TItem A r r a y , H e a p S o r t ( TItem A r r a y , M e r g e S o r t ( TItem A r r a y ,

long long long long long long long

void this this this

Programa 2.3: Mtodo para zerar valores.

SortMethods : : C l e a r A l l ( ) { >m C o m p a r a t i o n s >mMoviments = >mTime = 0;

Retorna o nmero de comparaes entre

double getMoviments(): Retorna o nmero de movimentaes (trocas) re-

alizadas entre os itens;

double return this

Programa 2.4: Mtodos de consulta s variveis de medida.

double return this

SortMethods : : getComparations ( ) { >m C o m p a r a t i o n s ;

double return this

SortMethods : : getMoviments ( ) { >mMoviments ;

Figura 2.2: Ilustrao do funcionamento do algoritmo BubbleSort.

A seguir na Figura 2.3 mostrado o uxograma do algoritmo.

Figura 2.3: Fluxograma do algoritmo BubbleSort.

Programa 2.5: Mtodo BubbleSort.

this for for this if this this this

>C l e a r A l l ( ) ; >s t a r t ( ) ; ; i ; < n

>m C o m p a r a t i o n s++; A r r a y [ j ] . Key < = Array [ j ] ; Array [ j

(0 + n 2)(n 1) (n 1) n(n 1) 2 (n2 3n + 2) n2 n (n 1) 2 2n2 2n n2 + 3n 2 2n + 2 2 2 n n 2 O(n2 )

Tabela 2.1: Vantagens e desvantagens do Mtodo BubbleSort.

Figura 2.4: Ilustrao do funcionamento do algoritmo InsertSort.

Figura 2.5: Fluxograma do algoritmo InsertSort. 10

Programa 2.6: Mtodo InsertSort.

this for this this while this

>C l e a r A l l ( ) ; >s t a r t ( ) ; 1; i < n; i ++){

>m C o m p a r a t i o n s++; ( j + >= 1] 0 = ) & & ( aux . Key < A r r a y [ j ] . Key ) ){

A Equao 2.3 demonstra o calculo da funo de complexidade em relao ao nmero de comparaes.

A seguir na Equao 2.4 apresentada a complexidade em funo do nmero de movimentaes;

(n 1)(1 + 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 O(n2 )

Tabela 2.2: Vantagens e desvantagens do Mtodo InsertSort.

Figura 2.6: Ilustrao do funcionamento do algoritmo SelectSort.

Programa 2.7: Mtodo SelectSort.

this for for this if

>C l e a r A l l ( ) ; >s t a r t ( ) ; 0; i <

>m C o m p a r a t i o n s++; A r r a y [ j ] . Key < j ; A r r a y [ Min ] . Key )

this this this

A Equao 2.5 mostra a equao da funo de complexidade em relao ao nmero de comparaes.

(0 + n 2)(n 1) (n 1) n(n 1) 2 (n2 3n + 2) 2 n n (n 1) 2 2n2 2n n2 + 3n 2 2n + 2 2 n2 n 2 O(n2 )

A seguir a funo de complexidade do nmero de movimentaes apresentado pela Equao 2.6.

Vantagens - Fcil Implementao

- Pequeno nmero de movimentaes - Interessante para arquivos pequenos

Tabela 2.3: Vantagens e desvantagens do Mtodo SelectSort.

void int int

A seguir na Figura 2.3 mostrado o uxograma do algoritmo.

Os testes foram realizados em um Computador com as seguintes conguraes:

Dentre os algoritmos ecientes o MergeSort o que tem o pior tempo de