Avaliação empírica de desempenho dos algoritmos de ordenação: Quicksort, Mergesort e Heapsort

Embed Size (px)

DESCRIPTION

O trabalho consistia em fazer uma análise de desempenho dos algoritmos de ordenação Quicksort,Mergesort e Heapsort. Foram realizados experimentos com os 3 algoritmos, onde os mesmos foramutilizados para ordenar vetores de tamanho 10.000, 100.000, 1.000.000, 10.000.000 e 100.000.000, eforam analisados os tempos de execução dos algoritmos em função do tamanho da entrada. Para cadaum dos algoritmos foram realizados testes com 50 vetores com inteiros naturais entre 0 e 65535 paracada tamanho de entrada, e ainda foram realizados testes com vetores compostos apenas pelos números1 e 0 dispostos aleatoriamente nos vetores.

Text of Avaliação empírica de desempenho dos algoritmos de ordenação: Quicksort, Mergesort e Heapsort

Avaliao emprica de desempenho dos algoritmos de ordenao: Quicksort, Mergesort e HeapsortAndrew Cavalcante Pacfico Instituto de Computao Universidade Federal do Amazonas, Manaus AM Brasil.{andrewcpacifico@gmail.com}

1.

Introduo

O trabalho consistia em fazer uma anlise de desempenho dos algoritmos de ordenao Quicksort, Mergesort e Heapsort. Foram realizados experimentos com os 3 algoritmos, onde os mesmos foram utilizados para ordenar vetores de tamanho 10.000, 100.000, 1.000.000, 10.000.000 e 100.000.000, e foram analisados os tempos de execuo dos algoritmos em funo do tamanho da entrada. Para cada um dos algoritmos foram realizados testes com 50 vetores com inteiros naturais entre 0 e 65535 para cada tamanho de entrada, e ainda foram realizados testes com vetores compostos apenas pelos nmeros 1 e 0 dispostos aleatoriamente nos vetores.

2.

Descrio dos experimentos e arquivos fornecidos

Os experimentos foram realizados utilizando as implementaes dos slides passados em sala de aula. Alm dos programas que executam os algoritmos de ordenao foi criado um programa geraEntrada, que responsvel por criar todas as entradas utilizadas nos experimentos. Os arquivos fornecidos so os cdigos-fonte de todos os programas utilizados no trabalho, um Makefile responsvel por compilar todos os fontes, e pra cada algoritmo de ordenao, so fornecidos 2 scripts que executam o algoritmo para todas as entradas. Um executa para as entradas compostas de inteiros entre 0 e 65535, e o outro para as entradas compostas por 1 e 0. Os tempos de execuo de cada um dos algoritmos foram medidos utilizando o comando time do Linux.

3. 3.1.

Testes realizados com inteiros naturais Entradas de tamanho 10.000

Para entradas de tamanho 10.000 o desempenho dos trs algoritmos acabou sendo muito semelhante, o que mostra que para entradas pequenas os trs algoritmos podem ser utilizados sem nenhuma visvel diferena de desempenho. A seguir so apresentados os grficos dos tempos de execuo dos trs algoritmos para cada uma das entradas de tamanho 10.000, e a tabela com os dados obtidos aps os testes realizados.

Tempo de execuo do Quicksort para entradas de tamanho 10.000 Mdia = 0,00330,009 0,008 0,007 0,006 0,005 0,004 0,003 0,002 0,001 0 1 4 7 10 13 16 19 22 25 28 31 34 37 40 43 46 49 Entrada

Tempo de execuo do Heapsort para entradas de tamanho 10.000 Mdia = 0,0047280,009 0,008 0,007 0,006 0,005 0,004 0,003 0,002 0,001 0 1 4 7 10 13 16 19 22 25 28 31 34 37 40 43 46 49 Entrada T em p o d e E xecu o (s)

T em p o d e execu o (s)

Tempo de execuo do Mergesort para entradas de tamanho 10.000 Mdia = 0,0036120,009 0,008 0,007 0,006 0,005 0,004 0,003 0,002 0,001 0 1 4 7 10 13 16 19 22 25 28 31 34 37 40 43 46 49 Entrada T em p o d e execu o (s)

Heapsort Mergesort Quicksort

Desempenho dos trs algoritmos para entradas de tamanho 10.000 Melhor caso Pior caso Mdia 0,0001 s 0,008 s 0,003612 s 0,0001 s 0,008 s 0,004728 s 0,0001 s 0,008 s 0,0033 s

Desvio Padro 0,00142666 s 0,0022239 s 0,0017119 s

3.2.

Entradas de tamanho 100.000

Para as entradas de tamanho 100.000, os trs algoritmos apresentaram desempenho semelhante novamente, ao verificar os tempos de execuo dos trs, observa-se que o quicksort obteve um desempenho ligeiramente melhor, mas como os tempos foram todos abaixo de 1 dcimo de segundo, os trs algoritmos ainda podem ser utilizados sem visveis diferenas no tempo de execuo. A seguir so apresentados os grficos dos tempos de execuo dos trs algoritmos para cada uma das entradas de tamanho 100.000, e a tabela com os dados obtidos aps os testes realizados.Tempo de execuo do Heapsort para entradas de tamanho 100.000 Mdia = 0,05880,08 Tem po d e E xecuo (s) 0,07 0,06 0,05 0,04 0,03 0,02 0,01 0 1 4 7 10 13 16 19 22 25 28 31 34 37 40 43 46 49 Entrada Tem po d e E xecuo (s) 0,08 0,07 0,06 0,05 0,04 0,03 0,02 0,01 0 1 3 5 7 9 11 13 15 17 19 21 23 25 27 29 31 33 35 37 39 41 43 45 47 49 Entradas

Tempo de execuo do Mergesort para entradas de tamanho 100.000 Mdia = 0,0488

Tempo de execuo do Quicksort para entradas de tamanho 100.000 Mdia = 0,038320,08 Tem po d e E xecuo (s) 0,07 0,06 0,05 0,04 0,03 0,02 0,01 0 1 4 7 10 13 16 19 22 25 28 31 34 37 40 43 46 49 Entrada

Heapsort Mergesort Quicksort

Desempenho dos trs algoritmos para entradas de tamanho 100.000 Melhor caso Pior caso Mdia Desvio Padro 0,048 s 0,068 s 0,0588 s 0,004061 s 0,036 s 0,056 s 0,0488 s 0,003614 s 0,032 s 0,052 s 0,03832 s 0,004359 s

3.3.

Entradas de tamanho 1.000.000

Para as entradas de tamanho 1.000.000 o algoritmo Heapsort acabou tendo um desempenho inferior aos outros dois, mas os tempos de execuo, assim como a diferena entre os tempos foram todos inferiores a 1 segundo. Portanto os trs algoritmos ainda podem ser utilizados sem nenhuma considervel diferena de desempenho. A seguir so apresentados os grficos dos tempos de execuo dos trs algoritmos para cada uma das entradas de tamanho 1.000.000, e a tabela com os dados obtidos aps os testes realizados.Tempo de execuo do Heapsort para entradas de tamanho Mdia = 0,78728 1.000.0000,81 Tem po d e E xecuo (s) 0,8 0,79 0,78 0,77 0,76 0,75 1 4 7 10 13 16 19 22 25 28 31 34 37 40 43 46 49 Entrada T em po d e execu o (s) 0,63 0,62 0,61 0,6 0,59 0,58 0,57 0,56 0,55 0,54 1 4 7 10 13 16 19 22 25 28 31 34 37 40 43 46 49 Entrada

Tempo de execuo do Mergesort para entradas de tamanho Mdia = 0,58352 1.000.000

Tempo de execuo do Quicksort para entradas de tamanho Mdia = 0,53696 1.000.0000,56 T em p o d e E xecu o (s) 0,55 0,54 0,53 0,52 0,51 0,5 1 4 7 10 13 16 19 22 25 28 31 34 37 40 43 46 49 Entrada

Heapsort Mergesort Quicksort

Desempenho dos trs algoritmos para entradas de tamanho 1.000.000 Melhor caso Pior caso Mdia Desvio Padro 0,772 s 0,804 s 0,78728 s 0,008308 s 0,572 s 0,62 s 0,58352 s 0,008839 s 0,52 s 0,552 s 0,52696 s 0,008574 s

3.4.

Entradas de tamanho 10.000.000

Nos testes realizados com entradas de tamanho 10.000.00, j foi possvel observar uma boa diferena de desempenho entre os algoritmos. O algoritmo Mergesort foi o que apresentou o melhor desempenho, a mdia de tempo do algoritmo prxima da metade da mdia dos outros dois. O Quicksort apresentou a pior mdia dos trs, essa perda significativa de desempenho pode ser explicada pelo fato de que quanto maior o tamanho da entrada, maior a quantidade de nmeros repetidos no vetor, o que prejudica a funo de partio, levando o quicksort a ficar prximo do seu pior caso. A seguir so apresentados os grficos dos tempos de execuo dos trs algoritmos para cada uma das entradas de tamanho 10.000.000, e a tabela com os dados obtidos aps os testes realizados.Tempo de execuo do Heapsort para entradas de tamanho Mdia = 12,61518 10.000.00025 T em p o d e E xecuo (s) 20 15 10 5 0 1 3 5 7 9 11 13 15 17 19 21 23 25 27 29 31 33 35 37 39 41 43 45 47 49 Entrada Tem po d e execuo (s) 7,4 7,2 7 6,8 6,6 6,4 6,2 6 5,8 1 3 5 7 9 11 13 15 17 19 21 23 25 27 29 31 33 35 37 39 41 43 45 47 49 Entrada

Tempo de execuo do Mergesort para entradas de tamanho Mdia = 6,693 10.000.000

Tempo de execuo do Quicksort para entradas de tamanho Mdia = 18,04748 10.000.00018,25 18,2 18,15 18,1 18,05 18 17,95 17,9 17,85 17,8 17,75 17,7 1 4 7 10 13 16 19 22 25 28 31 34 37 40 43 46 49 Entrada T em p o de E xecuo (s)

Desempenho dos trs algoritmos para entradas de tamanho 10.000.000 Melhor caso Pior caso Mdia Desvio Padro Heapsort 11,457 s 24,846 s 12,61518 s 2,87773 s Mergesort 6,402 s 7,316 s 6,693 s 0,330772 s Quicksort 17,901 s 18,205 s 18,04748 s 0,071517 s

3.5.

Entradas de tamanho 100.000.000

Nos testes realizados com entradas de tamanho 100.000.000, houve um aumento maior ainda na

diferena de desempenho entre os trs algoritmos. Mais uma vez o Mergesort obteve o melhor desempenho dos trs algoritmos. A maior diferena foi no desempenho do Quicksort, o algoritmo levou em mdia 23 minutos para ordenar cada entrada, o que comprova o que foi dito na anlise dos testes para entradas de tamanho 10.000.000, quanto maior a quantidade de elementos repetidos nos vetores de entrada, pior o desempenho do Quicksort. A seguir so apresentados os grficos dos tempos de execuo dos trs algoritmos para cada uma das entradas de tamanho 100.000.000, e a tabela com os dados obtidos aps os testes realizados.Tempo de execuo do Heapsort para entradas de tamanho Mdia = 161,37888 100.000.000Tem po d e E xecu o (s) T em p o de execuo (s) 166 165 164 163 162 161 160 159 158 157 1 3 5 7 9 11 13 15 17 19 21 23 25 27 29 31 33 35 37 39 41 43 45 47 49 Entrada

70,6 70,4 70,2 70 69,8 69,6 69,4 69,2 69

Tempo de execuo do Mergesort para entradas de tamanho Mdia = 69,8606 100.000.000

1

4

7

10 13 16 19 22 25 28 31 34 37 40 43 46 49 Entrada

Tempo de execuo do Quicksort para entradas de tamanho Mdia = 1443,7565 100.000.0001700 T em p o de E xecuo (s) 1650 1600 1550 1500 1450 1400 1350 1300 1 4 7 10 13 16 19 22 25 28 31 34 37 40 43 46 49 Entrada

Desempenho dos trs algoritmos para entradas de tamanho 100.000.000 Melhor caso Pior caso Mdia Desvio Padro Heapsort 159,774 s 165,126 s 161,37888 s 1,121472 s Mergesort 69,524 s 70,424 s 69,8606 s 0,232133 s Quicksort 1432,29 s 1645,887 s 1443,7565 s 35,95335 s

3.6.

Comparao entre o desempenho dos algoritmos

Fazendo uma anlise do desempenho dos trs algoritmos para cada um dos tamanhos de entrada, possvel verificar que o Mergesort apresenta o desempenho mais constante, pois o nico dos algoritmos que independe dos valores no vetor de entrada, para todos os casos a complexidade sempre a mesma. O Quicksort apresentou o pior desempenho dos trs para entradas muito grandes, devido quantidade de elementos repetidos dos vetores de entrada, como a implementao utilizada foi a mais simpl