E.

CENTRO UNIVERSITRIO DA GRANDE DOURADOS

Jos Jean Gomes

Anlise de Algoritmo de Ordenao

Dourados 2010

E.D

CENTRO UNIVERSITRIO DA GRANDE DOURADOS

Jos Jean Gomes Rgm: 122.780

Anlise de Algoritmo de Ordenao

Trabalho apresentado na Disciplina de Estrutura de dados do 2010 ano, Curso de Cincia da Computao Faculdade de Dourados - MS Professor(a) Ademir Martinez Sanches

Dourados 2010

E.D

Trabalho Estrutura de Dados

Analise comparativo dos Algoritmos de Ordenao

E.D

Sumrio
1. Introduo................................................. ...............................3 2. Especificao dos Algoritmos
2.1.1. 2.1.2. 2.1.3. 2.1.4. 2.1.5. Bubblesor ............................................................................... 4 Selection-sort.......................................................................... 5 Insertion-sort............................................ ...............................6 Margesort................................................. ...............................7 Quicksort.................................................. ...............................9

3. Mtodos Auxiliares
3.1.1. 3.1.2. Gerar seqncias de nmeros aleatrio... ..............................11 Verificando a Ordenao........................ ...............................12

4. Analise 4.1.1. Grfico de Comparao.................................................13 4.1.2. Grfico de Troca............................................ ................14 4.1.3. Grfico de Tempo..........................................................15 5. Concluses...............................................................................16 6. Especificaes.................................................... .....................16 7. Referncias..............................................................................1 7

E.D

1. Introduo
Principal assunto analisarmos a eficincia e comparao entre os seguintes algoritmos de busca: Bubblesort, Selection-Sort, Insertion-Sort, Margesort e Quicksort. O analise aplica em executar 50 vezes cada algoritmo com entrada aleatria de nmeros de tamanho K, para cada entra de tamanha K com os respectivos valos para K = 100.000, 200.000, 500.000, 1. 000.000, 5.000.000, 10.000.000. Para cada conjunto de 50 seqncias de tamanho K ser executado os algoritmo de ordenao, analisando a cada execuo do conjunto de 50 seqncias de tamanho K, nmeros de comparao entre elementos da seqncia, nmero de troca entre a seqncia e tempo de execuo do algoritmo, finalizando o conjunto de 50 seqncias de tamanho K, calcular a media para cada item citados. Com as medias de cada conjunto de tamanho K, ser gerado um grfico comparando cada item citado entre os algoritmos de ordenao. O analise leva em conta: I. Nmeros de comparao entre elementos da seqncia II. Nmero de troca entre a seqncia III. Tempo de execuo do algoritmo Para cada conjunto de 50 seqncia de tamanho K, usaremos algoritmo que gera instancias de nmeros aleatrios. Para cada ordenao de um conjunto de 50 seqncias ser executado um algoritmo de ordenao, provando que as instancias aleatrias foram corretamente ordenadas.

E.D

2. Especificao dos algoritmos de ordenao .

2.1.1. Bubble Sort
O bubble sort, ou ordenao por flutuao (literalmente "por bolha"), um algoritmo de ordenao dos mais simples. A idia percorrer o vetor diversas vezes, a cada passagem fazendo flutuar para o topo o maior elemento da seqncia. Essa movimentao lembra a forma como as bolhas em um tanque de gua procuram seu prprio nvel, e disso vem o nome do algoritmo. No melhor caso, o algoritmo executa n2 / 2 operaes relevantes, onde n representa o nmero de elementos do vetor. No pior caso, so feitas2n2 operaes. No caso mdio, so feitas 5n2 / 2 operaes. A complexidade desse algoritmo de Ordem quadrtica. Por isso, ele no recomendado para programas que precisem de velocidade e operem com quantidade elevada de dados.

--------------------------------------------------------------------------------------------------------------//Bubblesort Cdigo C++ void Bubblesort ( int *V, int M ) { int i, j, aux; for (i = M - 1; i > 1; i--) for (j = 0; j < i; j++) if (V[j] > V[j+1]) { aux = V[j]; V[j] = V[j+1]; V[j+1] = aux; } ---------------------------------------------------------------------------------------------------------------

E.D

2.1.2. Selection Sort

O selection sort (do ingls, ordenao por seleo) um algoritmo de ordenao baseado em se passar sempre o menor valor do vetor para a primeira posio (ou o maior dependendo da ordem requerida), depois o de segundo menor valor para a segunda posio, e assim feito sucessivamente com os (n -1) elementos restantes, at os ltimos dois elementos. O algoritmo possui complexidade O(n2) enquanto que, por exemplo, os algoritmos Heapsort e Mergesort possuem complexidades O(nlogn).

-------------------------------------------------------------- -----------------------------------------------------//Selection sort cdigo C++ void Selection (int x[], int n) { int j,i,k; for (j = n - 1; j > 0; j--) { i = 0; for (k=1; k<=j; k++){ if(x[k] > x[i]) i=k; comparar++; } troca (&x[i], &x[j]); } } --------------------------------------------------------------------------------------------------------------------

E.D

2.1.3. Insertion Sort

Insertion sort, ou ordenao por insero, um simples algoritmo de ordenao, eficiente quando aplicado a um pequeno nmero de elementos. Em termos gerais, ele percorre um vetor de elementos da esquerda para a direita e medida que avana vai deixando os elementos mais esquerda ordenados. O algoritmo de insero funciona da mesma maneira com que muitas pessoas ordenam cartas em um jogo de baralho como o pquer.

Menor nmero de trocas e comparaes entre os algoritmos de ordenao (n) quando o vetor est ordenado.Pior caso O(n)

-------------------------------------------------------------------------------------------------------------------//Insertionsort cdigo C++ void ordenarInsercao(int n, int v[]){ int i, j, x; for (j = 1; j < n; j++){ x = v[j]; for (i = j - 1; i >= 0 && v[i] > x; i--){ v[i + 1] = v[i]; } v[i + 1] = x; } } --------------------------------------------------------------------------------------------- -----------------------

E.D

2.1.4. Mergesort
O merge sort, ou ordenao por mistura, um exemplo de algoritmo de ordenao do tipo dividir-para-conquistar. Sua idia bsica que muito fcil criar uma seqncia ordenada a partir de duas outras tambm ordenadas. Para isso, ele divide a seqncia original em pares de dados, ordena-as; depois as agrupa em seqncia de quatro elementos, e assim por diante, at ter toda a seqncia dividida em apenas duas partes. Os trs passos teis dos algoritmos dividir -para-conquistar, ou divide and conquer, que se aplicam ao merge sort so: Dividir: Dividir os dados em subseqncias pequenas; Conquistar: Classificar as duas metades recursivamente aplicando o merge sort; Combinar: Juntar as duas metades em um nico conjunto j classificado. Complexidade de tempo: (n log 2 n), Complexidade de espao: (n).

E.D ------------------------------------------------------------------------------- ------------------------------------//Mergesort cdigo C++ void mergesort (int *v, int inicio, int fim) { int i,j,k,m,*t; if (inicio == fim) return; // ordenacao recursiva das duas metades m = (inicio + fim) / 2; mergesort (v, inicio, m); mergesort (v, m + 1, fim); // intercalacao no vetor temporario t i = inicio; j = m + 1; k = 0; t = (int *) malloc (sizeof (int) * (fim - inicio + 1) ); while (i < m + 1 || j < fim + 1) { if ( i == m + 1 ) { // i passou do final da primeira metade, pe gar v[j] t[k] = v[j]; j++; k++; } else if (j == fim + 1) { // j passou do final da segunda metade, pegar v[i] t[k] = v[i]; i++; k++; } else if (v[i] < v[j]) { // v[i]<v[j], pegar v[i] t[k] = v[i]; i++; k++; } else { // v[j]<=v[i], pegar v[j] t[k] = v[j]; j++; k++; } } // copia vetor intercalado para o vetor original for (i = inicio; i <= fim; i++) v[i] = t[i-inicio]; free(t); } --------------------------------------------------------------------------------------------------------------------

10

E.D

2.1.5. QuickSort
O algoritmo Quicksort um mtodo de ordenao muito rpido e eficiente, inventado por C.A.R. Hoare em 1960, quando visitou a Universidade de Moscovo como estudante. Ele criou o 'Quicksort ao tentar traduzir um dicionrio de ingls para russo, ordenando as palavras, tendo como objetivo reduzir o problema original em subproblemas que possam ser resolvidos mais facil e rapidamente. Foi publicado em 1962 aps uma srie de refinamentos. O Quicksort adota a estratgia de diviso e conquista. Os passos so: Escolha um elemento da lista, denominado piv; Rearranje a lista de forma que todos os elementos anteriores ao piv sejam menores que ele, e todos os elementos posteriores ao piv sejam maiores que ele. Ao fim do processo o piv estar em sua posio final e haver duas sublistas no ordenadas. Essa operao denominada partio; Recursivamente ordene a sublista dos elementos menores e a sublista dos elementos maiores; A base da recurso so as listas de tamanho zero ou um, que esto sempre ordenadas. O processo finito, pois a cada iterao pelo menos um elemento posto em sua posio final e no ser mais manipulado na iterao seguinte.

11

E.D ------------------------------------------------------------------------------------------------ -------------------//Quicksort cdigo C++ int DeterminarPivot (int V[], int inicio, int fim) //Funo para determinar o piv; { int i, k = inicio; // k = posio do pivot V[inicio]; for (i = inicio + 1; i <= fim; i++){ comp ++; if (V[ i ] < V[inicio]) { k++; Trocar (&V[i], &V[k]); } } Trocar ( &V[inicio], &V[k]); return (k); } -------------------------------------------------------------------------------------------------------------------void OrdenarQuicksort (int V[], int inicio, int fim)//Funo qsort de ordeno; { int k; // k = posio do pivot V[inicio]; if (inicio < fim) { k = DeterminarPivot (V, inicio, fim); //chamno a funo pra determinar o pivo; OrdenarQuicksort (V, inicio, k-1 ); OrdenarQuicksort (V, k + 1, fim); } } --------------------------------------------------------------------------------------------------------------------

12

E.D

3. Mtodos Auxiliares
O analise dos algoritmos de ordenao aplica em mtodos auxiliares, algoritmos que gera seqncias aleatrias de nmeros, al goritmo de verificao comprovando que a ordenao foi realizada com sucesso, provando que v[i-1] < v[i] < v[i+1]. 3.1.1. Gerar seqncia de nmeros aleatrios
O mtodo que vamos usada para gerar as seqncias de nmeros aleatrios em nosso analise vem da biblioteca stdlib.h. funo srand, rand. Inicializar o gerador de nmeros aleatrios . O gerador de nmeros pseudo -aleatrios inicializado usando o argumento passado como semente. Para cada valor de propagao diferente usadas em uma chamada para srand, o gerador de nmeros pseudo-aleatrios pode ser esperado gerar uma sucesso de resultados diferentes nas chamadas subseqentes para rand. Duas inicializaes diferentes com a mesma semente, instruem o gerador pseudo-aleatrios para gerar a mesma sucesso de resultados para as chamadas subseqentes para rand em ambos os casos. Se a semente definida como 1, o gerador reinicializada para seu valor inicial e produz os mesmos valores que a ntes qualquer chamada para rand e srand. Para gerar nmeros aleatrios, srand geralmente inicializado com um valor distinto, como as relacionado com o tempo de execuo. Por exemplo, o valor devolvido pelo tempo de funo (declarados no cabealho <ctime>) diferente a cada segundo, o que distintivo suficiente para a maioria randoming necessidades. ---------------------------------------------------------------------------------------------- ------//cdigo para gerar nmeros aleatrios C++ #include <iostream> #include <stdlib.h> #include <time.h> using namespace std; int main() { cout << O primeiro numero: << rand() % 100 << endl; srand (time (NULL )); cout << nmero aleatrio: << rand() % 100 << endl; srand(1); cout << Novamente o primeiro numero: << rand() % 100 << endl; return 0; } ------------------------------------------------------------------------------------------------- ---Executando o programa varias vezes podemos comprovar que gerado o numero aleatrio com o comando srand ( time ( NULL ) ), a cada execuo a primeira sada e a ultima so iguais, a sada do meio diferente a cada execuo.

13

E.D 3.1.2.

Verificando a ordenao

Ao finalizar cada algoritmo de ordenao teremos que verificar se o mesmo foi corretamente ordenado, neste analise usaremos um algoritmo seguencial. O algoritmo percorrera o vetor de 0 a n -1 verificando se o elemento do vetor v[i] <= v[i+1], se o vetor estiver corretamente ordenado ele retornara um string confirmando que o mesmo esta ordenado. Caso o vetor no esteja ordenado ele terminara o processo de verificao e retornara uma string alertando que a mesma no esta ordenado. ---------------------------------------------------------------------------------------------------------/*Cdigo de verificao C++ Iremos verificar se um vetor esta ordenado. Retornando uma mensagem de aviso, ok (vetor ordenado), Erro ( Vetor no esta ordenado )*/ #include <iostream> using namespace std; int main() { int i; int v[ ] = {1, 2, 3, 4, 5}; int k; string verif; k = 0; i = 0; while (i < 5 - 1 && k == 0) { if (v [ i ] <= v [ i+1 ]) verif = "Ok"; else{ verif = "Erro"; k = 1; } i++; } cout << "Mensagem : " << verif << endl; return 0; } ----------------------------------------------------------------------------------------------------------

14

E.D

4. Analise
4.1.1. Grfico de Tempo

*Anlise de tempo entre todos

*Anlise de Tempo entre Merge sort e Quicksort As medias de tempos entre os algoritmos de ordenao teve um grande aumento a cad tamanho de vetor, com 50 mil o tempo de ordenao foi irrelevante, quaisquer algoritmo analisado tem uma media de tempos praticamente iguai s, com o aumento do vetor podemos perceber nitidamente a diferena entre os tempos, dois mtodos de ordenao manteve uma regularidade de tempo sendo extremantes rpidos, analisando os dois mtodos de ordenao separados podemos perceber que existe uma dif erena de milsimos de segundo entre eles.

15

E.D 4.1.2. Grfico de Troca

*Anlise de troca entre todo.

*Anlise de troca entre Selection, Marge sort, Quicksort

Na comparao de troca o Bubblesort manteve sendo o que vez mais trocas, o Insertion sort que teve um tempo mais baixo de ordenao que o Selection sort na comparao de troca ele realizo uma quantidade de troca maior. Merge sorte e Quicksort mantiveram uma media razovel de troca com o Merge sorte tem um numero maior que o Quicksorte em todas as verificaes, O Selection sorte tendo seu tempo sendo menor apenas que o do Bubble sort o seu numero de troca considerado extremamente baixo a os outros algoritmos de troca.

16

E.D 4.1.3. Grfico de Comparao

*Anlise de Comparao de todos

*Anlise de Comparao entre Merge sort e Quicksort Por mais que o Selection sort teve um numero de troca extremamente baixo o seu numero de comparao extremamente alto, o mesmo numero de comparao do Bubble sort, Insertion sort manteve instvel no de correr do analise com o aumente dos vetores, um anlise mais detalhado entre uma disputa entre dois algoritmos de ordenao Merge sort e Quicksort vemos que o Quicksort levo vantagem em todas as comparao.

17

E.D

5. Concluso
Na anlise dos algoritmos podemos p erceber que alguns algoritmos tm uma certe vantagem perante outros, O Merge sorte e Quick sorte foram os que tiveram um media baixa perante os outros com um superioridade do Quicksor em cima do Merge sorte. Selection sort seu analise de troca teve uma me dia baixa superando a do Merge sort e Quick sort mesmo superando os dois algoritmos mais rpidos em troca sua comparao a mesma do algoritmo mais lento fazendo o seu tempo no ser considerado rpido para um numero grande de ordenao. Insertion sort no analise manteve certa regularidade entre troca e comparao, tendo seu tempo mais baixo que o Selection sort. Bubble como os outro algoritmo de ordenao em quantidade pequena de ordenao pode ser utilizado tranquilamente, com o aumento da quantidade de nmeros para ordenao pode perceber que um mento no considervel em se utilizar levando muito tempo para realizar a ordenao.

6. Especificaes
O Anlise realizado teve um tempo de 25h30min em um computador Celeron * M 430 com 512 MB-DDR2, sistema operacional Linux-Ubuntu.

18

E.D

7. Referncia
bubblesort http://pt.wikipedia.org/wiki/Bubble_sort imagem: http://www.brpreiss.com/books/opus5/html/img2035.gif Selection sort http://pt.wikipedia.org/wiki/Selection_sort imagem: http://www.brpreiss.com/books/opus5/html/img2084.gif Insertion sort http://pt.wikipedia.org/wiki/Insertion_sort imagem: http://www.brpreiss.com/books/opus5/html/img2017.gif Mergesort http://pt.wikipedia.org/wiki/Merge_sort imagem: http://www.brpreiss.com/books/opus5/html/img2101.gif Quicksort http://pt.wikipedia.org/wiki/Quick_sort imagem: http://www.brpreiss.com/books/opus5/html/img2046.gif Numeros aleatorio http://www.cplusplus.com/reference/clibrary/cstdlib/srand/

19