Universidade Paulista

Desenvolvimento de sistema para anlise de

performance de algoritmos de ordenao de dados

Unip
2015

Desenvolvimento de sistema para anlise de performance de

algoritmos de ordenao de dados

Nome:
ra:

Jorge

c20hbc2

Eduardo

c10cfd3

Bruno

c105449

Rodrigo T.

C086hb2

UNIP

2015
Introduo

Organizao e eficincia, no mundo de hoje imprescindvel, e no poderia ser

diferente no Mundo Digital, que dobra de tamanho a cada 2 anos.
Os Algoritmos de Ordenao de Vetores tem justamente esse fim, automatizar
o processo de ordenao de dados, sejam eles quais for. No seu dia a dia o
Homem se depara com a necessidade de consultar dados ordenados, tome
como exemplo uma lista telefnica. Imagine como seria consultar o nmero de
uma pessoa se os nomes na lista no tivessem ordenados de maneira
alfabtica? Por isso no cenrio tecnolgico de hoje a ordenao de dados tao
importante.
Nesta APS mostraremos diversos algoritmos de ordenao interna , Sendo
eles:

Bubble Sort
Merge Sort
Heap Sort
Selection Sort
Insertion Sort
Quick Sort

Bubble Sort
O Bubble Sort um dos mtodos de ordenao mais simples, porm no e tao
eficiente em casos em que a quantidade de elementos e grande, tendo em
vista que ele poder no pior dos casos fazer n operaes, e no melhor dos
casos n operaes aonde n representa o nmero dos elementos.
Consiste em percorrer o vetor diversas vezes sempre flutuando o maior valor
para o topo (este processo tambm pode ser feito inversamente, jogando o
menor valor para o incio, apenas invertendo a lgica).
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.

Merge Sort
Merge Sort um mtodo de ordenao que utiliza a tcnica dividir-paraconquistar, basicamente ele divide o vetor em partes menores, ordena essas
partes menores e depois une as partes ordenadas, um dos seus problemas
dependendo da maneira que implementado, e a memria, j que ele utiliza
recursividade, criando sempre cpias do vetor para cada instancia de
recursividade.
Os trs passos teis dos algoritmos dividir-para-conquistar, que se aplicam ao
Merge Sort so:
1. Dividir: Dividir os dados em subsequncias pequenas;
Este passo realizado recursivamente, iniciando com a diviso do vetor
de n elementos em duas metades, cada uma das metades novamente
dividida em duas novas metades e assim por diante, at que no seja

mais possvel a diviso (ou seja, sobre n vetores com um elemento

cada).
2. Conquistar: Classificar as duas metades recursivamente aplicando o
merge sort;
3. Combinar: Juntar as duas metades em um nico conjunto j classificado.
Para completar a ordenao do vetor original de n elementos, faz-se o
merge ou a fuso dos sub-vetores j ordenados.

Heap Sort
O Heap Sort Cria uma estrutura de arvore e utiliza uma derivao do mtodo
de seleo em conjunto.
Para uma ordenao crescente, deve ser construdo um heap mximo (o maior
elemento fica na raiz). Para uma ordenao decrescente, deve ser construdo
um heap mnimo (o menor elemento fica na raiz).
Assim os elementos so inseridos e depois retirados na ordem escolhida de
acordo com a construo da estrutura, este mtodo de ordenao e
consideravelmente rpido, e no ocupa muita memria, mas no e considerado
um mtodo de ordenao estvel pois altera as chaves primarias.

Selection Sort
Este algoritmo baseado em se passar sempre o menor valor do vetor para a
primeira posio (ou o maior dependendo da ordem requerida), depois o
segundo menor valor para a segunda posio e assim sucessivamente, at os
ltimos dois elementos.
Neste algoritmo de ordenao escolhido um nmero a partir do primeiro, este

nmero escolhido comparado com os nmeros a partir da sua direita, quando

encontrado um nmero menor, o nmero escolhido ocupa a posio do menor
nmero encontrado. Este nmero encontrado ser o prximo nmero
escolhido, caso no for encontrado nenhum nmero menor que este escolhido,
ele colocado na posio do primeiro nmero escolhido, e o prximo nmero
sua direita vai ser o escolhido para fazer as comparaes. repetido esse
processo at que a lista esteja ordenada

Quick Sort

O Quicksort o algoritmo mais eficiente na ordenao por comparao. Nele

se escolhe um elemento chamado de piv, a partir disto organizada a lista
para que todos os nmeros anteriores a ele sejam menores que ele, e todos os
nmeros posteriores a ele sejam maiores que ele. Ao final desse processo o
nmero piv j est em sua posio final. Os dois grupos desordenados
recursivamente sofreram o mesmo processo at que a lista esteja ordenada.

Sistema Para Calculo de Performance

Fizemos um sistema simples de calculo de performance, que consiste na
ordenao de 10 mil elementos, 50 mil elementos ou 100 mil elementos.
Apos o usurio escolher a opo, dado o processamento da maquina, com
todos os algoritmos aqui citados, em seguida e mostrado para o usurio o
tempo que cada algoritmo levou para ordenar o vetor.
Segue os Codigos

Main
import
javax.swing.JOptionPane;
import java.util.*;
public class MainClass {
public static void main(String args[])
{
try
{
int continua=0;
while(continua==0)
{
long marcatempo, diftempo; int opcao, tam=0;
opcao=Integer.parseInt(JOptionPane.showInputDialog("Digite
qual das opes deseja
testar"

+ "\n1-Ordenao 10.000 elementos"

+ "\n2-Ordenao 50.000 elementos"
+ "\n3-Ordenao 100.000 elementos"));
switch(opcao)
{
case 1:
tam=10000;
break;
case 2:
tam=50000;
break;
case 3:
tam=100000;
break;
case 4:
break;
default:
break;
}
String resultado="";
long tempo[] = new long[6];

int mainvetor[]= new int[tam];

int secvetor[] = new int[tam];
InsertionSort insertion = new InsertionSort();
HeapSort heap = new HeapSort();
MergeSort merge = new MergeSort();
//QuickSort quick = new QuickSort();
BubbleSort bubble = new BubbleSort();
SelectionSort selection = new SelectionSort();
for(int i=0;i<mainvetor.length;i++)
{
mainvetor[i]= (int)Math.random()*100;
}
for(int cont=0;cont<mainvetor.length;cont++)
{
secvetor[cont]=mainvetor[cont];
}
marcatempo=System.currentTimeMillis();
bubble.bubbleSort(secvetor, tam);
diftempo =System.currentTimeMillis()-marcatempo;
tempo[0]=diftempo*1000000;
for(int cont=0;cont<mainvetor.length;cont++)
{
secvetor[cont]=mainvetor[cont];
} marcatempo=System.nanoTime();
selection.selectionSort(secvetor, tam);
diftempo = System.nanoTime()-marcatempo;
tempo[1]=diftempo;
marcatempo=System.nanoTime();
for(int cont=0;cont<mainvetor.length;cont++)
{
int i=0; secvetor[i]=mainvetor[cont];
insertion.insertionSort(secvetor, tam);
}
diftempo = System.nanoTime()-marcatempo;
tempo[2]=diftempo;
for(int cont=0;cont<mainvetor.length;cont++)
{
secvetor[cont]=mainvetor[cont];
}
marcatempo=System.nanoTime();
merge.mergeSort(secvetor, 0, tam-1);
diftempo = System.nanoTime()-marcatempo;
tempo[3]=diftempo;
/*for(int cont=0;cont<mainvetor.length;cont++)
{
secvetor[cont]=mainvetor[cont];
}

marcatempo=System.currentTimeMillis();
quick.quickSort(secvetor,0, tam-1);
diftempo = System.currentTimeMillis()-marcatempo;
tempo[4]=diftempo;*/

for(int cont=0;cont<mainvetor.length;cont++)
{
secvetor[cont]=mainvetor[cont];
}
marcatempo=System.nanoTime();
heap.heapSort(secvetor, tam);
diftempo = System.nanoTime()-marcatempo;
tempo[5]=diftempo;
String
metodo[]={"Bolha","Seleo","Insero","Intercalao","partio","Monte"};
for(int i=0;i<6;i++)
{
resultado += metodo[i]+": "+tempo[i]+"ns"+"\n";
}
JOptionPane.showMessageDialog(null, "O tempo de cada
mtodo em
"+tam+"
elementos\n"+resultado,"Mensagem",JOptionPane.INFORMATION_MESSAGE);
continua=JOptionPane.showConfirmDialog(null,"Deseja
continuar?","Pergunta",JOptionPane.YES_NO_OPTION,JOptionPane.QUESTION_M
ESSAGE);
}
}
catch(Exception e)
{
JOptionPane.showMessageDialog(null,"Erro, "+
e.toString()+","+e.getMessage(),"Erro", JOptionPane.ERROR_MESSAGE);
e.printStackTrace();
}
}
}

Bubble Sort
Bubble Sort

Heap Sort

Insertion Sor

Merge Sort

Quick Sor

Selection Sort

Anlise de Performance
Depois de realizar testes de performance o grupo pode concluir que o processo
de execuo e comparao mais eficiente foi o ShellSort, este mtodo o mais
agil entre os mtodos utilizados neste trabalho.
Consideraes Finais
Este trabalho teve como objetivo a aprendizagem e o comprendimento dos
algoritmos de ordenao, neste trabalho formaram utilizados diversos tipos de
ordenao, mas foram testadas.
Este grupo testou a maior parte deste mtodo de ordenao e conclumos que
o insertion short e o mtodo mais adequado para uma ordenao.

Universidade Paulista
Tempo de execuo
O mtodo que levou menos tempo real para executar recebeu o valor 1 e os
outros receberam valores relativos.
Elementos em ordem aleatria:

Nmero de comparaes

Tempo de execuo
-Elementos em ordem crescente