Você está na página 1de 19

Universidade Paulista

Desenvolvimento de sistema para anlise de


performance de algoritmos de ordenao de dados

Unip
2015

Universidade Paulista

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

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 Sort

Merge Sort

Quick Sort

Selection Sort

Fichas da APS