Sunteți pe pagina 1din 19

INSTITUTO FEDERAL DE EDUCAO, CINCIA E TECNOLOGIA DO CEAR CAMPUS FORTALEZA CURSO DE ENGENHARIA DE COMPUTAO

Relatrio do exerccio-Programa de Pesquisa e Ordenao Prof. Glauber Cintra.

Equipe: Bruno Sales Francisco Jonas Rodrigues Jr. Klay da Rocha Casimiro Vitor Marcelo Martins Barreto

Sumrio

Sumrio..........................................................................................2 Introduo 4 Especificao do Software.............................................................4 Descrio.....................................................................................4 Critrios de implementao.........................................................6 3. Especificaes do ambiente computacional..............................7 4. Anlise dos resultados 7 4.1 Tempo....................................................................................8 4.1.1 Bolha com Flag................................................................8 4.1.3 Seleo............................................................................9 4.1.4 Insero.........................................................................10 4.1.5 Shellsort.........................................................................11 4.1.6 Mergesort.......................................................................12 4.1.7 Quicksort........................................................................13 4.1.8 Quicksort Probabilstico.................................................14 4.1.8 Counting Sort.................................................................15 4.1.8 Bucket Sort....................................................................16 Figura 8: Tempo do Bucket Sort ............................................16 4.1.8 Radix Sort......................................................................17 4.1.8 Heap Sort.......................................................................18 5. Concluso 19

Introduo Objetiva-se com este relatrio descrever experimento que consiste em verificar funcionamento dos mtodos de ordenao vistos durante a disciplina de Pesquisa e Ordenao, com esse experimento, espera-se confirmar o comportamento de cada mtodo visto. As duas primeiras sees do relatrio explicam como foi feita a implementao do programa e em que ambiente computacional foi realizado o experimento. A ltima seo, por sua vez, analisa o resultado obtido a partir da execuo do programa. Especificao do Software Descrio O programa ordena foi escrito na linguagem C e contm os seguintes mtodos de ordenao:

Bubble sort com Flag; Insertion sort; Selection sort Shell Sort; Merge Sort; Quick Sort Probabilstico; Quick Sort Determinstico; Counting Sort; Bucket Sort; Radix Sort; Heap Sort;

O programa tem a misso de prover uma lista aos mtodos de ordenao, donde cada um a ordenar a lista separadamente, os elementos dessa lista so nmeros gerados pseudo aleatoriamente. Ao fazer a chamada do programa informa-se o tamanho e o tipo da lista que poder ser: 1. em ordem aleatria, 2. em ordem decrescente e 3. em ordem crescente. Uma chamada vlida ao programa seria, por exemplo: ordena 1000 1, gera uma lista desordenada com 1000 elementos e submete aos mtodos. Durante a execuo contabilizado para cada mtodo: o tempo de execuo,

comparaes e movimentaes (que consiste em mover um elemento da lista para outra posio). Essas informaes so utilizadas para constatar o comportamento de cada mtodo.

Critrios de implementao A implementao do programa consistiu, basicamente, em escrever uma funo para cada mtodo de ordenao e realizar a chamada destas funes na funo principal do programa, a funo main(). Naturalmente, necessrio preparar a instncia para executar cada mtodo, a primeira tarefa coletar as variveis que definem a instncia, so elas:

tamanho : Do tipo primitivo int, define o tamanho da lista. informado


ao realizar a chamada do programa.

maximo : Do tipo primitivo int, define o maior valor que ter os cd_tipo_lista :

elementos da lista. obtido a partir da expresso: tamanho * 10. Do tipo primitivo int, armazena o cdigo que define o tipo da lista. Pode ser: 1 - Aleatria, 2 - Decrescente e 3- Crescente.

des_tipo_lista : Cadeia de caracteres que armazena a descrio do


tipo da lista.

grande : Tipo primitivo int que diz se a lista possui muitos elementos, ou
seja, grande. Aps inicializar a lista, o programa poder executar cada mtodo de ordenao. Notar que durante a execuo do programa gerado uma cpia da lista gerada inicialmente para cada mtodo, depois da execuo de um mtodo libera-se a memria usada para obter a cpia da lista. Para manipulao e marcao de tempo, usa-se da biblioteca time.h e as variveis de escopo global start e end do tipo clock_t, que controlam o tempo de inicio e fim, respectivamente, do processamento de ordenao. Elas so referenciadas na funo imprimir_tempo_decorrido(). Essa funo calcula o tempo que o mtodo gastou para ordenar em milissegundos usando as variveis start e end como base para seus clculos. Para contabilizar as movimentaes e comparaes de cada mtodo, faz-se uso de variveis globais inteiras, comp e mov, essas variveis so incrementadas em cada mtodo e zeradas ao finalizar a ordenao de um mtodo, de forma que possam ser reusadas. O programa foi escrito no padro C ANSI verso 89 e compilado com GCC 4.4.4 com a seguinte instruo: gcc -ansi -pedantic -Wall -std=c89 -o ordena ordena.c

O programa no apresentou problemas ao ser compilado em verses anteriores do GCC.

3. Especificaes do ambiente computacional O programa foi executado em uma mquina com as seguintes caractersticas:

Processador

Intel(R) Pentium(R) Dual CPU T3400 @ 2.16GHz, 2167 Mhz, 2 Ncleo(s), 2 Processador(es) Lgico(s).

Memria RAM - 2 GB Sistema Operacional - Microsoft Windows 7 Ultimate e Ubuntu 11.10


4. Anlise dos resultados Esta seo destina-se a mostrar os resultados obtidos aps a execuo do programa. Foi executado o programa usando os seguintes comandos. ordena 5000 1 ordena 5000 2 ordena 5000 3 ordena 10000 1 ordena 10000 2 ordena 10000 3 ordena 15000 1 ordena 15000 2 ordena 15000 3 ordena 20000 1 ordena 20000 2 ordena 20000 3 ordena 25000 1 ordena 25000 2 ordena 25000 3 ordena 30000 1 ordena 30000 2 ordena 30000 3 ordena 35000 1 ordena 35000 2 ordena 35000 3

. . . . . . ordena 50000 1 ordena 50000 2 ordena 50000 3 A partir da sada do programa pode-se graficar o tempo em relao ao tamanho da lista e constatar, claramente, a complexidade temporal dos mtodos de ordenao. Os grficos foram gerados pelo aplicativo Microsoft Excel 2010. 4.1 Tempo A seguir os grficos de tempo onde o eixo Y representa o tempo em milissegundos e o eixo X o tamanho da lista. 4.1.1 Bolha com Flag A Figura 1 mostra o resultado obtido, notar que o comportamento era esperado (n) no caso mdio e pior caso, quando a lista est em desordem e ordem decrescente ou menor elemento na ltima posio, respectivamente; Por ser o variante do Bolha implementado com uma flag, O(n) no melhor caso, quando a lista est em ordem.

Figura 1: Tempo do Bolha

4.1.3 Seleo Na Figura 3 podemos ver o resultado do Seleo que mostrou ser mais rpido que o Bolha com Flag, sabemos que o mtodo Seleo, independentemente da instncia que lhe submetido, possui complexidade temporal (n), ele INSITU. Para listas em desordem e em ordem decrescente ele se mostrou mais eficiente pelo fato de, comparado ao Bolha com Flag, realizar menos movimentaes.

Figura 3: Tempo do Seleo

4.1.4 Insero Na Figura 4 est o resultado do mtodo Insero. O insero, como esperado, mostrou-se muito bom para listas em ordem crescente e comparado aos demais mtodos inferiores foi o que ordenou listas em desordem mais eficientemente.

Figura 4: Tempo do Insero

4.1.5 Shellsort Do Shellsort pouco pode-se afirmar, no conhecido um comportamento padro desse mtodo. Sabe-se que a complexidade temporal desse mtodo esta entre (n log(n)) e (nn). Na Figura 5 pode-se ver o resultado obtido.

Figura 5: Tempo do Shellsort

4.1.6 Mergesort O Mergesort possui um bom desempenho, sua complexidade para qualquer instncia (n log n). A Figura 6 mostra o resultado do experimento para o Mergesort.

Figura 6: Tempo do Mergesort

4.1.7 Quicksort A Figura 7 mostra o resultado do Quicksort, verifica-se que caso a lista esteja em ordem crescente ou decrescente o desempenho pode ser comparado aos mtodos inferiores. Entretanto, para listas em completa desordem o Quicksort mostrou ser o mais rpido. Sabe-se que a complexidade temporal do Quicksort para o melhor caso (n log n) e para o pior caso (n).

Figura 7: Tempo do Quicksort

4.1.8 Quicksort Probabilstico A Figura 8 mostra o resultado do Quicksort Probabilstico, observa-se que esse variante no possui pssimo desempenho caso a lista esteja em ordem crescente ou decrescente..

Figura 8: Tempo do Quicksort Probabilistico

4.1.8 Counting Sort A Figura 8 mostra o resultado do CountingSort, observa-se que a ordenao foi feita praticamente em tempo linear em todos os casos, como era esperado. Caractersticas: Aspectos positivos Ordena vetores em tempo linear para o tamanho do vetor inicial; No realiza comparaes; um algoritmo de ordenao estvel;

Aspectos Negativos Necessita de dois vetores adicionais para sua execuo, utilizando, assim, mais espao na memria.

Figura 8: Tempo do Counting Sort

4.1.8 Bucket Sort A Figura 8 mostra o resultado do Bucket Sort, observa-se ...

Figura 8: Tempo do Bucket Sort

4.1.8 Radix Sort A Figura 8 mostra o resultado do Radix Sort, observa-se um comportamento praticamente linear em todos os caso. Em muitas aplicaes em que necessria velocidade, o radix sort melhora as ordenaes por comparao, como heapsort e o mergesort, que necessitam de (n log n) comparaes, onde "n" o nmero de itens a serem ordenados. Caractersticas: Complexidade de Tempo: (nk). Complexidade de espao: (n + s). n = nmero de elementos. k = tamanho string. s = tamanho do alfabeto.

Figura 8: Tempo do Radix Sort

4.1.8 Heap Sort A Figura 8 mostra o resultado do Heap Sort, observa-se um desempenho em tempo de execuo muito bom em conjuntos ordenados aleatoriamente, tem um uso de memria bem comportado e o seu desempenho em pior cenrio praticamente igual ao desempenho em cenrio mdio. Alguns algoritmos de ordenao rpidos tm desempenhos espetacularmente ruins no pior cenrio, quer em tempo de execuo, quer no uso da memria. O Heap Sort trabalha no lugar e o tempo de execuo em pior cenrio para ordenar n elementos de O (n lg n) Para valores de n, razoavelmente grande, o termo lg n quase constante, de modo que o tempo de ordenao quase linear com o nmero de itens a ordenar.

Figura 8: Tempo do Heap Sort

5. Concluso A implementao dos principais mtodos de ordenao funcionaram e o experimento, execuo dos mtodos implementados, consolidou ainda mais o conhecimento terico, tambm se pode perceber pelos testes feitos nesse experimento que o melhor mtodo de ordenao entre os estudados e implementados no exerccio programa, em relao a tempo foi o Quick Sort e o HeapSort, esse fato pode ser facilmente visualizado nos grficos gerados. Conclui-se ento que este relatrio confirmou, precisamente, o comportamento prtico de cada mtodo de ordenao.