Métodos de Ordenação

Mtodos de Ordenao

Estrutura de Dados Avanada

Sistemas de Informao - 5 semestre

2014

Gustavo Oliveira RA 27724226822

Wemeson Junior RA 41784409855

2

ndice

Introduo .................................................................................................................................. 3

Mtodos de Ordenao .............................................................................................................. 4

Mtodos de Ordenao por Seleo ...................................................................................... 4

Selection Sort ..................................................................................................................... 4

Hearp Sort .......................................................................................................................... 5

Mtodos de Ordenao por Permutao ................................................................................ 7

Bubble Sort ........................................................................................................................ 7

QuickSort ........................................................................................................................... 8

Mtodos de Ordenao por Insero ....................................................................................10

Insertion Sort .....................................................................................................................10

Shell Sort ..........................................................................................................................12

Mtodos de Ordenao por Intercalao ..............................................................................14

MergeSort .........................................................................................................................14

Mtodos de Ordenao por Contagem de Tipos ...................................................................16

Radix Sort .........................................................................................................................16

Anlise de Resultados ..............................................................................................................19

Cdigo Exemplo Selection Sort ......................................................................................19

Cdigo Exemplo Hearp Sort ...........................................................................................20

Cdigo Exemplo Bubble Sort..........................................................................................21

Cdigo Exemplo Quick Sort ...........................................................................................22

Cdigo Exemplo Insertion Sort .......................................................................................23

Cdigo Exemplo Shell Sort .............................................................................................24

Cdigo Exemplo MergeSort............................................................................................25

Cdigo Exemplo Radix Sort ...........................................................................................27

Concluso .................................................................................................................................29

Referencias Bibliograficas .........................................................................................................30

3

Introduo

Em vrios momentos do dia a dia, o homem depara-se com a necessidade de consultar dados

ordenados. Por isso uma das atividades mais utilizada na computao a ordenao.

Ordenao (ou Classificao) refere-se em tornar mais simples, rpida e vivel a recuperao

de uma determinada informao, num conjunto grande de informaes, ou ainda, podemos

definir como um processo de rearranjar um conjunto de objetos em uma ordem ascendente ou

descendente visando facilitar a recuperao posterior de itens do conjunto ordenado.

Os mtodos de ordenao so classificados em dois grandes grupos: ordenao interna e

externa. Ordenao Interna: So os mtodos onde a ordenao feita na memria principal do

computador; enquanto ordenao Externa so mtodos que necessitam serem armazenados

em unidades externas (fita ou disco, etc)

Os processos de ordenao podem ser classificados tambm como instvel e estvel: Instvel

quando a ordem relativa dos itens com chaves iguais alterada durante o processo de

ordenao; e Estvel quando a ordem relativa dos itens com chaves iguais mantm-se

inalterada durante o processo.

No existe um mtodo de ordenao considerado universalmente superior a todos os outros.

necessrio analisar o problema e, com base nas caractersticas dos dados, decidir qual o

mtodo que melhor se aplica ele.

Neste trabalho iremos apresentar alguns dos principais mtodos de ordenao, desenvolvendo

suas caractersiticas e funcionalidades; alm de descrever e classificar seus algortmos e

avaliar suas performance e complexidade. Por ltimo, apresentaremos uma comparao entre

os mtodos exibidos e ainda uma anlise conclusiva relacionada aos aspectos mencionados.

Para esta anlise, utilizaremos vetores de 100, 1000 e 10000 posies preenchidas

randomicamente em todos os mtodos citados neste trabalho com os seus cdigos

exemplificados em cada tpico.

4

Mtodos de Ordenao

A ordenao uma atividade importante na organizao de classes de objetos, visando sua

rpida localizao. Assim, ordenao corresponde ao mtodo de rearranjar um conjunto de

objetos em uma ordem crescente ou decrescente, com o objetivo de facilitar a recuperao dos

itens desse conjunto, tornando-se assim fundamental em processamento de dados (VARELLA,

1996). Existem muitos algoritmos de ordenao, a escolha mais eficiente vai depender de

vrios fatores, tais como: nmero de itens a ser classificado; se os valores j esto agrupados

em subconjuntos ordenados, desordenados, aleatrios e parcialmente ordenados. A seguir so

apresentados os mtodos de ordenao analisados na pesquisa proposta.

Mtodos de Ordenao por Seleo

A ordenao por seleo consiste, em cada etapa, em selecionar o maior (ou o menor)

elemento e coloc-lo em sua posio correta dentro da futura lista ordenada. Durante a

aplicao do mtodo de seleo a lista com n registros fica decomposta em duas sub listas,

uma contendo os itens j ordenados e a outra com os restantes ainda no ordenados.

Selection Sort

O Selection Sort um mtodo muito bsico, a verificao feita da seguinte forma, feito a

comparao de todos os valores e assim que encontrado o valor requerido ser armazenado

na posio, e depois o prximo valor armazenado na sequencia, at que o vetor esteja

organizado da forma desejada. um algoritmo que serve apenas para a ordenao de

pequenos conjuntos.

A lgica consiste em se varrer o conjunto comparando todos os seus elementos com o

primeiro. Caso o primeiro elemento esteja desordenado em relao ao elemento que est

sendo comparado com ele no momento, feita a troca. Ao se chegar ao final do conjunto,

teremos o valor relacionado na primeira posio do conjunto.

Funcionamento

Procura o elemento e troca com o elemento da 1 posio conforme desejado (maior ou

menor);

5

Procura 2 elemento e troca com o elemento na 2 posio, e procede assim at a ordenao

estar completa.

Avaliao do Algoritmo

O Selection Sort um mtodo muito simples. Alm disso, o algoritmo de seleo apresenta um

comportamento espetacular quanto ao nmero de movimentos de registros, cujo tempo de

execuo linear, esta particularidade dificilmente encontrada em outros algoritmos de

ordenao. o algoritmo ideal para arquivos com registros muito grandes.

Vantagens

Fcil Implementao Pequeno nmero de movimentaes Interessante para arquivos pequenos

Desvantagens

O fato de o arquivo j estar ordenado no influencia em nada Ordem de complexidade quadrtica Algoritmo no estvel

Classificao Estvel

Performance Baixa

Complexidade Simples

Hearp Sort

Utilizando o mesmo princpio do SelectSort, o HeapSort um algoritmo que utiliza uma

estrutura de dados conhecida como Heap binrio para manter o prximo item a ser

selecionado. Existem dois tipos de heaps: Os heaps de mximo (max heap), em que o valor de

todos os ns so menores que os de seus respectivos pais; e os heaps de mnimo (min heap),

6

em que o valor de todos os ns so maiores que os de seus respectivos pais. Assim, em um

heap de mximo, o maior valor do conjunto est na raz da rvore, enquanto no heap de

mnimo a raz armazena o menor valor existente.

Funcionamento

O HeapSort utiliza um heap binrio para manter o prximo elemento a ser selecionado heap

binrio: rvore binria mantida na forma de vetor o heap gerado e mantido no prprio vetor

a ser ordenado (no segmento no-ordenado)

A cada iterao seleciona-se o maior elemento (na raiz do heap) e o adiciona no incio de um

segmento ordenado. Aps cada seleo de elemento, o heap deve ser reorganizado para

continuar sendo um heap binrio mximo

Cria-se uma rvore binria com os elementos do vetor desordenado Transforma a rvore

binria em um heap binrio mximo. A transformao ocorre de forma bottom-up, inicia-se a

partir dos nodos folha e vai executando a transformao em direo a raiz.

7


primeira vista, o algoritmo no parece e_ciente, pois as chaves so movimentadas vrias

vezes. Entretanto, ele gasta um tempo de execuo proporcional a n log n no pior caso. Ele

no recomendado para vetores com poucos elementos por causa do tempo gasto na

construo do heap, sendo recomendado para aplicaes que no podem tolerar

eventualmente um caso desfavorvel.

Vantagens O comportamento do Heapsort sempre O(n log n), qualquer que seja a entrada.

Desvantagens O anel interno do algoritmo bastante complexo se comparado ao Quicksort.

Classificao Instvel

Performance Mdia

Complexidade Alta

Mtodos de Ordenao por Permutao

O mtodo de ordenao baseado em troca (permutao) consiste em intercalar pares de itens

que no esto em ordem at que no exista mais pares.

Bubble Sort

o mtodo mais simples em termos de implementao, porm o menos eficiente. A ideia

principal do algoritmo percorrer o vetor n-1 vezes, a cada passagem fazendo flutuar para o

inicio o menor elemento da sequncia. Seu uso no recomendado para vetores com muitos

elementos. Realiza varreduras no vetor, trocando pares adjacentes de elementos sempre que o

prximo elemento for menor que o anterior aps uma varredura, o maior elemento est

corretamente posicionado no vetor e no precisa mais ser comparado

Funcionamento

O mtodo de Bubble Sort, feito da seguinte forma, compare o primeiro elemento com o

segundo, se estiverem desordenados, ento efetue a troca de posio do menor para o maior

entre eles. Compare o segundo elemento com o terceiro e efetue a troca de posio. Porm

esse mtodo, apesar de eficaz, ele acaba, passando vrias vezes pelas mesmas posies do

vetor, no pior dos casos, executando o lao novamente (voltando ao incio do vetor e o

percorrendo novamente), por isso no recomendado para programas que precisam de

velocidade.

8


O algoritmo de ordenao bolha simples de entendimento e de fcil implementao. Est

entre os mais conhecidos e difundidos mtodos de ordenao de arranjos, porm a sua

eficincia a menor entre os mtodos de ordenao interna. Admite, contudo vrios

melhoramentos e tambm uma boa base para a construo de mtodos mais elaborados.

Vantagens Fcil Implementao Interessante para arquivos pequenos

Desvantagens O fato de o arquivo j estar ordenado no influencia em nada Ordem de complexidade quadrtica

Classificao Estvel

Performance Baixa


QuickSort

o algoritmo mais rpido que se conhece entre os de ordenao interna para uma ampla

variedade de situaes, porm a sua implementao demanda um pouco mais de pacincia e

cautela. O Algoritmo QuickSort pode ser definido mais adequadamente como um procedimento

recursivo. Baseia-se em um padro de projeto fundamental para soluo de problemas

conhecida como Diviso e Conquista. O padro pode ser descrito, de maneira geral, como

sendo composto de 3 fases:

Diviso: dividem-se os dados de entrada em dois ou mais conjuntos disjuntos (separados);

Recurso: solucionam-se os problemas associados aos subconjuntos recursivamente;

Conquista: obtm-se as solues dos subproblemas e junta-se as mesmas em uma nica soluo.

Funcionamento

Este algoritmo seleciona o valor central da lista como um separador. A partir da ele cria duas

listas: a primeira com os valores menores que o separador (para a esquerda) e outra com os

9

valores maiores (para a direita) ou iguais ao separador. A seguir a ordenao chama a si

mesma recursivamente, sempre selecionando um novo separador nas listas, e criando novas

listas menores at que estas tenham apenas um nico elemento. O algoritmo ento reposiciona

os valores das novas listas na lista original. Ao final do algoritmo uma matriz (lista) estar

ordenada.

A parte crucial do algoritmo o mtodo Partition quem tem a funo de rearranjar o vetor por

meio da escolha de um piv, de tal forma que ao final o vetor estar particionado em uma parte

esquerda com chaves menores ou iguais ao piv e outra maiores ou iguais.


O QuickSort considerado o mtodo mais eficiente e altamente recomendvel para arquivos

grandes. Quanto mais o vetor estiver desordenado, maior ser sua vantagem em relao aos

outros mtodos. A escolha correta do piv essencial para a garantia de ecincia do algoritmo.

Vantagens Extremamente eficiente Necessita apenas de uma pequena pilha como memria extra

Desvantagens Difcil implementao

Classificao Instvel

Performance Alta

Complexidade Avanada (n log n)

10

Mtodos de Ordenao por Insero

o mtodo que consiste em inserir informaes num conjunto j ordenado.

A ordenao por Insero um algoritmo simples, mas eficiente somente em vetores

pequenos, basicamente ele percorre um vetor da esquerda para a direita, e conforme avana,

vai alinhando os valores da sua esquerda.

A principal caracterstica deste mtodo consiste em ordenar o conjunto utilizando um sub-

conjunto ordenado localizado em seu inicio, e a cada novo passo, acrescentamos a este sub-

conjunto mais um elemento, at que atingimos o ltimo elemento do conjunto fazendo assim

com que ele se torne ordenado.

Insertion Sort

Insertion Sort um algoritmo elementar de ordenao. eficiente quando aplicado um vetor

com poucos elementos. Em cada passo, a partir de i = 2, o i-simo item da sequncia fonte

apanhado e transferido para a sequncia destino, sendo inserido no seu lugar apropriado.

O nmero mnimo de comparaes e movimentos ocorre quando os itens esto originalmente

em ordem, e o nmero mximo ocorre quando os itens esto originalmente na ordem reversa.

o mtodo a ser utilizado quando o arquivo est quase ordenado, alm de ser um bom

mtodo quando se deseja adicionar uns poucos itens a um arquivo ordenado, pois o custo

linear.

Funcionamento

A ordenao por Insero um algoritmo simples, mas eficiente somente em vetores

pequenos, basicamente ele percorre um vetor da esquerda para a direita, e conforme avana,

vai alinhando os valores da sua esquerda.

Este mtodo, considera-se o conjunto a ordenar como um conjunto dividido em dois sub-

conjuntos (esquerdo e direito), com o da esquerda ordenado e o da direita desordenado. Os

elementos so retirados um de cada vez do sub-conjunto da esquerda (no ordenado), e move-

se esse elemento para o sub-conjunto da esquerda, inserindo-o na posio correcta por forma

a manter o sub -conjunto da esquerda ordenado, terminando o processo quando o sub-

conjunto da direita ficar vazio.

11


Mtodo de ordenao, na qual so procurados sucessivos elementos que se encontram fora de

ordem, retira o elemento da lista e depois insere o elemento de forma ordenada. Este tipo de

ordenao em pequenas listas rpido, sendo extremamente lento para grandes listas.

O InsertSort tambm um mtodo de simples implementao, e tem a complexidade igual ao

BubbleSort . Pode ser aprimorado com o uso de sentinela e outras tcnicas de algoritmos. o

melhor mtodo para se utilizar quando os arquivos j esto quase ordenados.

12

Vantagens Fcil implementao O vetor j ordenado favorece a ordenao

Desvantagens

Nmero grande de movimentaes Ordem de complexidade quadrtica Ineficiente quando o vetor est ordenado inversamente

Classificao Estvel

Performance Baixa


Shell Sort

Este algoritmo uma extenso do mtodo Insertion Sort proposto por Donald Shell em 1959. O

algoritmo de insero troca itens adjacentes quando est procurando o ponto de insero na

sequncia destino. Se o menor item estiver na posio mais direita no vetor, ento o nmero

de comparaes e movimentaes igual a n-1 para encontrar o seu ponto de insero. O

ShellSort contorna este problema, permitindo trocas de registros distantes um do outro.

De maneira geral ele passa vrias vezes no vetor dividindo-o em vetores menores, e nestes

so aplicados o algoritmo de ordenao por insero tradicional. Dentre os programas de

ordenao interna que tem ordem de complexidade quadrtica,o ShellSort o mais eficiente.

Funcionamento

o mais eficiente algoritmo de ordenao dentre os de complexidade quadrtica (no utiliza

recursividade). um refinamento do mtodo de insero direta. O algoritmo difere do mtodo

de insero direta pelo fato de no lugar de considerar o vetor a ser ordenado como um nico

segmento, ele considera vrios segmentos sendo aplicado o mtodo de insero direta em

cada um deles. Basicamente o algoritmo passa vrias vezes pela lista dividindo o grupo maior

em menores. Nos grupos menores aplicado o mtodo da ordenao por insero.

O diferencial do ShellSort a diviso em h intervalos que ele realiza para posteriomente aplicar

o mtodo de insero. Vrias sequncias para h tm sido experimentadas. Knuth(1973)

mostrou experimentalmente que a escolha do incremento para h, mostrada a seguir difcil de

ser batida em mais de 20% dos casos em eficincia no tempo de execuo.

> 1 = 3 1 + 1

= 1 = 1

13


O ShellSort uma tima opo para arquivos de tamanho moderado, mesmo porque sua

implementao simples e requer uma quantidade de cdigo pequena.

Um problema com o shell sort ainda no resolvido a escolha dos incrementos que fornece os

melhores resultados. desejvel que ocorra o maior nmero possvel de interaes entre as

diversas cadeias, se a uma sequncia, previamente ordenada, de distncia k for em seguida

aplicada uma ordenao de distncia i, ento esta sequncia permanece ordenada de distncia

k.

14

A razo da eficincia do algoritmo ainda no conhecida. Ningum ainda foi capaz de analisar

o algoritmo. A sua anlise contm alguns problemas matemticos muito difceis. A comear

pela prpria seqncia de incrementos. O que se sabe que cada incremento no deve ser

mltiplo do anterior.

Vantagens Cdigo Simples Interessante para arquivos de tamanho moderado

Desvantagens Algoritmo no estvel Tempo de execuo sensvel ordem inicial do arquivo

Classificao Instvel

Performance Mdia


Mtodos de Ordenao por Intercalao

A intercalao o mtodo que combina dois ou mais arquivos classificados num terceiro

arquivo classificado. Pode-se usar essa tcnica para classificar um arquivo da seguinte

maneira: divida o arquivo em n sub-arquivos de tamanho 1; intercale pares de sub-arquivos

adjacentes. Tem-se ento, aproximadamente n=2 sub-arquivos de tamanho 2. Repita o

processo at restar apenas um arquivo de tamanho n.

MergeSort

outro algoritmo de ordenao do tipo dividir para conquistar. Sua idia bsica criar uma

sequncia ordenada a partir de duas outras tambm ordenadas. Para isso, ele divide a

sequncia original em pares de dados, ordena-as; depois as agrupa em sequncias de quatro

elementos, e assim por diante, at ter toda a sequncia dividida em apenas duas partes.

Os trs passos teis dos algoritmos dividir para conquistar, que se aplicam ao MergeSort so:

1. Dividir: Dividir os dados em subsequncias pequenas;

2. Conquistar: Classificar as duas metades recursivamente aplicando o mergesort;

3. Combinar: Juntar as duas metades em um nico conjunto j classificado.

15

Funcionamento

O algoritmo procede da seguinte forma:

1. criado um vetor auxiliar do tamanho do intervalo;

2. Copia os valores do intervalo para o vetor auxiliar, de forma ordenada;

3. Copia o vetor auxiliar para o intervalo correspondente ao vetor a ser ordenado.

Precisa de vetor auxiliar. Para o caso de intercalao de listas lineares, o procedimento pode

ser realizado com a mesma complexidade e sem necessidade de memria auxiliar, bastando a

manipulao de apontadores.


O Merge Sort um algoritmo de simples implementao e fcil entendimento, apesar de ter

suas desvantagens como o alto consumo de memria, devido a serie de chamadas recursivas.

Para o MergeSort no tem tanta importncia se o vetor est no melhor, mdio ou pior caso,

porque para qualquer que seja o caso ele sempre ter a complexidade de ordem n*log n.

O MergeSort independentemente em que situao se encontra o vetor, ele sempre ir dividir e

intercalar. Na prtica, difcil (seno impossvel) prever com rigor o tempo de execuo de um

algoritmo ou programa. O tempo vai depender de varias constantes, como por exemplo, o

tempo de processamento de cada computador, do algoritmo implementado. Desta maneira, ns

no vamos apresentar aqui como o calculo da anlise de complexidade do MergeSort.

16

Vantagens

Requerem um nmero menor de acessos memria. So altamente paralelizveis. Se existirem vrios processadores disponveis, a estratgia propiciar eficincia. Fcil implementao

Desvantagens

Algoritmo no estvel Utiliza memria auxiliar O(n) Na prtica mais lento que QuickSort no caso mdio

Classificao Instvel

Performance Mdia


Mtodos de Ordenao por Contagem de Tipos

Idia bsica: conta-se o nmero de vezes que cada elemento ocorre no arranjo; se h k

elementos antes dele, ele ser inserido na posio k + 1 do arranjo ordenado. Os elementos

devem estar contidos em um intervalo [min, max] do conjunto de nmeros inteiros positivos.

Usa-se um arranjo auxiliar para manter a contagem de tipos e um outro para montar o arranjo

ordenado.

Radix Sort

Esta ordenao baseia-se nos valores dos dgitos nas representaes posicionais dos nmeros

sendo ordenados.

O algoritmo Radix Sort ordena um vetor A de n nmeros inteiros com um nmero constante d

de dgitos, atravs de ordenaes parciais dgito a dgito. Esse algoritmo surgiu no contexto de

ordenao de cartes perfurados; a mquina ordenadora so era capaz de ordenar os cartes

segundo um de seus dgitos.

Poderamos ento ordenar os nmeros iniciando a ordenao a partir do dgito mais significativo

i, mas, para prosseguir assim, teramos que separar os elementos da entrada em subconjuntos

com o mesmo valor no dgito i. Podemos tambm ordenar os nmeros ordenando-os segundo

cada um de seus dgitos, comeando pelo menos significativo

Funcionamento

Executa as seguintes aes comeando pelo dgito menos significativo e terminando com o

mais significativo. Pegue cada nmero na sequncia e posicione-o em uma das dez filas,

dependendo do valor do dgito sendo processado.

17

Em seguida, restaure cada fila para a sequncia original, comeando pela fila de nmeros com

um dgito 0 e terminando com a fila de nmeros com o dgito 9.

Quando essas aes tiverem sido executadas para cada dgito, a sequncia estar ordenada.

Pressupe que as chaves de entrada possuem limite no valor e no tamanho (quantidade de

dgitos); ordena em funo dos dgitos (um de cada vez). essencial utilizar um segundo

algoritmo estvel para realizar a ordenao de cada dgito.


A complexidade do Radix Sort depende da complexidade do algoritmo estvel usado para

ordenar cada dgito dos elementos.

O melhor caso no algoritmo Radix Sort acontece quando a quantidade de dgitos d e constante

e obedecem as mesmas condies de melhor caso do Count Sort, e a ordenao e feita em

tempo linear, com complexidade O(n). Em [4] vemos a prova de tal afirmao.

Para o caso mdio, temos que a complexidade do Radix Sort e dada por ((b/r)(n+ 2r)), onde n

e a quantidade de nmeros, b e a quantidade de dgitos e r e um inteiro positivo qualquer, tal

que r b.

Esse mtodo funciona, mas requer o uso de bastante memoria adicional para a organizao,

dos grupos e sub-grupos.

18

Vantagens Muito rpido quando codificado apropriadamente

Desvantagens

Requer espao adicional A rapidez depende de como as operaes bsicas de comparao e seleo de dgitos so codificadas Se as chaves no forem do mesmo tamanho, necessrio um teste adicional para verificar, para cada chave, quando os dgitos so exauridos. menos flexvel do que outros mtodos, pois depende dos formatos das chaves; assim, muito difcil codific-lo com o propsito geral de lidar com todos os tipos de chaves.

Classificao Estvel

Performance Mdia

Complexidade Mdia

19

Anlise de Resultados

Neste tpico faremos um estudo comparativo dos algoritmos de ordenao exibidos neste

trabalho, assumindo a mesma entrada para os diferentes algoritmos. Utilizaremos quatro

padres de entrada de nmeros aleatrios 100, 1000, 10000 e 100000 posies. Com isso,

espera-se comparar o tempo de execuo e apresentar as complexidades dos algoritmos.

Apresentaremos um exemplo do cdigo utilizado em cada algoritmo e exibiremos a

performance de cada entrada de valores.

Cdigo Exemplo Selection Sort

#include #include #include #include #include #define TAM 1000 int main() { double ti,tf,tempo; // ti = tempo inicial // tf = tempo final ti = tf = tempo = 0; timeval tempo_inicio,tempo_fim; gettimeofday(&tempo_inicio,NULL); int vet[TAM], i, j, aux, Min; for(i=0; i

20

Cdigo Exemplo Hearp Sort

#include #include #include #include #include #define TAM 1000 int vetor[TAM]; // variavel global void carrega_vetor(); void mostra_vetor (char *); void heapsort(int vetor[], int n); int main() { double ti,tf,tempo; // ti = tempo inicial // tf = tempo final ti = tf = tempo = 0; timeval tempo_inicio,tempo_fim; gettimeofday(&tempo_inicio,NULL); printf("Inicializando..."); carrega_vetor(); mostra_vetor("Conjunto Original"); heapsort(vetor, TAM); mostra_vetor("\nConjunto Ordenado"); getch(); gettimeofday(&tempo_fim,NULL); tf = (double)tempo_fim.tv_usec + ((double)tempo_fim.tv_sec * (1000000.0)); ti = (double)tempo_inicio.tv_usec + ((double)tempo_inicio.tv_sec * (1000000.0)); tempo = (tf - ti) / 1000; printf("\nTempo gasto em milissegundos %.3f\n",tempo); } void carrega_vetor() { int i; for(i=0; i vetor[filho])) filho++; if (vetor[filho] > t){ vetor[pai] = vetor[filho]; pai = filho; filho = pai*2 + 1; } else break; } vetor[pai] = t; } }

21

Cdigo Exemplo Bubble Sort

#include #include #include #include #include #define TAM 1000 int vetor[TAM]; // variavel global void carrega_vetor(); void mostra_vetor (char *); void bubblesort(int [], int); int main(){ double ti,tf,tempo; // ti = tempo inicial // tf = tempo final ti = tf = tempo = 0; timeval tempo_inicio,tempo_fim; gettimeofday(&tempo_inicio,NULL); printf("Inicializando..."); carrega_vetor(); mostra_vetor("Conjunto Original"); bubblesort(vetor, TAM); mostra_vetor("\nConjunto Ordenado"); gettimeofday(&tempo_fim,NULL); tf = (double)tempo_fim.tv_usec + ((double)tempo_fim.tv_sec * (1000000.0)); ti = (double)tempo_inicio.tv_usec + ((double)tempo_inicio.tv_sec * (1000000.0)); tempo = (tf - ti) / 1000; printf("\nTempo gasto em milissegundos %.3f\n",tempo); return 0; system("pause"); } void carrega_vetor(){ int i; for(i=0; i vetor[j+1]) { int temp; temp = vetor[j]; vetor[j] = vetor [j+1]; vetor[j+1] = temp; } } } }

22

Cdigo Exemplo Quick Sort

#include #include #include #include #include #define TAM 1000 void quicksort(int *v,int esq, int dir); int main() { double ti,tf,tempo; // ti = tempo inicial // tf = tempo final ti = tf = tempo = 0; timeval tempo_inicio,tempo_fim; gettimeofday(&tempo_inicio,NULL); int vetor[TAM],i; for (i=0;i esq) { j--; } if (i

23

Cdigo Exemplo Insertion Sort

#include #include #include #include #include #define TAM 1000 int vetor[TAM]; // variavel global void carrega_vetor(); void mostra_vetor (char *); void insertionsort(int [], int); int main() { double ti,tf,tempo; // ti = tempo inicial // tf = tempo final ti = tf = tempo = 0; timeval tempo_inicio,tempo_fim; gettimeofday(&tempo_inicio,NULL); printf("Inicializando..."); carrega_vetor(); mostra_vetor("Conjunto Original"); insertionsort(vetor, TAM); mostra_vetor("\nConjunto Ordenado"); getch(); gettimeofday(&tempo_fim,NULL); tf = (double)tempo_fim.tv_usec + ((double)tempo_fim.tv_sec * (1000000.0)); ti = (double)tempo_inicio.tv_usec + ((double)tempo_inicio.tv_sec * (1000000.0)); tempo = (tf - ti) / 1000; printf("\nTempo gasto em milissegundos %.3f\n",tempo); } void carrega_vetor( ) { int i; for(i=0; i

24

Cdigo Exemplo Shell Sort

#include #include #include #include #include #define TAM 1000 int vetor[TAM]; // variavel global void carrega_vetor(); void mostra_vetor (char *); void shellsort(int [], int); int main() { double ti,tf,tempo; // ti = tempo inicial // tf = tempo final ti = tf = tempo = 0; timeval tempo_inicio,tempo_fim; gettimeofday(&tempo_inicio,NULL); printf("Inicializando..."); carrega_vetor(); mostra_vetor("Conjunto Original"); shellsort(vetor, TAM); mostra_vetor("\nConjunto Ordenado"); getch(); gettimeofday(&tempo_fim,NULL); tf = (double)tempo_fim.tv_usec + ((double)tempo_fim.tv_sec * (1000000.0)); ti = (double)tempo_inicio.tv_usec + ((double)tempo_inicio.tv_sec * (1000000.0)); tempo = (tf - ti) / 1000; printf("\nTempo gasto em milissegundos %.3f\n",tempo); } void carrega_vetor() { int i; for(i=0; i

25

Cdigo Exemplo MergeSort

#include #include #include #include #include #define TAM 1000 int vetor[TAM], temp[TAM], array_size=TAM; // variavel global void carrega_vetor(); void mostra_vetor (char *); void mergeSort(int vetor[], int temp[], int array_size); void m_sort(int vetor[], int temp[], int left, int right); void merge(int vetor[], int temp[], int left, int mid, int right); int main() { double ti,tf,tempo; // ti = tempo inicial // tf = tempo final ti = tf = tempo = 0; timeval tempo_inicio,tempo_fim; gettimeofday(&tempo_inicio,NULL); printf("Inicializando..."); carrega_vetor(); mostra_vetor("Conjunto Original"); mergeSort(vetor, temp, array_size); mostra_vetor("\nConjunto Ordenado"); getch(); gettimeofday(&tempo_fim,NULL); tf = (double)tempo_fim.tv_usec + ((double)tempo_fim.tv_sec * (1000000.0)); ti = (double)tempo_inicio.tv_usec + ((double)tempo_inicio.tv_sec * (1000000.0)); tempo = (tf - ti) / 1000; printf("\nTempo gasto em milissegundos %.3f\n",tempo); } void carrega_vetor() { int i; for(i=0; i

26

void merge(int vetor[], int temp[], int left, int mid, int right) { int i, left_end, num_elements, tmp_pos; left_end = mid - 1; tmp_pos = left; num_elements = right - left + 1; while ((left

27

Cdigo Exemplo Radix Sort

#include #include #include #include #include #define TAM 1000 int vetor[TAM]; // variavel global void carrega_vetor(); void mostra_vetor (char *); void radixsort(int vetor[], int tamanho); int main() { double ti,tf,tempo; // ti = tempo inicial // tf = tempo final ti = tf = tempo = 0; timeval tempo_inicio,tempo_fim; gettimeofday(&tempo_inicio,NULL); printf("Inicializando..."); carrega_vetor(); mostra_vetor("Conjunto Original"); radixsort(vetor, TAM); mostra_vetor("\nConjunto Ordenado"); getch(); gettimeofday(&tempo_fim,NULL); tf = (double)tempo_fim.tv_usec + ((double)tempo_fim.tv_sec * (1000000.0)); ti = (double)tempo_inicio.tv_usec + ((double)tempo_inicio.tv_sec * (1000000.0)); tempo = (tf - ti) / 1000; printf("\nTempo gasto em milissegundos %.3f\n",tempo); } void carrega_vetor() { int i; for(i=0; i 0) { int bucket[10] = { 0 }; for (i = 0; i < tamanho; i++) bucket[(vetor[i] / exp) % 10]++; for (i = 1; i < 10; i++) bucket[i] += bucket[i - 1]; for (i = tamanho - 1; i >= 0; i--) b[--bucket[(vetor[i] / exp) % 10]] = vetor[i]; for (i = 0; i < tamanho; i++) vetor[i] = b[i]; exp *= 10; } }

28

Qtde posio vetor 100 1000 10000 100000

selection sort 22088 360.246 2390.747 75046.038

hearp sort 2498.271 2984.984 4067.803 26766.905

bubble sort 23047 390.61 3381.797 133132.844

quick sort 35222 309.571 17177.05 26827.712

insertion sort 8070.337 492454.41 *N/A *N/A

shell sort 4778.376 687967.47 *N/A *N/A

merge sort 2650.2 2068.998 4453.12 27309.745

radix sort 1843.982 1843.944 5793.187 26783.902

*no foi possvel realizar o teste nestas condies.

escala numerao em milissegundos

29

Concluso

possvel identificar que o comportamento dos mtodos de ordenao varia conforme o

tamanho de entrada, onde a eficincia dos mtodos esta relacionada ao tempo de execuo,

nmero de comparaes e trocas a serem efetuadas. A fim de verificar e analisar o

comportamento, aplicou-se os mtodos em uma escala crescente de valores de entrada, em

vetores de 100 a 100000 posies, e de forma desordenada.

Os resultados mostram que em todos os casos o mtodo bolha teve um desempenho

semelhante ou pior que os demais mtodos simples, como insero direta e seleo, sendo

que para vetores pequenos a diferena de processamento relativamente baixa, porm

tratando-se de valores mais abrangentes seu tempo de execuo bem superior. Isto se deve

ao fato do bolha realizar muitas trocas ao longo de cada iterao.

Os mtodos de insero direta e seleo tambm possuem deficincias em seus algoritmos de

ordenao, apresentando comportamentos semelhantes ao bolha, embora um pouco mais

eficaz. A utilizao destes mtodos torna-se vivel apenas para vetores muito pequenos, mas

precisamente na escala de 0 a 100.

Por fim, algoritmos mais otimizados como Shellsort, QuickSort e HeadSort tm desempenhos

muito superior aos mtodos simples tanto no pior caso, como tambm de forma desordenada,

reduzindo consideravelmente seu tempo de execuo. Isto se deve ao fato destes algoritmos

utilizarem tcnicas que reduzem o vetor em anlise a cada iterao, com menor nmero de

trocas e algoritmos bem mais otimizados, alguns at utilizando recursividade como o quicksort.

30

Referencias Bibliograficas

LOPES, Arthur V Estrutura de Dados: Para a construo de software. 1.ed. Canoas: Editora

Ulbra, 1999.

OLIVEIRA, lvaro Borges de.. Mtodos de Ordenao Interna. Visual Book, So Paulo,

1.ed., 2002.

CORMEN, T. H.; LEISERSON, C. E.; RIVEST, R. L. e STEIN, C. Introduction to Algorithms,

3.ed, MIT Press, 2009.

SZWARCFITER, J. L. e MARKENZON, L. Estruturas de Dados e seus Algoritmos, LTC,

1994.

VARELLA, Irineu Gomes. Mtodos de Ordenao. So Paulo, 1996.

https://sites.google.com/site/carnevalli/estruturadedados-

m%C3%A9todosdeordena%C3%A7%C3%A3oemc

http://ee.hawaii.edu/~tep/EE160/Book/chap10/subsection2.1.2.1.html

http://en.wikipedia.org/wiki/Selection_sort

https://www.princeton.edu/~achaney/tmve/wiki100k/docs/Selection_sort.html

http://terminaldeinformacao.com/2013/05/10/ordenando-vetores-usando-linguagem-c/

http://www.arnerobotics.com.br/eletronica/metodos_pesquisa_ordenacao.htm

http://en.wikipedia.org/wiki/Shellsort

Documents

Métodos de Ordenação