Análise empírica de algoritmos de ordenação

13,047 views

Published on

Trabalho apresentado à Universidade Federal do ABC como parte para aprovação no curso de Análise de Algoritmos e Estrutura de Dados.

O objetivo principal deste trabalho é estudar empiricamente a complexidade de tempo dos algoritmos de ordenação interna.

Published in: Technology
2 Comments
2 Likes
Statistics
Notes
No Downloads
Views
Total views
13,047
On SlideShare
0
From Embeds
0
Number of Embeds
3
Actions
Shares
0
Downloads
468
Comments
2
Likes
2
Embeds 0
No embeds

No notes for slide

Análise empírica de algoritmos de ordenação

  1. 1. UNIVERSIDADE FEDERAL DO ABC ANDRÉ RICARDO FREDERICO ORLANDO DA SILVA JUNIORANÁLISE EMPÍRICA DE ALGORITMOS DE ORDENAÇÃO Santo André Maio de 2012
  2. 2. ANDRÉ RICARDO FREDERICO ORLANDO DA SILVA JUNIORANÁLISE EMPÍRICA DE ALGORITMOS DE ORDENAÇÃO Trabalho apresentado à Universidade Federal do ABC como parte para aprovação no curso de Análise de Algoritmos e Estrutura de Dados, ministrado pelo Prof. Dr. André Balan e Prof. Dr. Daniel Martin. Santo André Maio de 2012
  3. 3. 2 SUMÁRIO1 INTRODUÇÃO ..................................................................................................................... 31.1 Objetivos............................................................................................................................... 32 METODOLOGIA.................................................................................................................. 42.1 Experimentos ........................................................................................................................ 43 RESULTADOS ...................................................................................................................... 63.1 Bubble Sort ........................................................................................................................... 63.2 Selection Sort........................................................................................................................ 73.3 Insertion Sort ........................................................................................................................ 83.4 Quick Sort ............................................................................................................................. 93.5 Heap Sort ............................................................................................................................ 103.6 Merge Sort .......................................................................................................................... 123.7 Shell Sort ............................................................................................................................ 123.8 Shell Sort – Knuth .............................................................................................................. 133.9 Shell Sort – Pardons ........................................................................................................... 143.10 Ordenação Inversa ............................................................................................................ 14ANÁLISE DOS RESULTADOS E CONCLUSÃO ............................................................. 16REFERÊNCIAS BIBLIOGRÁFICAS ................................................................................. 18
  4. 4. 31 INTRODUÇÃO Um algoritmo consiste em um procedimento com um conjunto regras não ambíguasque especificam, para cada entrada, uma sequência finita de operações, resultando em umasaída correspondente (TOSCANI; VELOSO, 2002). Assim, analisar um algoritmo significaprever os recursos que o algoritmo necessitará (CORMEN et al., 2002). A previsão de recursos necessários, neste trabalho, é obtida através da análise empíricado tempo de execução de cada algoritmo. Com esta metodologia, espera-se obter o tempomédio de um algoritmo para diferentes tamanhos de entrada. Esse tipo de avaliação permitecomparar a praticidade com que os algoritmos podem ser utilizados. No entanto, para que omodelo matemático que avalia a complexidade de algoritmos não se torne inútil, também énecessária a sua presença nessa avaliação. É indiscutível a importância dos algoritmos de ordenação na ciência da computação(CORMEN et. al, 2002; MCCONNELL, 2006). Neste trabalho, os principais algoritmos deordenação são avaliados e comparados. Basicamente, um algoritmo de ordenação é aquele que resolve um problema deordenação. Formalmente, um problema de ordenação pode ser definido como uma sequênciade números 〈 〉 cuja saída é uma permutação da sequência de entrada, tal que (CORMEN et al., 2002).1.1 Objetivos O objetivo principal deste trabalho é estudar empiricamente a complexidade de tempodos algoritmos de ordenação interna. Para alcançar esse objetivo, outros objetivos específicos se tornam necessários. Paraeste trabalho, os objetivos específicos são: a) Estudar as características gerais e a complexidade de cada algoritmo utilizado; b) Implementar em uma linguagem adequada todos os algoritmos utilizados, a fim de que fatores externos de desempenho não prejudiquem a avaliação final e que a leitura do código seja facilmente compreensível; c) Analisar e comparar o tempo médio do algoritmo com sua complexidade temporal. d) Realizar, analisar e comparar o desempenho entre os algoritmos avaliados.
  5. 5. 42 METODOLOGIA A metodologia utilizada neste trabalho seguiu as diretrizes propostas pela atividade.Assim, foram utilizados sete algoritmos de ordenação sobre seis conjuntos de dados aleatóriosdiferentes conforme a variação de suas sementes mais um conjunto extra inversamenteordenado. Os conjuntos de dados possuíam nove diferentes tamanhos. Cada um desses conjuntos,escolhidos pela diretriz da atividade proposta, comportava, respectivamente, 10 mil, 30 mil,90 mil, 270 mil, 810 mil, 2430 mil, 7290 mil, 21870 mil e 65610 mil elementos. No casodeste trabalho, esses conjuntos agregaram apenas números inteiros, embora pudessem serutilizados outros tipos de dados. As sequências utilizadas para a geração dos números aleatórios tiveram as sementes: 4,81, 151, 1601, 2307 e 4207. Por fim, os algoritmos de ordenação utilizados foram divididosem: a) Ineficientes: Bubble sort, Selection sort e Insertion sort; e b) Eficientes: Quick sort, Heap sort, Merge sort e Shell sort (com 3 variações: padrão, Knuth e Pardons).2.1 Experimentos Ao todo, o projeto contabilizou nove métodos de ordenação, nove tamanhos diferentesde conjunto de dados e seis sequências aleatórias, totalizando 486 ordenações. Na rodadainversa, os nove algoritmos foram utilizados para prever o pior caso: ordenar um conjuntoinversamente ordenado. Foram utilizados dois computadores para realizar este experimento. O primeirocomputador é um notebook com processador Intel Core 2 Duo 2.10 Ghz 32-bits, 4 GB dememória RAM. O segundo computador é um notebook com processador Intel Core 2 Duo 2.0Ghz 32-bits, 3 GB de memória. Enquanto o primeiro computador utilizou-se do sistemaoperacional Windows 7, o segundo utilizou o Linux Ubutu 11.10. Para a coleta dos dados e posterior análise, os resultados de ambos os computadoresforam aproveitados, sem, no entanto, intercalar as respostas dos algoritmos ou suas sequênciasnuméricas. Isto foi realizado para: (a) analisar a influência do computador sobre a execuçãodos algoritmos em cada conjunto de dados e (b) acelerar os experimentos, que poderiamdemorar horas ou dias.
  6. 6. 5 As funções de tempo próprias de cada sistema operacional foram implementadas eutilizadas em seus respectivos ambientes.
  7. 7. 63 RESULTADOS Com os experimentos, notou-se que a partir do tamanho de entrada 2430 mil osalgoritmos ineficientes estavam levando mais de duas horas para serem concluídos. Por estarazão, este trabalho optou por não continuar executando os algoritmos ineficientes para ostamanhos maiores que 810 mil elementos e nem os apresentará nestes resultados. Ainda, para evitar o pior caso do algoritmo Quick Sort, ele foi implementadoparcialmente em modo iterativo e a seleção do pivô se deu de maneira aleatória. Também,para melhorar a execução do algoritmo Bubble Sort, sua implementação foi modificada demodo a não executar mais de uma vez o que já foi executado. Os resultados expressos nos gráficos abaixo apresentam a relação tamanho x tempo decada um dos algoritmos utilizados pelo projeto. Os resultados são apresentados por algoritmoe semente utilizada. Por fim, é apresentado o resultado da rodada inversa.3.1 Bubble Sort O Bubble Sort é um algoritmo de ordenação interna que compara pares de elementos,trocando aqueles que estão fora de ordem até que a lista esteja ordenada (MCCONNELL,2006). A Figura 1 apresenta a relação tamanho do conjunto x tempo médio, emmilissegundos, do algoritmo Bubble Sort para as seis sementes utilizadas. Os tamanhospresentes no gráfico são 10 mil, 30 mil e 90 mil elementos. A Figura 2 apresenta a mesmarelação da Figura 1, mas apenas para os tamanhos 270 mil e 810 mil elementos.
  8. 8. 7 Bubble Sort 60000 Tempo médio (ms) 50000 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 algoritmo3.2 Selection Sort O Selection Sort é um dos algoritmos de ordenação mais simples que existe.Basicamente, o algoritmo divide a lista em duas listas: ordenada e desordenada. Percorrendo alista desordenada, o algoritmo seleciona nela o menor valor e a insere na lista ordenada(BALAN, 2012; SEDGWICK, 1990). Assim como o Bubble Sort, o algoritmo Selection Sort está dividido em duas análises:do tamanho 10 mil até o tamanho 90 mil (Figura 3) e do tamanho 270 mil até o tamanho 810mil (Figura 4).
  9. 9. 8 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 algoritmo3.3 Insertion Sort 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 suasanálises no mesmo espaço de tamanho de conjuntos. A Figura 5 e a Figura 6 apresentam essasanálises.
  10. 10. 9 Insertion Sort 16000 Tempo médio (ms) 14000 12000 10000 8000 6000 4000 2000 0 10000 30000 90000 Figura 5 – Gráfico comparativo do tempo médio do algoritmo 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 algoritmo3.4 Quick Sort O Quick Sort é um dos melhor algoritmos de ordenação que existe. Recursivamente, oalgoritmo escolhe um elemento e divide a lista em duas partes: a primeira, com todos oselementos menores que o elemento escolhido; e a segunda, com todos os maiores. Quando alista atinge o tamanho mínimo, o algoritmo, então, ordena e devolve o pequeno conjuntoordenado (MCCONNELL, 2006; SEDGWICK, 1990). O Quick Sort foi o primeiro algoritmo da categoria dos algoritmos eficientes utilizado.Para apresentar seus resultados e dos demais algoritmos eficientes, duas análises foramrealizadas: a primeira abrange os seis primeiros tamanhos de conjuntos de dados (de 10 mil
  11. 11. 10elementos a 2430 mil elementos) e a segunda abrange os três últimos conjuntos (de 7290 milelementos 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 algoritmo3.5 Heap Sort O Heap Sort é um algoritmo baseado na árvore binária Heap (máxima), onde paracada subárvore o valor da raiz é maior que dos filhos. A ideia geral do Heap Sort é aconstrução do Heap: o maior elemento será sempre a raiz da árvore; a raiz é copiada para a
  12. 12. 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 primeiraabrange os seis primeiros tamanhos de conjuntos de dados (de 10 mil elementos a 810 milelementos) e a segunda abrange os três últimos conjuntos (de 2430 mil elementos a 65610 milelementos). 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
  13. 13. 123.6 Merge Sort O Merge Sort é baseado na ideia de que unir duas listas ordenadas é um processorápido. Sendo que uma lista com apenas um elemento já está ordenada, o Merge Sort quebraas 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 percebena Figura 11, os diferentes tamanhos não desbalancearam totalmente o gráfico, já que a faixade tempo não possui uma largura tão ampla de valores, como nos demais algoritmosanalisados. Merge Sort 40000 35000 Tempo médio (ms) 30000 25000 20000 15000 10000 5000 0 Figura 11 – Gráfico comparativo do tempo médio do algoritmo3.7 Shell Sort O algoritmo Shell Sort é uma variação do algoritmo de inserção. A ideia por trás doShell Sort é inserir os elementos em suas posições corretas através de passos mais largos. OShell Sort utiliza uma sequência de incrementos que determina qual é o próximo elemento aser ordenado na subsequência (BALAN, 2012). Para o algoritmo Shell Sort, quatro análises foram realizadas. Nas duas primeirasanálises, é verificado a faixas entre (a) 10 mil elementos e 810 mil elementos e (b) 2430 milelementos e 65610 mil elementos. Nas duas últimas análises, todas as faixas de valores sãocomparadas, porém apenas nas versões de Knuth e Pardons, nos subcapítulos seguintes.
  14. 14. 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 ePardons 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 suaversã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 algoritmo3.8 Shell Sort – Knuth A Figura 14 apresenta a análise do algoritmo Shell Sort – versão Knuth.
  15. 15. 14 Shell Sort - Knuth 100000 90000 Tempo médio (ms) 80000 70000 60000 50000 40000 30000 20000 10000 0 Figura 14 – Gráfico comparativo do tempo médio do algoritmo3.9 Shell Sort – Pardons A Figura 15 apresenta a análise do algoritmo Shell Sort – versão Pardons. Shell Sort - Pardons 50000 45000 Tempo médio (ms) 40000 35000 30000 25000 20000 15000 10000 5000 0 Figura 15 – Gráfico comparativo do tempo médio do algoritmo3.10 Ordenação Inversa Por fim, é apresentada nesta seção a rodada da ordenação inversa. Nesta atividade, osalgoritmos ordenaram um conjunto de dados com 50 mil elementos. Nesse conjunto, oselementos foram inseridos em ordem decrescente sobre uma com distribuição linear.
  16. 16. 15 A finalidade dessa rodada é avaliar os algoritmos na certeza de seus piores casos. AFigura 16 apresenta a análise realizada nos algoritmos ineficientes e a Figura 17, nosalgoritmos eficientes. Ineficientes 20000 18000 16000 14000 Tempo (ms) 12000 10000 8000 6000 4000 2000 0 Bubble Sort Selection Sort Insertion Sort Figura 16 – Gráfico comparativo da rodada inversa nos algoritmos ineficientes 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 Figura 16 – Gráfico comparativo da rodada inversa nos algoritmos eficientes
  17. 17. 164 ANÁLISE DOS RESULTADOS E CONCLUSÃO Neste capítulo serão analisados os resultados dos experimentos e serão apresentadas asconclusões gerais do projeto. Para que a análise empírica possa auxiliar este estudo, é interessante também analisar acomplexidade de tempo de cada um dos algoritmos. A Tabela 1 apresenta a complexidade detempo dos algoritmos deste trabalho, segundo a implementação adotada. Para o algoritmoShell Sort é apresentada apenas a complexidade de pior caso, já que os demais casos, médio emelhor, podem variar segundo a sequência de incrementos. Tabela 1 – Complexidade temporal dos algoritmos implementados Algoritmo Pior caso Caso médio Melhor caso Bubble Sort Selection Sort Insertion Sort Quick Sort Heap Sort Merge Sort Shell Sort - - A análise gráfica de todos os algoritmos mostra que à medida que a quantidade deelementos a serem ordenados cresce, o desempenho decai e o tempo, em milissegundos,aumenta. Isto significa que o desempenho dos algoritmos só é aproveitável se o conjuntopossuir uma quantidade máxima N de elementos. Em cada gráfico, é possível verificar o valoraproximado dessa quantidade. Com a modificação da implementação, o Bubble Sort mostrou-se mais rápido. Namaior parte das vezes, bem mais rápido que o Selection Sort. Isto não era esperado, já quepopularmente o Bubble Sort é conhecido por ser o pior algoritmo de ordenação em termos dedesempenho. No geral, entre os algoritmos ineficientes, o Insertion Sort foi o que obteve omelhor desempenho. Ao contrário dos algoritmos eficientes, cuja taxa de crescimento foi linearmente baixa,os algoritmos ineficientes mostraram-se inaptos para grandes quantidades de dados. Para elementos, a taxa de crescimento dessa classe de algoritmos apresentou baixodesempenho. O Quick Sort, primeiro algoritmo eficiente avaliado neste projeto, apresentouresultados satisfatórios. Embora seu pior caso seja , assim como todos os ineficientes, o
  18. 18. 17tempo médio avaliado não ultrapassou o tempo de nenhuma das avaliações dos algoritmosanteriores. No pior caso esperado deste projeto, ainda ordenou o conjunto com mais de 65milhões de dados em apenas 20 segundos. O algoritmo Heap Sort foi o segundo algoritmo eficiente avaliado. Conforme análisegráfica, este algoritmo alcançou bons resultados em seu desempenho. Embora seja umalgoritmo 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 assequências de semente e os tamanhos que o Heap Sort. Junto com o Quick Sort e apenas umaanálise gráfica, a taxa de crescimento do tempo médio do Merge Sort mostrou-se linear emrelação ao tamanho do conjunto. O algoritmo Shell Sort concluiu a análise de desempenho do projeto. Com trêsvariações de implementação – tradicional, de Knuth e de Pardons –, o algoritmo Shell Sort foium dos melhores algoritmos de ordenação em termos de desempenho. Tanto para pequenasquantidades quanto para grandes quantidades, a taxa de crescimento desse algoritmo foilinear. Para o Shell Sort, é interessante notar que a versão de Pardons obteve um desempenhosignificativo em relação a suas demais versões. Embora a versão de Knuth tenha tido umdesempenho melhor que a versão original de Shell, a diferença entre ambas foi poucosignificativa na avaliação dos tamanhos dos conjuntos. Por fim, a ordenação inversa obteve como melhor resultado entre os ineficientes oalgoritmo Insertion Sort, que rodou em menos da metade do tempo que o Bubble Sort – osegundo melhor. Entre os algoritmos eficientes, os melhores foram o Quick Sort e a versãooriginal do algoritmo Shell Sort. Com apenas um milissegundo de diferença, os demaisalgoritmos eficientes (Heap Sort, Merge Sort, Shell Sort – Knuth e Shell Sort – Pardons)ficaram em segundo lugar na avaliação de desempenho geral.
  19. 19. 18 REFERÊNCIAS BIBLIOGRÁFICASBALAN, A. G. R. Notas de Aula. Universidade Federal do ABC (UFABC), 2012.CORMEN, T. et al. Algoritmos: teoria e prática. Rio de Janeiro: Elsevier, 2002.MCCONNELL, J. J. Analysis of Algorithms: an active learning approach. USA: Jones andBartlett Publishers, 2008.SEDGEWICK, Robert. Algorithms in C. USA: Addison-Wesley, 1990.TOSCANI, L. V.; VELOSO, P. A. S. Complexidade de Algoritmos: análise, projeto emétodos. Porto Alegre: Editora Sagra Luzzatto, 2002.

×