Algoritimos de Ordenação

CINCIA DA COMPUTAO
Desenvolvimento de sistema para anlise de

performance de algoritmos de ordenao de
dados
ndice
Introduo .......................................................................................................... 4
Referencial Terico ............................................................................................ 7
Desenvolvimento .............................................................................................. 10
Resultados e Discusso ................................................................................... 22
Consideraes Finais ....................................................................................... 30
Cdigo Fonte .................................................................................................... 32
Referncias Bibliogrficas ................................................................................ 64
Introduo
Bubble sort
O bubble sort, ou ordenao por flutuao (literalmente "por bolha"), um
algoritmo de ordenao dos mais simples. A ideia percorrer o vector diversas
vezes, a cada passagem fazendo flutuar para o topo o maior elemento da
sequncia. Essa movimentao lembra a forma como as bolhas em um tanque
de gua procuram seu prprio nvel, e disso vem o nome do algoritmo.
O vetor analisado comparando-se pares de chaves, a mais leve sobe,
a mais pesada desce, caso j estejam na posio correta, o prximo par
analisado.
No melhor caso, o algoritmo executa n operaes relevantes, onde n
representa o nmero de elementos do vector. No pior caso, so feitas n2
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.
Quicksort
O algoritmo Quicksort um mtodo de ordenao muito rpido e eficiente,
inventado por C.A.R. Hoare em 1960 e publicado em 1962 aps uma srie de
refinamentos. O Quicksort um algoritmo de ordenao por comparao no-
estvel.
Provavelmente o mais eficiente para ordenao interna, baseado no
paradigma Dividir-e-Conquistar.
O Quicksort adota a estratgia de diviso e conquista. A estratgia
consiste em rearranjar as chaves de modo que as chaves "menores" precedam
as chaves "maiores". Em seguida o Quicksort ordena as duas sublistas de
chaves menores e maiores recursivamente at que a lista completa se encontre
ordenada.
Complexidade de tempo: (n lg2 n) no melhor caso e caso mdio e (n2)
no pior caso.
Complexidade de espao: (lg2 n) no melhor caso e no caso mdio e (lg2
n) no pior caso. R. Sedgewick desenvolveu uma verso do Quicksort com
partio recurso de cauda que tem complexidade (n2) no pior caso.
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.
Pode ser feita uma analogia com a organizao de cartas de baralho na
mo, cartas so recebidas e colocadas na mo aleatoriamente, durante a
organizao, cada carta colocada no seu lugar certo, uma por vez, deslocando
as demais.
Compara-se os pares de chaves, cada chave colocada na posio
correta para isso, outras so movidas. Caso j esteja na posio certa, passa-
se ao prximo par.
Menor nmero de trocas e comparaes entre os algoritmos de
ordenao O(n) quando o vetor est ordenado. Pior caso O(n)
Merge Sort
O merge sort, ou ordenao por intercalao, um exemplo de algoritmo
de ordenao do tipo dividir-para-conquistar.
Sua ideia bsica consiste em dividir (o problema em vrios subproblemas
e resolver esses subproblemas atravs da recursividade) e conquistar (aps
todos os subproblemas terem sido resolvidos ocorre a conquista que a unio
das resolues dos subproblemas). Como o algoritmo do Merge Sort usa a
recursividade em alguns problemas esta tcnica no muito eficiente devido ao
alto consumo de memria e tempo de execuo.
Baseado em dois procedimentos:
MERGE: Cria dois subvetores, cada um correspondente a uma
metade do vetor original, depois intercala os menores valores,
copiando-os de volta ao vetor original;
MERGE_SORT: Divide o problema original em subproblemas, e usa o
procedimento anterior para resolv-los.
Bucket Sort
Bucket sort, ou bin sort, um algoritmo de ordenao que funciona
dividindo um vetor em um nmero finito de recipientes. Pressupe que a entrada
consiste em nmeros inteiros distribudos uniformemente sobre um intervalo, ou
seja, que h um limite nos valores das chaves. O intervalo ento dividido em n
subintervalos de tamanhos iguais, os chamados buckets (baldes), cada chave
vai para o balde correspondente sua faixa de valor. Considerando a
uniformidade da distribuio, no esperamos muitas chaves em um mesmo
balde. Cada balde posteriormente ordenado, isoladamente dos demais.
Referencial Terico
Bubble sort
O mtodo mais simples. Suponha chaves em um vetor vertical A. Valores
baixos so leves e valores altos so pesados. Como bolhas, os valores leves
sobem no vetor um por vez, ao passo que os pesados descem.
Operao Troca(A[i], A[j]): os elementos das posies i e j trocam de
posio.
O vetor analisado comparando-se pares de chaves, a mais leve sobe,
a mais pesada desce, caso j estejam na posio correta, o prximo par
analisado.
Caractersticas:
Ordenao: Interna.
Complexidade: O(n2).
Quantidade de dados: Poucos.
Especificidades: Complexidade fixa e cdigo compacto.
Estabilidade: Sim.
Adaptabilidade: No. A implementao clssica realiza a mesma
quantidade de operaes mesmo se as chaves j estiverem ordenadas.
Quick sort
o algoritmo de ordenao interna mais rpido que se conhece para uma

ampla variedade de situaes. Um dos mais utilizado.
Provavelmente o mais eficiente para ordenao interna, baseado no
paradigma Dividir-e-Conquistar, divide o problema original em problemas
menores, semelhantes, procedimento recursivo, complexidade varia com o caso.
Trs passos bsicos:
1. Dividir: Escolha uma chave piv e divida o vetor em dois subvetores
(possivelmente vazios) tal que as chaves do subvetor esquerda
sejam menores que a chave piv, que por sua vez menor que as
chaves do subvetor direita.
2. Conquistar: Ordene os subvetores recursivamente, dividindo-os
tambm.
3. Combinar: Uma vez que todos os subvetores estejam ordenados,
o vetor original tambm estar.
A parte mais delicada do mtodo o processo de partio.
O vetor A[Esq..Dir] rearranjado por meio da escolha arbitrria de um
piv x.
O vetor A particionado em duas partes:
A parte esquerda com chaves menores ou iguais a x. A parte direita com
chaves maiores ou iguais a x.
Algoritmo para o particionamento:
Escolha arbitrariamente um piv x.
Percorra o vetor a partir da esquerda at que A[i] x.
Percorra o vetor a partir da direita at que A[j] x.
Troque A[i] com A[j].
Continue este processo at os apontadores i e j se cruzarem.
Ao final, o vetor A[Esq..Dir] est particionado de tal forma que:
Os itens em A[Esq], A[Esq + 1], ..., A[j] so menores ou iguais a x;
Os itens em A[i], A[i + 1], ..., A[Dir] so maiores ou iguais a x.
O piv x escolhido como sendo A[(i + j) / 2]. Como inicialmente i = 1 e j
= 6, ento x = A[3] = D. Ao final do processo de partio i e j se cruzam em i = 3
e j = 2.
Seja C(n) a funo que conta o nmero de comparaes.
Pior caso: C(n) = O(n2). O pior caso ocorre quando, sistematicamente, o
piv escolhido como sendo um dos extremos de um arquivo j ordenado. Isto
faz com que o procedimento Ordena seja chamado recursivamente n vezes,
eliminando apenas um item em cada chamada.
No melhor caso: C(n) = 2C(n/2) + n = O (n log n). Esta situao ocorre
quando cada partio divide o arquivo em duas partes iguais.
Caso mdio de acordo com Sedgewick e Flajolet (1996, p. 17): C(n)
1,386n log n 0,846n. Isso significa que em mdia o tempo de execuo do
Quicksort O(n log n).
Vantagens:
extremamente eficiente para ordenar arquivos de dados.
Necessita de apenas uma pequena pilha como memria auxiliar.
Requer cerca de n log n comparaes em mdia para ordenar n
itens.
Desvantagens:
Tem um pior caso O(n2) comparaes.
Sua implementao muito delicada e difcil:
Um pequeno engano pode levar a efeitos inesperados para
algumas entradas de dados.
O mtodo no estvel.
Merge sort
Baseado no paradigma Dividir-e-Conquistar, divide o problema original
em problemas menores semelhantes. Resolve os problemas menores mais
fceis, combina os problemas menores para formar a soluo para o problema
original. mais fcil ordenar chaves parcialmente ordenadas. um algoritmo
recursivo.
Baseado em dois procedimentos Merge e Merge_Sort.
Merge
Cria dois subvetores, cada um correspondente a uma metade do vetor original,
depois intercala os menores valores, copiando-os de volta ao vetor original. Para
que funcione, o vetor original deve ter subvetores ordenados. Para isso, aplica-
se recursivamente o algoritmo.
Merge_Sort
Divide o problema original em subproblemas, e usa o procedimento
anterior para resolv-los. Divide o vetor ao meio recursivamente at que no seja
mais possvel subvetor com apenas uma chave.
Na volta das chamadas recursivas, combina e ordena os ltimos 2
subvetores. Na primeira vez, dois subvetores de apenas uma chave. Os
subvetores vo aumentando de tamanho, at formar o vetor original.
Caractersticas:
Ordenao: Interna/Externa.
Complexidade: 0(n log n).
Quantidade de dados: Muitos.
Alto consumo de memria, devido s vrias chamadas recursivas.
Estabilidade: Sim.
Adaptabilidade: No.
Desenvolvimento
Nesta tela inicial do sistema temos a opo de criar um vetor. Temos a
opo de se criar um vetor atravs de um arquivo de texto, para isso ser
necessrio mover o arquivo para raiz do sistema, ou seja, C: tambm ser
necessrio alterar o nome para nmeros.txt. Neste exemplo estamos criando um
vetor de 500 posies.
Podemos escolher a opo de obter os dados:
Obteno de dados Aleatrios para ordenao
{17, 02, 12, 18, 04, 09, 16, 382, 6443, 4545, 1824, 4155, 2748, 912, 4130,
2798, 533, 761, 2134, 4190, 4914, 5008....... N}
Obteno de dados semi ordenados:
{ 0, 13, 22, 35, 36, 48, 50, 64, 70, 77, 109, 115, 167, 178, 186, 202,
207.....N}
Mtodo Bubble sort
Processamento
O algoritmo Bubble Sort percorre todo o vetor diversas vezes, por isso,
no recomendado o uso dele para aplicaes que requerem velocidade ou
trabalhem com uma grande quantidade de dados.
O algoritmo inicia comparando a primeira posio do vetor com a segunda
posio do vetor.
Como elemento 17 maior que o elemento 2 feito a troca de posio e
reordena-se o vetor. E assim feito ate o fim do vetor. Com isso o primeiro maior
valor fica no final do vetor.
Na segunda interao o 2 menor que o elemento 12, no h troca de
posio. Na prxima iterao, compara-se a Terceira posio do vetor, que tem
o elemento 12 comparando-o com a quarta posio do vetor, que tem o elemento
18.
Esse processo vai se repetir at que o vetor esteja ordenado. Na prxima
iterao, o segundo maior valor ser ordenado para penltima posio do vetor.
Essa ordenao lembra como as bolhas num tanque de gua procuram seu
prprio nvel, e disso vem o nome do algoritmo, Bubble Sort.
O mtodo ilustrado
Mtodo MergeSort
Processamento
Dividir os dados em subseqncias pequenas;

Conquistar, classificar as duas metades antes divididas e, recursivamente
ir aplicando o Merge Sort;
Combinar, juntar as duas metades em um nico conjunto j classificado;
Mtodo Quicksort (Ordenao Rpida)
Processamento
Escolher arbitrariamente um elemento do vetor (escolher uma estratgia
- normalmente o meio) e coloc-lo em uma varivel auxiliar X;
Inicializar dois ponteiros I e J (I = 1 e J = n);
Percorrer o vetor a partir da esquerda at que se encontre um V[I] >= X
(incrementando o valor de I);
Percorrer o vetor a partir da direita at que se encontre um V[J] <= X
(decrementando o valor de J);
Trocar os elementos V[I] e V[J] (esto fora de lugar) e fazer: I = I + 1 e J =
J - 1;
Continuar esse processo at que I e J se cruzem em algum ponto do vetor;
Aps obtidos os dois segmentos do vetor atravs do processo de partio, cada
um ordenado recursivamente
Listagem dos valores aleatrios depois da ordenao:
{2, 4, 6, 9, 12, 16, 17, 18, 174, 184, 192, 194, 195, 196, 206, 209, 216, 241,
248, 254, 261.....N}
Listagem dos valores semi ordenados depois da
ordenao:
{0, 13, 22, 35, 36, 48, 50, 59, 60, 64, 66, 70, 77, 80, 109, 115....N}
Comparaes entre os mtodos
Tempo gasto na ordenao de vetores com 500, 1000, 10000, 30000
elementos, organizados de forma aleatria (17, 02, 12, 18, 04, 09, 16, 382, 6443, 4545,
1824, 4155, 2748...N) e em ordem semi-ordenada ( 13, 22, 35, 36, 48, 50, 64, 70, 77,
109...N).
Ordem aleatria
Tempo (ms)
Elementos 500 1000 10000 30000
Bubble 4.0 20.0 137.0 1054.0
Sort
Merge Sort 1.0 2.0 5.0 13.0
Quick Sort 1.0 2.0 19.0 1.0
Tempo 0.0 4.0 13.0 15.0

Gasto
Ordem Semi Ordenada

Tempo (ms)
Elementos 500 1000 10000 30000
Bubble 9.0 22.0 132.0 939.0

Sort
Merge 3.0 0.0 1.0 5.0
Sort
Quick 1.0 2.0 7.0 3.0
Sort
Tempo 1.0 2.0 21.0 31
Gasto
Concluso
Com base nos testes realizados foram obtidas as seguintes concluses:
Bubble sort
Para listas j ordenadas em ordem crescente o nico algoritmo que no
realiza movimentaes, mas em compensao o que tem o maior tempo e o maior
nmero de comparaes. No s em listas j ordenadas, mas em todos os casos o
bubble sort se mostrou um algoritmo ineficiente.
Quick Sort
O quick sort certamente o algoritmo mais eficiente em listas totalmente
desordenadas, ele se torna muito eficiente em relao aos outros no quesito de tempo.
Merge Sort
Quando utiliza-se muitos dados, o merge sort no aconselhado devido aos
inmeros clculos realizados atravs da recurso pelo processador e tambm aloca
o dobro de memria por usar um array auxiliar. Isto pode acarretar em mais tempo de
execuo onde outros mtodos podem ser mais eficientes.
Resultados e Discusso
Foram testados os trs seguintes Mtodos: BubbleSort (Bolha), QuickSort e

MergeSort.
Para cada mtodo foi testado com um tamanho diferente de vetor (100, 1.000,
10.000, 100.000) elementos e para cada tamanho de vetor com um tipo diferente de
ordenao dos elementos.
(Ordenado Crescente, Ordenado Decrescente, Ordenado Aleatrio e
parcialmente Ordenado (90% Ordenado).
Para o tipo Aleatrio o teste foi realizado com 10 vetores diferentes, e assim o
resultado aqui apresentado a mdia dos valores.
Consideraes Finais
O trabalho pode nos proporcionar uma mais clara compreenso dos vrios
cenrios, que podem ocorrer quando nos deparamos com uma situao em que
precisamos organizar nossos dados.
Pelos testes realizados, conclui-se que a escolha de um algoritmo de
ordenao depende do tipo de vetor e tamanho a ser ordenado.
Conclui-se tambm que mtodos eficientes, demandam uma implementao
mais cautelosa do cdigo, pois so detalhes que definem a qualidade da operao de
ordenao.
Ficou mais claro as vantagens e desvantagens de cada tamanho de vetor e em
cada cenrio diferente, como podem ser vistas nas observaes abaixo:
BubbleSort
Apresentou-se como o pior mtodo de ordenao.O BubbleSort um mtodo

de simples implementao, 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.
Algoritmo Estvel.
Desvantagens
O fato de o arquivo j estar ordenado no ajuda em nada.
Ordem de complexidade quadrtica.
QuickSort
Obteve o melhor resultado na maioria dos testes. Teve um maior desempenho

nos arquivos aleatrios. Sua eficincia foi identificada apenas nos grandes arquivos.
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 do elemento do meio do arranjo melhora o desempenho quando o
arquivo est total ou parcialmente ordenado.
O pior caso tem uma probabilidade muito pequena de ocorrer quando os
elementos forem aleatrios.
Geralmente se usa a mediana de uma amostra de trs elementos para evitar o
pior caso.
Vantagens
Extremamente Eficiente
Necessita apenas de uma pequena pilha como memria extra
Complexidade n log n
Desvantagens
Tem um pior caso de O(n2)
Implementao difcil
No estvel
MergeSort
Apresentou os piores resultados entre os algoritmos de ordenao eficientes.

Em todos testes com 100 elementos apresentou um tempo de execuo maior que os
algoritmos O(n2).
outro algoritmo de ordenao do tipo dividir para conquistar. Sua ideia 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.
Cdigo Fonte
BubbleSort.java
public class BubbleSort{
long inicio, fim, total;
public int[] ordena(int[] vetor){

int[] ord = new int[vetor.length];
int aux = 0;
inicio();
//inicio ordenacao
for (int i = 0; i < vetor.length; i++)
for (int j = 0; j < vetor.length; j++) {
if (vetor[i] < vetor[j]) {
aux = vetor[i];
vetor[i] = vetor[j];
vetor[j] = aux;
}
}
//fim ordenacao
fim();
total();
return vetor;
}
public long getTotal(){

return total;
}
private void inicio(){

this.inicio = System.currentTimeMillis();
}
private void fim(){

this.fim = System.currentTimeMillis();
}
private void total(){

this.total = this.fim - this.inicio;
}
}
MergeSort.java
public class MergeSort {
private int[] array;
private int[] tempMergArr;
private int length;
public void sort(int inputArr[]) {

this.array = inputArr;
this.length = inputArr.length;
this.tempMergArr = new int[length];
doMergeSort(0, length - 1);
}
private void doMergeSort(int lowerIndex, int higherIndex) {
if (lowerIndex < higherIndex) {

int middle = lowerIndex + (higherIndex - lowerIndex) / 2;
// Below step sorts the left side of the array
doMergeSort(lowerIndex, middle);
// Below step sorts the right side of the array
doMergeSort(middle + 1, higherIndex);
// Now merge both sides
mergeParts(lowerIndex, middle, higherIndex);
}
}
private void mergeParts(int lowerIndex, int middle, int higherIndex) {
for (int i = lowerIndex; i <= higherIndex; i++) {

tempMergArr[i] = array[i];
}
int i = lowerIndex;
int j = middle + 1;
int k = lowerIndex;
while (i <= middle && j <= higherIndex) {
if (tempMergArr[i] <= tempMergArr[j]) {
array[k] = tempMergArr[i];
i++;
} else {
array[k] = tempMergArr[j];
j++;
}
k++;
}
while (i <= middle) {
array[k] = tempMergArr[i];
k++;
i++;
}
public int[] getArray(){

return array;
}

return total;
}
public void inicio(){
}
public void fim(){

}
public void total(){

}
}
QuickSort.java
import javax.swing.JOptionPane;
public class QuickSort {

int arr[];
public int partition(int[] arr, int left, int right)

{
int i = left, j = right;
int tmp;
int pivot = arr[(left + right) / 2];
while (i <= j) {
while (arr[i] < pivot)
i++;
while (arr[j] > pivot)
j--;
if (i <= j) {
tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
i++;
j--;
}
};
return i;
}
public int[] quickSort(int[] arr, int left, int right) {
int index = partition(arr, left, right);

if (left < index - 1)
quickSort(arr, left, index - 1);
if (index < right)
quickSort(arr, index, right);
return arr;
}

return total;
}
public void inicio(){

}
public void fim(){

}
public void total(){

}
public int[] getDecrescente(int[] arr, int left, int right){

int[] aux = new int[arr.length];
for (int i = left; i < arr.length; i++)
aux[i] = arr[right - i];
return aux;
}
}
Tela.java
import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.EventQueue;
import java.awt.Font;
import java.awt.List;
import java.awt.Toolkit;
import javax.swing.GroupLayout;
import javax.swing.GroupLayout.Alignment;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JTextField;
import javax.swing.LayoutStyle.ComponentPlacement;
import javax.swing.SwingConstants;
import javax.swing.UIManager;
import javax.swing.border.EmptyBorder;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
import java.util.Date;
import java.util.Random;
import javax.swing.JList;
import javax.swing.JTextArea;
import java.awt.Color;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.awt.event.WindowStateListener;
import java.awt.Point;
import java.awt.Window.Type;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import javax.swing.JTextPane;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
public class Tela extends JFrame {
private JPanel contentPane;

private JTextField txtTamVetor;
private JLabel tituloEsquerda, tempo, resultado, labelBubble, labelQuick,
labelMerge, seg, segs, segss, tempoGerar;
private JButton btTeclado, btAuto, btArquivo, btVoltar, btOrdDec;
private JPanel painelDados, painelMetodos;
private JTextArea txtAleatorio, txtBubble, txtQuick, txtMerge;
private int tamanho = 0, contador = 0, helpArq = -1; // salva o tamanho
do vetor
private int[] aleatorio, aux, ordenadoBubble, ordenadoQuick,
ordenadoMerge; // vetor
private BubbleSort bubble = new BubbleSort();
private QuickSort quick = new QuickSort();
private MergeSort merge = new MergeSort();
private String linha = "", caminho_arquivo = "";
Date data = new Date(System.currentTimeMillis());
/**
* Create the frame.
*/
public Tela() {
String apresentacao = "";
apresentacao += "- - - Atividade Prtica Supervisionada\n";
apresentacao += "- - - " + data + "\n\n";
apresentacao += "Esse programa foi desenvolvido com a
finalidade\n"
+ "de apresentar os resultados de alguns
algoritmos\n"
+ "de ordenao de dados. Com ele ser
possvel ob-\n"
+ "ter tempos de execuo dos trs mtodos
escolhi-\n"
+ "dos, que so: BubbleSort, MergeSort e
QuickSort.\n";
JOptionPane.showMessageDialog(null, apresentacao);
setTitle("APS");
//evento abrir tela do programa
addWindowListener(new WindowAdapter() {
@Override
public void windowOpened(WindowEvent arg0) {
//redimensionar
setSize(450, 320);
}
});
setFont(new Font("Times New Roman", Font.PLAIN, 12));
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setBounds(100, 100, 1525, 804);
contentPane = new JPanel();
contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
contentPane.setLayout(new BorderLayout(0, 0));
setContentPane(contentPane);
//painel titulo
JPanel panelTitulo = new JPanel();
contentPane.add(panelTitulo, BorderLayout.NORTH);
//label titulo
JLabel lbTitulo = new JLabel("T\u00E9cnicas de
Ordena\u00E7\u00E3o de Dados");
lbTitulo.setFont(new Font("Times New Roman", Font.PLAIN, 30));
panelTitulo.add(lbTitulo);
//painel dados
JPanel panelDados = new JPanel();
panelDados.setToolTipText("Obter dados");
panelDados.setBorder(UIManager.getBorder("CheckBox.border"));
contentPane.add(panelDados, BorderLayout.CENTER);
painelDados = panelDados;
//labe titulo esquerda

JLabel lbTitLeft = new JLabel("Obter dados");
lbTitLeft.setHorizontalAlignment(SwingConstants.CENTER);
lbTitLeft.setFont(new Font("Times New Roman", Font.PLAIN,
23));
tituloEsquerda = lbTitLeft;
JLabel lbTamanho = new JLabel("Tamanho: ");

lbTamanho.setFont(new Font("Times New Roman", Font.PLAIN,
18));
lbTamanho.setVisible(false);
JLabel lbTempoGerar = new JLabel("Tempo pra gerar: ");

lbTempoGerar.setFont(new Font("Times New Roman",
Font.PLAIN, 18));
lbTempoGerar.setVisible(false);
// botao ordenar decrescente

JButton btnOrdenarDecrescente = new JButton("Ordenar
Decrescente");
btnOrdenarDecrescente.setVisible(false);
btnOrdenarDecrescente.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
ordenadoQuick = null;
ordenadoQuick = new int[aleatorio.length];
ordenadoQuick = quick.quickSort(aleatorio, 0,
aleatorio.length - 1);
//for (int i = 0, j = tamanho-1; i <= tamanho/2; i++, j--

){
// aleatorio[i] = ordenadoQuick[j];
// aleatorio[j] = ordenadoQuick[i];
//}
aleatorio = quick.getDecrescente(ordenadoQuick, 0,
tamanho - 1);
txtAleatorio.setText(exibiVetor(aleatorio));
}
});
//botao automatico
JButton btnAuto = new JButton("Autom\u00E1tico");
//click
btnAuto.addActionListener(new ActionListener() {
Random r = new Random();
long inicio = System.currentTimeMillis();
for (int i = 0; i < tamanho; i++)
aleatorio[i] = r.nextInt(tamanho * 13);
long total = System.currentTimeMillis() - inicio;
invisibleEtapa1();
lbTempoGerar.setVisible(true);
lbTempoGerar.setText("Tempo para gerar: " +
String.valueOf(total));
lbTamanho.setVisible(true);
lbTamanho.setText(lbTamanho.getText() +
String.valueOf(tamanho));
}
});
btnAuto.setVisible(false);
btnAuto.setFont(new Font("Times New Roman", Font.PLAIN,
16));
btAuto = btnAuto;
//botao teclado
JButton btnTeclado = new JButton("Pelo teclado");
//click
btnTeclado.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent arg0) {
aleatorio[i] =
Integer.parseInt(JOptionPane.showInputDialog(null,
"Faltam "+
String.valueOf(tamanho - i) +" valores...\nInforme um valor aleatrio:", "Valor", 0));
invisibleEtapa1();
lbTempoGerar.setText("Gerado manualmente");
lbTamanho.setText("Tamanho: " +
}
});
btnTeclado.setVisible(false);
btnTeclado.setFont(new Font("Times New Roman", Font.PLAIN,
16));
btTeclado = btnTeclado;
//botao arquivo
JButton btnArquivo = new JButton("Arquivo");
btnArquivo.addMouseListener(new MouseAdapter() {
boolean helpArquivo = true;
@Override
//Evento Mouse em Cima do Botao Arquivo
public void mouseEntered(MouseEvent arg0) {
if (helpArquivo){
helpArq =
JOptionPane.showConfirmDialog(null,
"Para utilizar a opo de criar
um vetor atrves de arquivo,\n"
+ "ser necessrio mover o
arquivo para raiz do sistema, ou seja:\n"
+ "'C:\', tambm ser necessrio
alterar o nome para numeros.txt\n\n"
+ "Deseja ver esse aviso
novamente?",
"Carregamento via arquivo de
texto",
JOptionPane.INFORMATION_MESSAGE);
if (helpArq == 1)
helpArquivo = false;
}
}
});
btnArquivo.addActionListener(new ActionListener() {
caminho_arquivo = "C:\\numeros.txt";
String temporario = new String();

File arq = new File(caminho_arquivo);
if (arq.exists()) { // existe o arquivo?

// sim
try { // tente
tamanho = 5000;
aux = new int[tamanho];
FileReader leitor = new
FileReader(caminho_arquivo);
BufferedReader temp = new
BufferedReader(leitor);
while (true){ // ler todas as linhas

temporario = temp.readLine();
if (temporario == null){ // se
chegou no fim
break;
}
aux[contador++] +=
Double.parseDouble(temporario);
}
lbTempoGerar.setText("Gerado via
arquivo");
lbTamanho.setText("Tamanho: " +
// Quantos posies foram usadas

int pos = 0;
while (aux[pos] != 0){
pos++;
}
tamanho = pos;
aleatorio = new int[tamanho];
aleatorio[i] = aux[i];
invisibleEtapa1();
} catch (Exception e) { // se der errado
JOptionPane.showMessageDialog(null, "Erro inesperado :(", "Erro",

JOptionPane.ERROR_MESSAGE);
}
} else {
// nao existe
JOptionPane.showMessageDialog(null, "O
arquivo no existe :(", "Erro", JOptionPane.ERROR_MESSAGE);
}
} //fim public void

});
btnArquivo.setEnabled(true);
btnArquivo.setFont(new Font("Times New Roman", Font.PLAIN,
16));
btArquivo = btnArquivo;
//label
JLabel lblTamanhoDoVetor = new JLabel("Tamanho do vetor?");
//Botao Criar vetor

JButton btnGerarVetor = new JButton("Criar Vetor");
//evento click
btnGerarVetor.addActionListener(new ActionListener() {
if (txtTamVetor.getText().length() != 0){
txtTamVetor.setVisible(false);
lblTamanhoDoVetor.setVisible(false);
btnGerarVetor.setVisible(false);
btnArquivo.setVisible(false);
btnAuto.setVisible(true);
btnTeclado.setVisible(true);
tamanho =
Integer.parseInt(txtTamVetor.getText());
aleatorio = new int[tamanho];
}
}
});
//TextField
txtTamVetor = new JTextField();
//Somente numero
txtTamVetor.addKeyListener(new KeyAdapter() {
@Override
public void keyTyped(KeyEvent arg0) {
char caracter = arg0.getKeyChar();
if (((caracter < '0') || (caracter > '9'))
&& (caracter != '\b')) {
arg0.consume();
}
}
});
txtTamVetor.setColumns(10);
GroupLayout gl_panelDados = new GroupLayout(panelDados);

gl_panelDados.setHorizontalGroup(
gl_panelDados.createParallelGroup(Alignment.LEADING)
.addGroup(gl_panelDados.createSequentialGroup()
.addGap(70)
.addComponent(lbTitLeft,
GroupLayout.PREFERRED_SIZE, 254, GroupLayout.PREFERRED_SIZE)
.addContainerGap(165, Short.MAX_VALUE))
.addGap(24)
.addGroup(gl_panelDados.createParallelGroup(Alignment.TRAILING)
.addGroup(gl_panelDados.createParallelGroup(Alignment.TRAILING, false)
.addComponent(btnArquivo,
Alignment.LEADING, GroupLayout.DEFAULT_SIZE, GroupLayout.DEFAULT_SIZE,
Short.MAX_VALUE)
.addComponent(btnTeclado,
Alignment.LEADING, GroupLayout.DEFAULT_SIZE, 346, Short.MAX_VALUE)
.addComponent(btnGerarVetor,
Alignment.LEADING, GroupLayout.DEFAULT_SIZE, 346, Short.MAX_VALUE)
.addComponent(btnAuto,
Alignment.LEADING, GroupLayout.PREFERRED_SIZE, 346,
GroupLayout.PREFERRED_SIZE))
.addComponent(lblTamanhoDoVetor, GroupLayout.DEFAULT_SIZE, 197,

Short.MAX_VALUE)
.addGap(22)
.addComponent(txtTamVetor,
GroupLayout.DEFAULT_SIZE, 127, Short.MAX_VALUE)))
.addGap(392))
);
gl_panelDados.setVerticalGroup(
gl_panelDados.createParallelGroup(Alignment.LEADING)
.addContainerGap()
.addComponent(lbTitLeft)
.addGap(18)
.addGroup(gl_panelDados.createParallelGroup(Alignment.BASELINE)
.addComponent(lblTamanhoDoVetor)
.addComponent(txtTamVetor,
GroupLayout.PREFERRED_SIZE, GroupLayout.DEFAULT_SIZE,
.addPreferredGap(ComponentPlacement.RELATED)
.addComponent(btnGerarVetor)
.addComponent(btnTeclado)
.addComponent(btnAuto)
.addComponent(btnArquivo)
.addContainerGap(455, Short.MAX_VALUE))
);
panelDados.setLayout(gl_panelDados);
//painel metodos
JPanel panelMetodos = new JPanel();
panelMetodos.setVisible(false);
contentPane.add(panelMetodos, BorderLayout.WEST);
painelMetodos = panelMetodos;
JLabel lbMetodos = new JLabel("Escolha um metodo de

ordena\u00E7\u00E3o:");
lbMetodos.setFont(new Font("Times New Roman", Font.PLAIN,
23));
JLabel lblVetorAleatorio = new JLabel("Vetor aleatorio");

lblVetorAleatorio.setFont(new Font("Times New Roman",
Font.PLAIN, 20));
//textarea
JTextArea textAleatorio = new JTextArea();
textAleatorio.setBackground(Color.LIGHT_GRAY);
textAleatorio.setFont(new Font("Times New Roman", Font.PLAIN,
14));
textAleatorio.setLineWrap(true);
txtAleatorio = textAleatorio;
//label bubble
JLabel lbBubble = new JLabel("0");
lbBubble.setFont(new Font("Times New Roman", Font.PLAIN,
18));
lbBubble.setVisible(false);
labelBubble = lbBubble;
//label quick
JLabel lbQuick = new JLabel("0");
lbQuick.setFont(new Font("Times New Roman", Font.PLAIN, 18));
lbQuick.setVisible(false);
labelQuick = lbQuick;
//texarea bubble
JTextArea textBubble = new JTextArea();
textBubble.setLineWrap(true);
textBubble.setVisible(false);
textBubble.setBackground(Color.LIGHT_GRAY);
textBubble.setText("N\u00E3o executado!");
txtBubble = textBubble;
//textarea quick
JTextArea textQuick = new JTextArea();
textQuick.setLineWrap(true);
textQuick.setVisible(false);
textQuick.setBackground(Color.LIGHT_GRAY);
textQuick.setText("N\u00E3o executado!");
txtQuick = textQuick;
//botao bubblesort
JButton btnBubble = new JButton("BubbleSort");
//click
btnBubble.addActionListener(new ActionListener() {
ordenadoBubble = bubble.ordena(aleatorio);
txtBubble.setText(exibiVetor(ordenadoBubble));
lbBubble.setText(String.valueOf(bubble.getTotal()));
visibleContadoresBubble();
btnOrdenarDecrescente.setVisible(true);
}
});
btnBubble.setMnemonic(KeyEvent.VK_ENTER);
//botao quicksort
JButton btnQuick = new JButton("QuickSort");
//click
btnQuick.addActionListener(new ActionListener() {
quick.inicio();
ordenadoQuick = quick.quickSort(aleatorio, 0,
tamanho-1);
quick.fim();
quick.total();
long total = quick.getTotal();
lbQuick.setText(String.valueOf(total));
txtQuick.setText(exibiVetor(ordenadoQuick));
visibleContadoresQuick();
}
});
//label segs
JLabel lbSegs = new JLabel("milisegundos");
lbSegs.setFont(new Font("Times New Roman", Font.PLAIN, 18));
lbSegs.setVisible(false);
seg = lbSegs;
//labels segss
JLabel lbSegs2 = new JLabel("milisegundos");
lbSegs2.setFont(new Font("Times New Roman", Font.PLAIN,
18));
lbSegs2.setVisible(false);
segs = lbSegs2;
JLabel lbMerge = new JLabel("0");

lbMerge.setFont(new Font("Times New Roman", Font.PLAIN,
18));
lbMerge.setVisible(false);
labelMerge = lbMerge;
JLabel lbSegs3 = new JLabel("milisegundos");

lbSegs3.setFont(new Font("Times New Roman", Font.PLAIN,
18));
lbSegs3.setVisible(false);
segss = lbSegs3;
//botao merge
JButton btnMerge = new JButton("MergeSort");
btnMerge.addActionListener(new ActionListener() {
merge.inicio();
merge.sort(aleatorio);
ordenadoMerge = merge.getArray();
merge.fim();
merge.total();
long total = merge.getTotal();
lbMerge.setText(String.valueOf(total));
txtMerge.setText(exibiVetor(ordenadoMerge));
visibleContadoresMerge();
}
});
//textarea
JTextArea textMerge = new JTextArea();
textMerge.setLineWrap(true);
textMerge.setVisible(false);
textMerge.setBackground(Color.LIGHT_GRAY);
textMerge.setText("N\u00E3o executado!");
txtMerge = textMerge;
//botaoVoltar
JButton btnVoltar = new JButton("Voltar");
btnVoltar.addActionListener(new ActionListener() {
//alternar paineis
painelDados.setVisible(true);
painelMetodos.setVisible(false);
//redimensionar para tela inicial

setSize(450, 320);
//zerar variaveis
tamanho = 0;
aleatorio = null;
ordenadoBubble = null;
ordenadoQuick = null;
ordenadoMerge = null;
aux = null;
//zerar campos
txtAleatorio.setText("");
txtTamVetor.setText("");
lbTamanho.setText("Tamanho: ");
//deixar visivel configurao inicial

txtTamVetor.setVisible(true);
lblTamanhoDoVetor.setVisible(true);
btnGerarVetor.setVisible(true);
//deixar invisivel configurao secundaria

btnArquivo.setVisible(true);
btnAuto.setVisible(false);
btnTeclado.setVisible(false);
lbBubble.setVisible(false);
lbQuick.setVisible(false);
lbMerge.setVisible(false);
labelBubble.setVisible(false);
labelQuick.setVisible(false);
labelMerge.setVisible(false);
txtBubble.setVisible(false);
txtQuick.setVisible(false);
txtMerge.setVisible(false);
seg.setVisible(false);
segs.setVisible(false);
segss.setVisible(false);
//ativar botoes
btnBubble.setEnabled(true);
btnQuick.setEnabled(true);
btnMerge.setEnabled(true);
}
});
GroupLayout gl_panelMetodos = new
GroupLayout(panelMetodos);
gl_panelMetodos.setHorizontalGroup(
gl_panelMetodos.createParallelGroup(Alignment.LEADING)
.addGroup(gl_panelMetodos.createSequentialGroup()
.addContainerGap()
.addGroup(gl_panelMetodos.createParallelGroup(Alignment.LEADING)
.addGroup(gl_panelMetodos.createParallelGroup(Alignment.TRAILING)
.addComponent(lblVetorAleatorio)
.addComponent(lbTamanho))
.addGap(171))
.addComponent(textAleatorio, GroupLayout.PREFERRED_SIZE, 282,

GroupLayout.PREFERRED_SIZE)
.addPreferredGap(ComponentPlacement.RELATED)))
.addComponent(textBubble, GroupLayout.PREFERRED_SIZE, 183,

.addGap(17)
.addComponent(lbBubble)
.addComponent(lbSegs))
.addGroup(Alignment.LEADING, gl_panelMetodos.createSequentialGroup()
.addComponent(btnOrdenarDecrescente)
.addComponent(btnBubble, GroupLayout.DEFAULT_SIZE, 188,

Short.MAX_VALUE))))
.addGap(18)
.addComponent(lbQuick)
.addComponent(lbSegs2, GroupLayout.PREFERRED_SIZE, 93,

.addComponent(btnQuick, GroupLayout.PREFERRED_SIZE, 184,

.addGap(9))
.addComponent(textQuick, GroupLayout.PREFERRED_SIZE,
GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
.addPreferredGap(ComponentPlacement.RELATED, 77, Short.MAX_VALUE)
.addComponent(lbMerge)
.addComponent(lbSegs3))
.addComponent(btnMerge, GroupLayout.DEFAULT_SIZE, 187,

Short.MAX_VALUE)
.addComponent(textMerge, GroupLayout.DEFAULT_SIZE, 187,

Short.MAX_VALUE)))
.addGap(134)
.addComponent(lbMetodos)
.addGap(40)
.addComponent(btnVoltar, GroupLayout.DEFAULT_SIZE, 92,

Short.MAX_VALUE)))
.addGap(108))
.addComponent(lbTempoGerar)
.addContainerGap(855,
Short.MAX_VALUE))))
);
gl_panelMetodos.setVerticalGroup(
gl_panelMetodos.createParallelGroup(Alignment.TRAILING)
.addGap(27)
.addComponent(lbMetodos))
.addContainerGap()
.addComponent(btnVoltar, GroupLayout.PREFERRED_SIZE, 46,

.addComponent(lblVetorAleatorio)
.addComponent(lbTamanho)))))
.addComponent(btnOrdenarDecrescente)
.addGroup(gl_panelMetodos.createParallelGroup(Alignment.BASELINE)
.addComponent(btnMerge)
.addComponent(btnQuick)
.addComponent(btnBubble))
.addGap(5)
.addComponent(lbSegs2)
.addComponent(lbSegs)
.addComponent(lbSegs3)
.addComponent(lbMerge)
.addComponent(lbQuick)
.addComponent(lbBubble))
.addComponent(textBubble, GroupLayout.PREFERRED_SIZE, 618,

.addComponent(textQuick, GroupLayout.PREFERRED_SIZE, 525,

.addComponent(textMerge, GroupLayout.PREFERRED_SIZE, 524,

GroupLayout.PREFERRED_SIZE)))
.addGap(8)
.addComponent(lbTempoGerar)
.addGap(18)
.addComponent(textAleatorio,
GroupLayout.PREFERRED_SIZE, 572, GroupLayout.PREFERRED_SIZE)))
.addContainerGap(GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE))
);
panelMetodos.setLayout(gl_panelMetodos);
setLocation(256, 100);
} // fim construtor
public String exibiVetor(int[] vet){

String msg = "";
for (int i = 0; i < vet.length; i++)
msg += String.valueOf(vet[i]) + ", ";
return msg;
}
public void invisibleEtapa1(){

painelDados.setVisible(false);
painelMetodos.setVisible(true);
txtAleatorio.setText(exibiVetor(aleatorio));
setSize(950, 783);
}
public int[] clonaVetor(int[] original){

int [] copia = new int[original.length];
for (int i = 0; i < original.length; i++)
copia[i] = original[i];
return copia;
}
//bubble
public void visibleContadoresBubble(){
labelBubble.setVisible(true);
txtBubble.setVisible(true);
seg.setVisible(true);
}
//quick
public void visibleContadoresQuick(){
labelQuick.setVisible(true);
txtQuick.setVisible(true);
segs.setVisible(true);
}
//merge
public void visibleContadoresMerge(){
labelMerge.setVisible(true);
txtMerge.setVisible(true);
segss.setVisible(true);
}
/**
* Launch the application.
*/
public static void main(String[] args) {
EventQueue.invokeLater(new Runnable() {
public void run() {
try {
Tela frame = new Tela();
frame.setVisible(true);
} catch (Exception e) {
e.printStackTrace();
}
}
});
}
}
Referncias Bibliogrficas
Livros:
Ziviani, N. Projeto de Algoritmos com Implementaes em Pascal e C, So Paulo,
Brazil, Cengage Learning
Cormen, Leiserson, Rivest. Introduction to Algorithms. 2nd edition. MIT Press, 2001.
Captulos 2, 6, 7, 8.
Aho, Alfred V., Hopcroft, John F., Ullman, Jeffrey D., Data Structure and Algorithms,
Massachusetts: Addison- Wesley, 1987. Captulo 8.
AZEREDO, Paulo A.. Mtodos de Classificao de Dados e Anlise de suas
Complexidades. Rio de Janeiro: Campus, 1996
Texto de Internet
Colturato, Daniela. Ordenao de dados. Disponvel em: <http://dbcolturato.info>.
Acesso em 17 de junho de 2015.
Mello, Ronaldo S. Ordenao de dados. Disponvel em:

<http://www.inf.ufsc.br/~ronaldo/ine5384/15-OrdenacaoDados.pdf>
Rangel, W. Celes e J. L. Ordenao de dados captulo 15. Disponvel em:

<http://www.ic.unicamp.br/~ra069320/PED/MC102/1s2008/Apostilas/Cap15.pdf>
Loureiro, Antonio Alfredo Ferreira Loureiro. Ordenao. Disponvel em:

<http://homepages.dcc.ufmg.br/~loureiro/alg/071/aeds2_ORDENACAO_1pp.pdf>
Silva, Fernando. Estruturas de Dados. Disponvel em:

<http://www.dcc.fc.up.pt/~fds/aulas/EDados/1314/Apontamentos/ordenacao-1x2.pdf>

Algoritimos de Ordenação

Uploaded by

Document Information

Original Description:

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Algoritimos de Ordenação

Uploaded by

Copyright:

Available Formats

CINCIA DA COMPUTAO

Desenvolvimento de sistema para anlise de

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

Obteno de dados Aleatrios para ordenao

Dividir os dados em subseqncias pequenas;

Combinar, juntar as duas metades em um nico conjunto j classificado;

Mtodo Quicksort (Ordenao Rpida)

Quick Sort 1.0 2.0 19.0 1.0

Tempo 0.0 4.0 13.0 15.0

Ordem Semi Ordenada

Bubble 9.0 22.0 132.0 939.0

Foram testados os trs seguintes Mtodos: BubbleSort (Bolha), QuickSort e

Apresentou-se como o pior mtodo de ordenao.O BubbleSort um mtodo

Obteve o melhor resultado na maioria dos testes. Teve um maior desempenho

Apresentou os piores resultados entre os algoritmos de ordenao eficientes.

public int[] ordena(int[] vetor){

public long getTotal(){

private void inicio(){

private void fim(){

private void total(){

public void sort(int inputArr[]) {

private void doMergeSort(int lowerIndex, int higherIndex) {

if (lowerIndex < higherIndex) {

for (int i = lowerIndex; i <= higherIndex; i++) {

public int[] getArray(){

public long getTotal(){

public void fim(){

public void total(){

public class QuickSort {

public int partition(int[] arr, int left, int right)

public int[] quickSort(int[] arr, int left, int right) {

int index = partition(arr, left, right);

public long getTotal(){

public void inicio(){

public void fim(){

public void total(){

public int[] getDecrescente(int[] arr, int left, int right){

public class Tela extends JFrame {

private JPanel contentPane;

//labe titulo esquerda

JLabel lbTamanho = new JLabel("Tamanho: ");

JLabel lbTempoGerar = new JLabel("Tempo pra gerar: ");

// botao ordenar decrescente

//for (int i = 0, j = tamanho-1; i <= tamanho/2; i++, j--

String temporario = new String();

if (arq.exists()) { // existe o arquivo?

while (true){ // ler todas as linhas

// Quantos posies foram usadas

} catch (Exception e) { // se der errado

JOptionPane.showMessageDialog(null, "Erro inesperado :(", "Erro",

} //fim public void

//Botao Criar vetor

GroupLayout gl_panelDados = new GroupLayout(panelDados);

.addComponent(lblTamanhoDoVetor, GroupLayout.DEFAULT_SIZE, 197,

JLabel lbMetodos = new JLabel("Escolha um metodo de

JLabel lblVetorAleatorio = new JLabel("Vetor aleatorio");

JLabel lbMerge = new JLabel("0");

JLabel lbSegs3 = new JLabel("milisegundos");

//redimensionar para tela inicial

//deixar visivel configurao inicial

//deixar invisivel configurao secundaria

.addComponent(textAleatorio, GroupLayout.PREFERRED_SIZE, 282,

.addComponent(textBubble, GroupLayout.PREFERRED_SIZE, 183,