Escolar Documentos
Profissional Documentos
Cultura Documentos
Santo André
Maio de 2012
ANDRÉ RICARDO FREDERICO
ORLANDO DA SILVA JUNIOR
Santo André
Maio de 2012
2
SUMÁRIO
1 INTRODUÇÃO ..................................................................................................................... 3
1.1 Objetivos............................................................................................................................... 3
2 METODOLOGIA.................................................................................................................. 4
2.1 Experimentos ........................................................................................................................ 4
3 RESULTADOS ...................................................................................................................... 6
3.1 Bubble Sort ........................................................................................................................... 6
3.2 Selection Sort........................................................................................................................ 7
3.3 Insertion Sort ........................................................................................................................ 8
3.4 Quick Sort ............................................................................................................................. 9
3.5 Heap Sort ............................................................................................................................ 10
3.6 Merge Sort .......................................................................................................................... 12
3.7 Shell Sort ............................................................................................................................ 12
3.8 Shell Sort – Knuth .............................................................................................................. 13
3.9 Shell Sort – Pardons ........................................................................................................... 14
3.10 Ordenação Inversa ............................................................................................................ 14
1 INTRODUÇÃO
1.1 Objetivos
2 METODOLOGIA
2.1 Experimentos
3 RESULTADOS
Bubble Sort
60000
40000
30000
20000
10000
0
10000 30000 90000
Figura 1 – Gráfico comparativo do tempo médio do algoritmo
Bubble Sort
6000000
5000000
Tempo médio (ms)
4000000
3000000
2000000
1000000
0
270000 810000
Figura 2 – Gráfico comparativo do tempo médio do algoritmo
Selection Sort
70000
60000
Tempo médio (ms)
50000
40000
30000
20000
10000
0
10000 30000 90000
Figura 3 – Gráfico comparativo do tempo médio do algoritmo
Selection Sort
6000000
5000000
Tempo médio (ms)
4000000
3000000
2000000
1000000
0
270000 810000
Figura 4 – Gráfico comparativo do tempo médio do algoritmo
A ideia por trás do Insertion Sort é ordenar uma lista através da inserção de elementos.
Se um elemento é inserido na lista, ele já deve ser colocado em sua posição correta
(MCCONNELL, 2006).
Assim como o Selection Sort, o algoritmo Insertion Sort também subdivide suas
análises no mesmo espaço de tamanho de conjuntos. A Figura 5 e a Figura 6 apresentam essas
análises.
9
Insertion Sort
16000
Insertion Sort
1600000
1400000
Tempo médio (ms)
1200000
1000000
800000
600000
400000
200000
0
270000 810000
Figura 6 – Gráfico comparativo do tempo médio do algoritmo
elementos a 2430 mil elementos) e a segunda abrange os três últimos conjuntos (de 7290 mil
elementos a 65610 mil elementos).
A primeira análise é apresentada na Figura 7, enquanto que a segunda análise é
apresentada na Figura 8.
Quick Sort
900
800
700
Tempo médio (ms)
600
500
400
300
200
100
0
10000 30000 90000 270000 810000 2430000
Figura 7 – Gráfico comparativo do tempo médio do algoritmo
Quick Sort
25000
20000
Tempo médio (ms)
15000
10000
5000
0
7290000 21870000 65610000
Figura 8 – Gráfico comparativo do tempo médio do algoritmo
O Heap Sort é um algoritmo baseado na árvore binária Heap (máxima), onde para
cada subárvore o valor da raiz é maior que dos filhos. A ideia geral do Heap Sort é a
construção do Heap: o maior elemento será sempre a raiz da árvore; a raiz é copiada para a
11
última posição e, então, o Heap é reconstruído, até que a lista esteja ordenada
(MCCONNELL, 2006).
Para apresentar os resultados do Heap Sort, duas análises foram realizadas: a primeira
abrange os seis primeiros tamanhos de conjuntos de dados (de 10 mil elementos a 810 mil
elementos) e a segunda abrange os três últimos conjuntos (de 2430 mil elementos a 65610 mil
elementos).
Heap Sort
800
700
Tempo médio (ms)
600
500
400
300
200
100
0
10000 30000 90000 270000 810000
Figura 9 – Gráfico comparativo do tempo médio do algoritmo
Heap Sort
120000
100000
Tempo médio (ms)
80000
60000
40000
20000
0
2430000 7290000 21870000 65610000
Figura 10 – Gráfico comparativo do tempo médio do algoritmo
12
O Merge Sort é baseado na ideia de que unir duas listas ordenadas é um processo
rápido. Sendo que uma lista com apenas um elemento já está ordenada, o Merge Sort quebra
as listas até que elas tenham esse tamanho único e depois as une, recursivamente.
Para o algoritmo Merge Sort, foi realizada apenas uma análise. Conforme se percebe
na Figura 11, os diferentes tamanhos não desbalancearam totalmente o gráfico, já que a faixa
de tempo não possui uma largura tão ampla de valores, como nos demais algoritmos
analisados.
Merge Sort
40000
35000
Tempo médio (ms)
30000
25000
20000
15000
10000
5000
0
O algoritmo Shell Sort é uma variação do algoritmo de inserção. A ideia por trás do
Shell Sort é inserir os elementos em suas posições corretas através de passos mais largos. O
Shell Sort utiliza uma sequência de incrementos que determina qual é o próximo elemento a
ser ordenado na subsequência (BALAN, 2012).
Para o algoritmo Shell Sort, quatro análises foram realizadas. Nas duas primeiras
análises, é verificado a faixas entre (a) 10 mil elementos e 810 mil elementos e (b) 2430 mil
elementos e 65610 mil elementos. Nas duas últimas análises, todas as faixas de valores são
comparadas, porém apenas nas versões de Knuth e Pardons, nos subcapítulos seguintes.
13
Essa divisão foi feita para que seja possível analisar o algoritmo como um todo,
independente de sua versão. Como é possível notar, os gráficos das versões de Knuth e
Pardons aproximam-se um do outro e da versão original do algoritmo Shell Sort.
A Figura 12 e a Figura 13 apresentam a análise gráfica do algoritmo Shell Sort em sua
versão original.
Shell Sort
900
800
700
Tempo médio (ms)
600
500
400
300
200
100
0
10000 30000 90000 270000 810000
Figura 12 – Gráfico comparativo do tempo médio do algoritmo
Shell Sort
100000
90000
80000
Tempo médio (ms)
70000
60000
50000
40000
30000
20000
10000
0
2430000 7290000 21870000 65610000
Figura 13 – Gráfico comparativo do tempo médio do algoritmo
80000
70000
60000
50000
40000
30000
20000
10000
0
40000
35000
30000
25000
20000
15000
10000
5000
0
Por fim, é apresentada nesta seção a rodada da ordenação inversa. Nesta atividade, os
algoritmos ordenaram um conjunto de dados com 50 mil elementos. Nesse conjunto, os
elementos foram inseridos em ordem decrescente sobre uma com distribuição linear.
15
Ineficientes
20000
18000
16000
14000
Tempo (ms)
12000
10000
8000
6000
4000
2000
0
Bubble Sort Selection Sort Insertion Sort
Eficientes
16,2
16,0
15,8
15,6
Tempo (ms)
15,4
15,2
15,0
14,8
14,6
14,4
Quick Sort Heap Sort Merge Sort Shell Sort Shell Sort - Shell Sort -
Knuth Pardons
tempo médio avaliado não ultrapassou o tempo de nenhuma das avaliações dos algoritmos
anteriores. No pior caso esperado deste projeto, ainda ordenou o conjunto com mais de 65
milhões de dados em apenas 20 segundos.
O algoritmo Heap Sort foi o segundo algoritmo eficiente avaliado. Conforme análise
gráfica, este algoritmo alcançou bons resultados em seu desempenho. Embora seja um
algoritmo in-place (que não utiliza memória auxiliar para o processamento) com pior caso
, o Heap Sort não obteve melhores resultados que o Quick Sort.
O algoritmo Merge Sort ainda conseguiu superar o desempenho do Heap Sort. Até
mesmo para os tamanhos maiores, o Merge Sort obteve menor tempo médio entre as
sequências de semente e os tamanhos que o Heap Sort. Junto com o Quick Sort e apenas uma
análise gráfica, a taxa de crescimento do tempo médio do Merge Sort mostrou-se linear em
relação ao tamanho do conjunto.
O algoritmo Shell Sort concluiu a análise de desempenho do projeto. Com três
variações de implementação – tradicional, de Knuth e de Pardons –, o algoritmo Shell Sort foi
um dos melhores algoritmos de ordenação em termos de desempenho. Tanto para pequenas
quantidades quanto para grandes quantidades, a taxa de crescimento desse algoritmo foi
linear.
Para o Shell Sort, é interessante notar que a versão de Pardons obteve um desempenho
significativo em relação a suas demais versões. Embora a versão de Knuth tenha tido um
desempenho melhor que a versão original de Shell, a diferença entre ambas foi pouco
significativa na avaliação dos tamanhos dos conjuntos.
Por fim, a ordenação inversa obteve como melhor resultado entre os ineficientes o
algoritmo Insertion Sort, que rodou em menos da metade do tempo que o Bubble Sort – o
segundo melhor. Entre os algoritmos eficientes, os melhores foram o Quick Sort e a versão
original do algoritmo Shell Sort. Com apenas um milissegundo de diferença, os demais
algoritmos eficientes (Heap Sort, Merge Sort, Shell Sort – Knuth e Shell Sort – Pardons)
ficaram em segundo lugar na avaliação de desempenho geral.
18
REFERÊNCIAS BIBLIOGRÁFICAS