CINCIA DA COMPUTAO

3 PERIODO

DESENVOLVIMENTO DE SISTEMA PARA ANLISE DE

PERFORMANCE DE ALGORITMOS DE ORDENAO DE
DADOS

ndice
Objetivo

Trabalho___________________________________________________3

Introduo_________________________________________________________4
Referencial Terico___________________________________________________6
Desenvolvimento____________________________________________________15
Resultados e Discusso______________________________________________25
Consideraes Finais________________________________________________28
Referncias Bibliogrficas____________________________________________29
Cdigo Fonte_______________________________________________________30
Fichas APS________________________________________________________43

Objetivo do Trabalho
2

Esse trabalho tem como objetivo apresentar o que so mtodos de

ordenao, quais so os mais conhecidos, demonstrar como funcionam, aplic-los
em um programa, obter os resultados de desempenho e discutir sobre eles.

Introduo
3

Ordenao: Tornar mais simples, rpida e vivel a recuperao de uma determinada

informao, num conjunto grande de informaes.

Algoritmo de ordenao em cincia da computao um algoritmo que coloca os

elementos de uma dada sequncia em certa ordem, em outras palavras, efetua
sua ordenao completa ou parcial. Existem vrias razes para se ordenar uma
sequncia. Uma delas a possibilidade se acessar seus dados de modo mais
eficiente.
No existe um mtodo de ordenao considerado universalmente superior a todos
os outros. necessrio analisar o problema e, com base nas caractersticas dos
dados, decidirem qual o mtodo que melhor se aplica a ele.
Alguns aspectos de medida de eficincia: tempo para codificao do programa de
ordenao; tempo de mquina para a execuo do programa; espao de memria
necessrio. Normalmente o tempo gasto medido pelo nmero de operaes
crticas, ao problema, que so efetuadas. Nesse caso as operaes crticas so:
comparaes de chaves; movimentao de registros ou de ponteiros; troca entre
dois registros. A medida tomada pela anlise do melhor caso, do pior caso e do
caso mdio. O resultado uma frmula em funo de n (nmero de registros do
arquivo).
Na realidade o tempo gasto no depende exclusivamente do tamanho do arquivo,
mas tambm de outros aspectos, por exemplo: se existe uma pr ordenao no
arquivo ou no.

Abaixo so apresentados trs dos algoritmos de ordenao mais conhecidos.

Bubble Sort
o mtodo mais intuitivo e simples de ser implementado, porm o menos
eciente.
Selection Sort
Neste tipo de ordenao, se seleciona o menor elemento do subvetor no ordenado
e troca com o primeiro elemento deste subvetor
Quick Sort
O quicksort um algoritmo de ordenao considerado entre os mais rpidos e
eficientes.

O ambiente de desenvolvimento do programa ser o NetBeans, utilizando a

linguagem Java.

Referencial Terico
A escolha de um mtodo de ordenao deve se, a necessidade a qual o
software requer, disponibilizando-se de uma biblioteca j estabelecida, porm no
fixa, ou seja, podem surgir vrias outras, o desenvolvedor pode optar por diversas
formas de ordenar. Porm alguns mtodos so mais simples e outros mais
complexos ou mais eficientes e menos eficientes.
Existem vrios desenvolvedores e criadores de mtodos e lgicas, mas
podemos colocar em destaque James Gosling, que agrega grande conhecimento e
influncia, assim como experincia, sendo referncia na rea tecnolgica, ajudando
a inovar e produzir novos conceitos.

Ordenar corresponde ao processo de rearranjar um conjunto de objeto sem ordem

ascendente ou descendente. O objetivo principal da ordenao facilitar a
recuperao posterior de itens do conjunto ordenado. O objetivo principal da
ordenao facilitar a recuperao posterior de itens do conjunto ordenado.

Sero apresentados agora os mtodos de ordenao Bubble Sort, Selection Sort e

Quick Sort.

Bubble Sort
Bubble sort um simples e bem conhecido algoritmo de ordenao. Ele usado
mais para prtica inicial, para ajudar na introduo aos algoritmos de ordenao.
Bubble sort pertence aos O (n) algoritmos de ordenao, o que o torna bastante
ineficiente para ordenar grandes volumes de dados. Bubble sort estvel e
adaptativo.

Algoritmo
1. Compara cada par de elementos adjacentes do incio do vetor e, se eles
estiverem na ordem reversa, troca eles de lugar.
2. Se ao menos uma troca foi feita, repete o primeiro passo.
Voc pode imaginar como se em cada passo grandes bolhas flutuam at a superfcie
e ficam l. Em um momento, quando nenhuma bolha flutua, a ordenao para.
Vejamos um exemplo do algoritmo ordenando um vetor para termos uma idia mais
clara sobre o bubble sort.

Anlise de Complexidade
Em casos de complexidade mediana ou alta, o bubble sort possui desempenho de O
(n). Assim como, ele efetua O (n) trocas nos piores casos. Bubble sort adaptativo.
Isso significa que em vetores quase ordenados seu desempenho estimado O(n).
Evite implementaes que no confiram se o vetor j est ordenado em cada passo
(qualquer troca feita). Essa checagem necessria, em ordem para preservar
propriedades adaptativas.

Exemplo:
Ordenando {5, 1, 12, -5, 16} usando bubble sort.

Ordenao por seleo

Ordenao por seleo um dos algoritmos de ordenao O (n), o que o torna bem
ineficiente para ordenar grandes volumes de dados. Ordenao por seleo
notvel por sua simples programao e pode superar em performance outros
mtodos de ordenao em certas situaes.

Algoritmo
A ideia do algoritmo bem simples. O vetor imaginariamente dividido em duas
partes, ordenada e no ordenada. No comeo, a ordenada est vazia, enquanto a
no ordenada contm todo o vetor. A cada passo, o algoritmo acha o elemento
mnimo na parte no ordenada e adiciona ele para o final da parte ordenada.
Quando a parte no ordenada se torna vazia, o algoritmo encerra.

Anlise de Complexidade
Ordenao por seleo acaba quando a parte no ordenada se torna vazia. Como
ns sabemos, em cada passo o nmero de elementos no ordenados diminui por 1.
Portanto, ordenao por seleo faz n passos (n o nmero de elementos no vetor)
antes de terminar. Cada passo requer achar um mnimo na parte no ordenada.
Assim sendo, n + (n - 1) + (n - 2) + ... + 1, resulta em O (n) nmeros de
comparaes. Nmeros de trocas podem variar de 0 (no caso de um vetor
ordenado) a n - 1 (no caso do vetor ser ordenado em ordem reversa), que resulta em
O(n) nmeros de trocas. Em geral a complexidade do algoritmo O (n).
Em fato, ordenao por seleo requer (n 1) nmeros de trocas na maioria,
tornando-o bastante eficiente em situaes, onde a operao de obter
significantemente maior do que a opo de ler.

Exemplo:
Ordenando {5, 1, 12, -5, 16, 2, 12, 14} usando ordenao por seleo.

10

Quicksort
Quicksort um rpido algoritmo de ordenao, que usado no s para o meio
educacional, mas altamente aplicado em prtica. Em mdia, ele tem O(n log n) de
complexidade, tornando o quicksort adequado para ordenar grandes volumes de
dados.
A ideia do algoritmo bem simples e quando voc perceber, voc poder escrever
quicksort to rpido quando o bubble sort.

Algoritmo
A estratgia de dividir e conquistar usada no quicksort. Abaixo o processo de
recurso descrito:

1. Escolha um valor piv: Ns pegamos o valor do elemento do meio como valor

piv, mas pode ser qualquer valor, desde que esteja entre os valores a serem
ordenados.
2. Particione: Reordena os elementos em tal mtodo que, todos os elementos que
forem menos que o piv vo para a parte esquerda do vetor e todos os elementos
maiores que o piv, vo para a parte direita do vetor. Valores iguais ao piv podem
ficar em qualquer parte do vetor. Nota-se que, o vetor pode ser dividido em partes
no iguais.
3. Ordene ambas as partes: Aplique o algoritmo quicksort recursivamente para as
partes esquerdas e direitas.

11

Algoritmo de particionamento em detalhe

H dois ndices, i e j, e bem no incio do algoritmo i aponta para o primeiro elemento
no vetor e j aponta para o ltimo. Em seguida, o algoritmo move o i para frente, at
um elemento com valor maior ou igual ao piv encontrado. O ndice j movido
para trs, at que um elemento com valor inferior ou igual ao piv seja encontrado.
Se i<=j ento eles so trocados e i passa para a prxima posio (i+1), j passa para
a posio anterior (j-1). O algoritmo termina quando i se torna maior do que j.
Aps o particionamento, todos os valores anteriores ao elemento i so inferiores ou
iguais ao piv e todos os valores posteriores ao elemento j so maiores ou iguais ao
piv.

12

Exemplo:
Ordenando {1, 12, 5, 26, 7, 14, 3, 7, 2} usando quicksort.

13

Por que funciona?

No algoritmo de particionamento o vetor dividido em duas partes e todo elemento a
da parte esquerda inferior ou igual a todos os elementos b da parte direita. A e b
tambm satisfazem a <= piv <= b. Aps o encerramento do processo de recurso,
ambas as partes se tornam ordenadas e, levando em conta todos os argumentos
apresentados acima, todo o vetor ordenado.

Anlise da Complexidade
Em mdia, o quicksort possui O (n log n) de complexidade, mas nos piores casos,
o quicksort roda em O (n) de tempo, mas nos mais "prticos" dados ele funciona
bem e superior outros O (n log n) algoritmos de ordenao.

Observaes extras
recomendado que o algoritmo de partio seja usado como uma funo separada,
por exemplo, a utilizao de duas funes, uma de partio e outra de ordenao
que utiliza a de partio.

14

Desenvolvimento

1CASO Obteno de Dados atravs do usurio

Na tela inicial do programa, requisitado o modo de obteno de dados. Caso digite
1, os dados sero obtidos atravs da insero pelo usurio, caso contrrio, os dados
sero gerados de forma aleatria. No exemplo a seguir, a opo escolhida a 1.

15

Agora, requisitado pelo programa que o usurio digite um nmero, para ser
armazenado e depois usado para a ordenao.

16

Neste momento, o programa deseja saber se o usurio quer continuar digitando

mais valores ou encerrar, caso digite qualquer tecla, o programa ir pedir que digite
outro valor, mas se o N for digitado, ser encerrado o processo de obteno de
dados.

17

Caso a opo digitada for N, o usurio ser apresentado a essa tela, na qual o
programa estar requisitando a opo para selecionar o modo de ordenao em que
os valores sero ordenados. Se o usurio digitar 1, ser utilizado o Bubble Sort,
caso digite 2, ser utilizado o Selection Sort e se for digitado o 3, ser utilizado o
Quick Sort. Nesse caso, a opo informada pelo usurio o Bubble Sort, de nmero
1.

18

Aps isso, sero apresentados nessa tela final o nmero total de ndices informados
pelo usurio, a ordem original de seus valores, a ordem final, obtida aps a
ordenao pelo mtodo selecionado e o tempo total decorrido durante a ordenao
dos dados.

19

2CASO Dados gerados de forma aleatria pelo programa

Na tela inicial do programa, requisitado o modo de obteno de dados. Caso digite
1, os dados sero obtidos atravs da insero pelo usurio, caso contrrio, os dados
sero gerados de forma aleatria. No exemplo a seguir, a opo escolhida a 2.

20

Nesta tela, o programa ir requisitar que o usurio digite a quantidade de nmeros a

serem gerados de forma aleatria. Neste exemplo, a quantidade de nmeros a
serem gerados ser de 100.

21

Como no primeiro caso, o programa est requisitando que o usurio informe o

mtodo de ordenao que ir ser utilizado para a ordenao do vetor. Se o usurio
digitar 1, ser utilizado o Bubble Sort, caso digite 2, ser utilizado o Selection Sort e
se for digitado o 3, ser utilizado o Quick Sort. Nesse caso, a opo informada pelo
usurio o Selection Sort, de nmero 2.

22

Por ltimo, como no primeiro caso, nas duas imagens seguintes sero apresentados
o nmero total de ndices gerados de forma aleatria, a ordem original de seus
valores, a ordem final, obtida aps a ordenao pelo mtodo selecionado e o tempo
total decorrido durante a ordenao dos dados.

23

A apresentao dos resultados comparativos entre os mtodos e diferentes casos

estar contida no prximo tpico.

24

Resultados e Discusso

Os resultados que sero apresentados a seguir foram obtidos atravs de um

computador com processador DualCore 2.5GHz e memria RAM DDR2 de 4GB.

Dados Aleatrios

(Valores na escala de milisegundos (ms))

30000
25000
20000
Cem
Mil

15000

Dez Mil
Cem Mil

10000
5000
0
Bubble Sort

Selection Sort

Quick Sort

Na condio de dados em ordem aleatria, o Bubble Sort obteve de longe o pior

desempenho, 8 vezes mais demorado para ordenar mil nmeros, 3 vezes para
ordenar dez mil e quase duas vezes mais para ordenar cem mil em comparao

25

com o segundo da lista, o Selection Sort. E como melhor desempenho bem acima
dos demais se encontra o Quick Sort.

Dados pr-ordenados em ordem decrescente

(Valores na escala de milisegundos (ms))

16000
14000
12000
10000

Cem
Mil

8000

Dez Mil
6000

Cem Mil

4000
2000
0
Bubble Sort

Selection Sort

Quick Sort

Na condio de dados pr-ordenados em ordem decrescente, o Bubble Sort obteve

o pior resultado, mas desta vez no to ruim como a primeira, ficando apenas um
pouco atrs do segundo da lista, o Selection Sort. E como melhor desempenho bem
acima dos demais novamente, se encontra o Quick Sort.

26

Dados j ordenados (ordem crescente)

(Valores na escala de milisegundos (ms))

16000
14000
12000
10000

Cem
Mil

8000

Dez Mil
6000

Cem Mil

4000
2000
0
Bubble Sort

Selection Sort

Quick Sort

Na condio de dados j ordenados, o Bubble Sort obteve o pior resultado, mas

como no caso anterior, ficando apenas um pouco atrs do segundo da lista, na
verdade, quase levou o mesmo tempo que o Selection Sort. E como melhor
desempenho bem acima dos demais novamente, se encontra o Quick Sort.

Em relao aos testes:

O Quick Sort o mais rpido para todos os tamanhos e tipos de dados
experimentados em relao aos outros. Em dados do mesmo tamanho, o Quick Sort
executa mais rpido para dados ordenados, o Selection s ganha ou empata com o
Quick Sort em todos os casos em que o tamanho de dados foi de 100. O Bubble

27

Sort se demonstra o pior nos casos em ordem aleatria e decrescente, sendo

semelhante ao Selection apenas nos dados j ordenados.

Consideraes Finais
No trabalho foi apresentado o que so mtodos de ordenao, alguns dos mais
conhecidos, foi explicado como funcionam, seus desempenhos e foram tambm
aplicados na prtica em um programa. Em relao aos desempenhos dos mtodos,
o quick sort o algoritmo mais eficiente que existe para uma grande variedade de
situaes, recursivo, o que demanda uma pequena quantidade de memria
adicional.

28

Referncias Bibliogrficas
http://www.algolist.net/Algorithms/
http://wiki.icmc.usp.br/images/b/b3/SCC501Cap4.pdf
http://homepages.dcc.ufmg.br/~cunha/teaching/20121/aeds2/sortingcmp.pdf
http://opendevnotes.blogspot.com.br/2008/09/java-medir-tempo-de-execuo-detarefas.html

29

Cdigo Fonte

Classe principal: APS

/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package aps;
import javax.swing.JOptionPane;
import java.util.ArrayList;
/**
*
* @author Bruno
*/
public class APS {
//Bubble
static void Bubblesort(int [] vetor){

30

int n = vetor.length;
int MenorNumero;

for(int i=0; i < n; i++){

for(int j=1; j < (n-i); j++){

if(vetor[j-1] > vetor[j]){

MenorNumero = vetor[j-1];
vetor[j-1] = vetor[j];
vetor[j] = MenorNumero;
}

}
}
}

public static int[] SelectSort(int[] Vetor){

for (int i = 0; i < Vetor.length - 1; i++)

{
int aux = i;
for (int j = i + 1; j < Vetor.length; j++)
if (Vetor[j] < Vetor[aux])
31

aux = j;

int MenorNumero = Vetor[aux];

Vetor[aux] = Vetor[i];
Vetor[i] = MenorNumero;
}
return Vetor;

//QuickSort e seus 2 mtodos

int dividir(int vetor[], int esq, int dir)

{
int i = esq, j = dir;
int tmp;
int pivot = vetor[(esq + dir) / 2];

while (i <= j) {
while (vetor[i] < pivot)
i++;
while (vetor[j] > pivot)
j--;
32

if (i <= j) {
tmp = vetor[i];
vetor[i] = vetor[j];
vetor[j] = tmp;
i++;
j--;
}

return i;
}

void quickSort(int vetor[], int esq, int dir) {

int index = dividir(vetor, esq, dir);
if (esq < index - 1) {
quickSort(vetor, esq, index - 1);
}

if (index < dir) {

quickSort(vetor, index, dir);
}

}
33

public static void main(String[] args) {

String continuar="", opcao="";
int contador =0, i ,n;
long time = 0;
ArrayList vetororiginal = new ArrayList();

do {
opcao =JOptionPane.showInputDialog("Digite 1 para escolher os nmeros e 2
para usar nmeros aleatrios");

if (!opcao.equals("1") && !opcao.equals("2")) {

JOptionPane.showMessageDialog(null, "Opo inexistente, digite
novamente");
}
} while (!opcao.equals("1") && !opcao.equals("2"));

if (opcao.equals("1")) {

34

while (!continuar.equals("n")) {
vetororiginal.add(Integer.parseInt(JOptionPane.showInputDialog("Digite um
nmero")));
contador++;
continuar = JOptionPane.showInputDialog("Continuar? Pressione qualquer
tecla para sim ou N para nao");

}
n = contador;
int vetorordenado[] = new int[n];
for (i = 0;i<n;i++) {
vetorordenado[i] = Integer.parseInt(vetororiginal.get(i).toString());
}

do {
opcao = JOptionPane.showInputDialog("Digite 1 para Bubble Sort, 2 para
Selection Sort ou 3 para Quick Sort");

if (!opcao.equals("1") && !opcao.equals("2") && !opcao.equals("3")) {

JOptionPane.showMessageDialog(null, "Opo inexistente, digite
novamente");
}
} while (!opcao.equals("1") && !opcao.equals("2") && !opcao.equals("3"));
35

if (opcao.equals("1")) {
Chronometer.start();
Bubblesort(vetorordenado);
Chronometer.stop();
time = Chronometer.elapsedTime();

else {
if (opcao.equals("2")) {
Chronometer.start();
SelectSort(vetorordenado);
Chronometer.stop();
time = Chronometer.elapsedTime();
}

else {
APS ordenarQuick = new APS();
Chronometer.start();
ordenarQuick.quickSort(vetorordenado, 0, n-1);
Chronometer.stop();
time = Chronometer.elapsedTime();
}
36

System.out.println("v[i] = Original, Ordenado");

System.out.println("-------------------------");
for (i=0; i<vetororiginal.size(); i++) {
System.out.printf("v[%d] = %8s, %8d\n",i, vetororiginal.get(i).toString(),
vetorordenado[i]);
}

System.out.println("");

System.out.println("Tempo de ordenao: " + time +"ms");

}

//aleatorio
else {

n = Integer.parseInt(JOptionPane.showInputDialog("Digite a quantidade de
nmeros aleatrios"));
int x;
int vetorordenado[];
vetorordenado = new int[n];

for (i=0; i<n; i++) {

37

x = (int)Math.round(Math.random()*n); //o resultado desta expressao sera um

numero
vetororiginal.add(x)

// no intervalo de 0 ate 100

vetorordenado[i] = x;
}

do {
opcao = JOptionPane.showInputDialog("Digite 1 para Bubble Sort, 2 para
Selection Sort ou 3 para Quick Sort");

if (!opcao.equals("1") && !opcao.equals("2") && !opcao.equals("3")) {

JOptionPane.showMessageDialog(null, "Opo inexistente, digite
novamente");
}
} while (!opcao.equals("1") && !opcao.equals("2") && !opcao.equals("3"));

if (opcao.equals("1")) {
Chronometer.start();
Bubblesort(vetorordenado);
Chronometer.stop();
time = Chronometer.elapsedTime();
38

else {
if (opcao.equals("2")) {
Chronometer.start();
SelectSort(vetorordenado);
Chronometer.stop();
time = Chronometer.elapsedTime();
}

else {
APS ordenarQuick = new APS();
Chronometer.start();
ordenarQuick.quickSort(vetorordenado, 0, n-1);
Chronometer.stop();
time = Chronometer.elapsedTime();
}
}

System.out.println("v[i] = Original, Ordenado");

System.out.println("-------------------------");
for (i=0; i<vetororiginal.size(); i++) {
System.out.printf("v[%d] = %8s, %8d\n",i, vetororiginal.get(i).toString(),
vetorordenado[i]);
39

System.out.println("");

System.out.println("Tempo de ordenao: " + time +"ms");

Classe utilizada para cronometrar o tempo de ordenao:

/*
* To change this license header, choose License Headers in Pgina 40 de 42
Project Properties.
* To change this template file, choose Tools | Templates
40

* and open the template in the editor.

*/
package aps;

/**
*
* @author Bruno
*/
public final class Chronometer {

private static long startValue;

private static long stopValue;
private static long timeDiff;

/**
* Inicia a contagem temporal
*/
public static void start() {
startValue = System.currentTimeMillis();
stopValue = 0;
timeDiff = 0;
}

/**
* Calcula a diferena temporal
41

*/
public static void stop() {
stopValue = System.currentTimeMillis();
timeDiff = stopValue - startValue;
}

/**
* Retorna o diferena de tempo medida
* @return tempo em milisegundos
*/
public static long elapsedTime() {
return timeDiff;
}
}

42