Você está na página 1de 30

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
Avaliao do Algoritmo
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




Avaliao do Algoritmo
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
Complexidade Simples

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.
Avaliao do Algoritmo
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

Avaliao do Algoritmo
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
Complexidade Simples

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

Avaliao do Algoritmo
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
Complexidade Simples

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.
Avaliao do Algoritmo
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
Complexidade Simples

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.

Avaliao do Algoritmo
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<stdlib.h>
#include<stdio.h>
#include<conio.h>
#include <sys/time.h>
#include <stdio.h>
#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 <TAM; i++) {
vet[i] = rand();
}
for(i=0;i<TAM-1;i++) {
Min = i;
for(j=i+1;j<TAM;j++) {
if(vet[j] < vet[Min]) {
aux = vet[Min];
vet[Min] = vet[j];
vet[j] = aux;
} } }
printf("\nImprimindo vetor");
for(i=0;i<TAM;i++) {
printf("\nvet[%d] = %d", i, vet[i]);
}
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);
system("pause");
}






20
Cdigo Exemplo Hearp Sort
#include<stdlib.h>
#include<stdio.h>
#include<conio.h>
#include <sys/time.h>
#include <stdio.h>
#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<TAM; i++) {
vetor[i] = rand();
} }void mostra_vetor(char *texto){
int i;
printf("\n\n %s \n\n", texto);
for(i=0;i<TAM;i++) {
printf(" %d ", vetor[i]);
} }
void heapsort(int vetor[], int n) {
int i = n/2, pai, filho, t;
for (;;) {
if (i > 0){
i--;
t = vetor[i];
}else {
n--;
if (n == 0)return;
t = vetor[n];
vetor[n] = vetor[0]; }
pai = i;
filho = i*2;
while (filho < n){
if ((filho + 1 < n) && (vetor[filho + 1] > 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<stdlib.h>
#include<stdio.h>
#include<conio.h>
#include <sys/time.h>
#include <stdio.h>
#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<TAM; i++){
vetor[i] = rand();
}
}
void mostra_vetor(char *texto){
int i;
printf("\n\n %s \n\n", texto);
for(i=0;i<TAM;i++){
printf(" %d ", vetor[i]);
}
}
void bubblesort(int vetor[], int tamanho){
int i, j, aux=0;
for (i=tamanho-1; i > 0; i--){
for(j=0; j < i; j++) {
if(vetor[j] > vetor[j+1]) {
int temp;
temp = vetor[j];
vetor[j] = vetor [j+1];
vetor[j+1] = temp;
}
}
}
}
22
Cdigo Exemplo Quick Sort
#include<stdlib.h>
#include<stdio.h>
#include<conio.h>
#include <sys/time.h>
#include <stdio.h>
#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<TAM;i++) {
vetor[i] = rand();
}
quicksort(vetor, 0, TAM-1);
printf("\nVetor Classificado\n");
for (i=0;i<TAM;i++) {
printf("vetor[%d] = %d\n", i, vetor[i]);
}

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);

system("pause"); }

void quicksort(int *v,int esq, int dir) {
int i, j, pivo, aux;
i=esq;
j=dir;
pivo=v[(i+j)/2];
//Particionando o Vetor
do {
while (v[i] < pivo && i < dir) { i++; }
while (v[j] > pivo && j > esq) { j--; }
if (i <= j) {
aux=v[i];
v[i]=v[j];
v[j]=aux;
i++;
j--;
}
} while (i<=j);
if (esq < j) quicksort(v,esq, j);
if (dir > i) quicksort(v,i,dir);
}



23
Cdigo Exemplo Insertion Sort
#include<stdlib.h>
#include<stdio.h>
#include<conio.h>
#include <sys/time.h>
#include <stdio.h>
#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<TAM; i++) {
vetor[i] = rand();
} }
void mostra_vetor(char *texto) {
int i;
printf("\n\n %s \n\n", texto);

for(i=0;i<TAM;i++) {
printf(" %d ", vetor[i]);
}
}
void insertionsort(int vetor[], int tamanho) {
int i, j, elem;
for (i=1; i< tamanho; i++) {
elem = vetor[i];
for (j=i-1; (j>=0) &&(elem<vetor[j]); j--) {
vetor[j+1]=vetor[j];
}
vetor[j+1] = elem;
mostra_vetor("\n passo...");
}
}





24
Cdigo Exemplo Shell Sort
#include<stdlib.h>
#include<stdio.h>
#include<conio.h>
#include <sys/time.h>
#include <stdio.h>
#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<TAM; i++) {
vetor[i] = rand();
} }void mostra_vetor(char *texto){
int i;
printf("\n\n %s \n\n", texto);
for(i=0;i<TAM;i++) {
printf(" %d ", vetor[i]);
}
}
void shellsort(int vetor[], int tamanho) {
int elem, i, j, gap, k;
int a[5] = {9, 5, 3, 2, 1};
for (k=0;k<5;k++) {
gap=a[k];
for (i=gap; i< tamanho; i++) {
elem = vetor[i];
for (j=i-gap; (j>=0) &&(elem<vetor[j]); j=j-gap) {
vetor[j+gap]=vetor[j];
}
vetor[j+gap] = elem;
mostra_vetor("\n passo...");
}
}
}







25
Cdigo Exemplo MergeSort
#include<stdlib.h>
#include<stdio.h>
#include<conio.h>
#include <sys/time.h>
#include <stdio.h>
#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<TAM; i++) {
vetor[i] = rand();
} }void mostra_vetor(char *texto){
int i;
printf("\n\n %s \n\n", texto);
for(i=0;i<TAM;i++) {
printf(" %d ", vetor[i]);
}
}

void mergeSort(int vetor[], int temp[], int array_size)
{
m_sort(vetor, temp, 0, array_size - 1);
}

void m_sort(int vetor[], int temp[], int left, int right)
{
int mid;

if (right > left)
{
mid = (right + left) / 2;
m_sort(vetor, temp, left, mid);
m_sort(vetor, temp, mid+1, right);

merge(vetor, temp, left, mid+1, right);
}
}
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 <= left_end) && (mid <= right))
{
if (vetor[left] <= vetor[mid])
{
temp[tmp_pos] = vetor[left];
tmp_pos = tmp_pos + 1;
left = left +1;
}
else
{
temp[tmp_pos] = vetor[mid];
tmp_pos = tmp_pos + 1;
mid = mid + 1;
}
}

while (left <= left_end)
{
temp[tmp_pos] = vetor[left];
left = left + 1;
tmp_pos = tmp_pos + 1;
}
while (mid <= right)
{
temp[tmp_pos] = vetor[mid];
mid = mid + 1;
tmp_pos = tmp_pos + 1;
}

for (i=0; i <= num_elements; i++)
{
vetor[right] = temp[right];
right = right - 1;
}
}






















27
Cdigo Exemplo Radix Sort
#include<stdlib.h>
#include<stdio.h>
#include<conio.h>
#include <sys/time.h>
#include <stdio.h>
#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<TAM; i++) {
vetor[i] = rand();
} }void mostra_vetor(char *texto){
int i;
printf("\n\n %s \n\n", texto);
for(i=0;i<TAM;i++) {
printf(" %d ", vetor[i]);
} }
void radixsort(int vetor[], int tamanho) {
int i;
int b[tamanho];
int maior = vetor[0];
int exp = 1;

for (i = 0; i < tamanho; i++) {
if (vetor[i] > maior)
maior = vetor[i];
}
while (maior/exp > 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