Avaliao emprica de desempenho dos algoritmos de ordenao: Quicksort, Mergesort e Heapsort

Andrew 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,0033

0,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,004728

0,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,003612

0,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,0588
0,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,03832

0,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.000
0,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.000

0,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.000
25 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.000

18,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.000
Tem 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

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.000

1700 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 simples, que utiliza recurso e ainda faz uma escolha fixa para piv, o desempenho do algoritmo foi ainda mais prejudicado.

Mdias de tempo de execuo em funo do tamanho da entrada

Quicksort 10000 Tempo de Execuo (s) 1000 100 10 1 0,1 0,01 0,001 Quicksort Heapsort Mergesort 10.000 0,0033 0,004728 0,003612 100.000 0,03832 0,0588 0,0488 1.000.000 0,53696 0,78728 0,58352 Tamanho da entrada 10.000.000 18,04748 12,61518 6,693 100.000.000 1443,7565 161,37888 69,8606 Heapsort Mergesort

4. 4.1.

Testes realizados com entradas contendo apenas 0 e 1 Mergesort

Para as entradas contendo apenas os inteiros 0 e 1, no foi observada nenhuma alterao no comportamento do algoritmo Mergesort com relao aos testes realizados com entradas com inteiros entre 0 e 65535, as mdias obtidas sofreram pouca alterao quando comparadas com as mdias obtidas nos primeiros experimentos. A seguir so apresentados as mdias e desvios padro obtidos com os testes realizados com o Mergesort, junto com o grfico comparativo entre as mdias dos experimentos realizados com entradas contendo valores entre 0 e 65535 e as entradas com valores contendo 0 e 1.
Desempenho do Mergesort para entradas contendo apenas 0 e 1 Tamanho da Entrada Mdia Desvio Padro 10.000 0,00656 0,002224 100.000 0,0436 0,003614 1.000.000 0,49216 0,008839 10.000.000 5,57488 0,330772 100.000.000 61,61848 0,232133

Mdias de tempo do Mergesort para entradas naturais e binrias Mdia 0-65535 Mdia 0-1
80 Tempo de execuo (s) 70 60 50 40 30 20 10 0 10.000 100.000 1.000.000 10.000.000 100.000.000 Tamanho da entrada

4.2.

Heapsort

Nos testes realizados com o Heapsort, houve uma visvel diferena de desempenho com relao aos testes realizados com entradas contendo inteiros at 65535. Para as entradas contendo apenas os inteiros 0 e 1 o Heapsort foi o algoritmo que apresentou o melhor desempenho dos trs. Possivelmente essa melhora significativa no desempenho seja pelo fato de que com muitos elementos repetidos, necessrio um nmero menor de chamadas da funo Heapfy, para montar a rvore Heap no vetor, tornando a ordenao muito mais rpida, se aproximando de seu melhor caso na maioria das vezes.
Desempenho do Heapsort para entradas contendo apenas 0 e 1 Tamanho da Entrada Mdia Desvio Padro 10.000 0,00656 0,001852 100.000 0,0436 0,003774 1.000.000 0,49216 0,005613 10.000.000 5,57488 0,0177546 100.000.000 61,61848 0,11151583

Mdias de tempo do Heapsort para entradas naturais e binrias Mdia 0-65535

180 160 140 120 100 80 60 40 20 0 10.000 100.000 1.000.000 10.000.000 Tamanho da entrada Tempo de execuo (s)

Mdia 0-1

100.000.000

4.3.

Quicksort

Como os testes realizados anteriormente demonstraram que o Quicksort tem o seu desempenho muito prejudicado com entradas que possuem muitos valores repetidos, o esperado para entradas com apenas 0 e 1 era que o algoritmo apresentasse um desempenho ruim para todas as entradas, e os testes ocorreram conforme o esperado. Para as entradas com 0 e 1 o comportamento do algoritmo vai ser o mesmo para todas as entradas, a entrada vai ser dividida em duas partes, ento a ordenao vai ser quadrtica em cada uma dessas parties. S foram possveis testes com entradas de tamanho 10.000 e 100.000, para entradas maiores o programa gerava um erro em tempo de execuo aps 23 min. de execuo, possivelmente pelo fato da implementao ser recursiva, ento a grande quantidade de recurses acabava estourando o limite de memria disponvel.
Desempenho do Quicksort para entradas contendo apenas 0 e 1 Tamanho da Entrada 10.000 100.000 Mdia 0,4892 47,28148 Desvio Padro 0,004061 1,509785

Devido a falta de resultados nos testes realizados com o quicksort, no foi possvel plotar o grfico comparando o desempenho do quicksort com entradas at 65535.

5.

Consideraes finais

Os testes realizados com os trs algoritmos demonstram todos apresentam desempenho semelhante para entradas de at 1.000.000 de posies, a partir da comeam a apresentar considervel diferena de desempenho. Mas vale ressaltar que essa diferena s aparece devido as implementaes utilizadas terem sido feitas sem nenhum tipo de otimizao. Foram realizados alguns testes com o quicksort da linguagem C, e ele apresentou desempenho melhor do que todos os outros, o que mostra que com implementaes mais elaboradas os trs algoritmos devem apresentar desempenho semelhante pra todos os casos, uma vez que os trs possuem a mesma complexidade no caso mdio.