[0]

Universidade Paulista
Campus: Goinia - Flamboyant
Departamento de Computao
Curso: CINCIAS DA COMPUTAO

Tema: DESENVOLVIMENTO DE SISTEMA PARA ANLISE

PERFORMACE DE ALGORITMOS DE ORDENAO DE DADOS

Relao de Alunos:

Las de Morais
R.A.: B41IAB-8
Lucas Aleixo Mendona
R.A.: B25444-0
Railton Brito Oliveira
R.A.: B47294-4
Rodrigo Marinho
R.A.: B233HC-0

DE

[1]

NDICE
Objetivo do Trabalho..................................................................................pg. 2
Introduo..................................................................................................pg. 3
Referencial Terico..............................................................................pg. 4 a 6
Desenvolvimento................................................................................pg. 7 a 21
Resultados e Discusso....................................................................pg. 20 a 27
Consideraes Finais................................................................................pg. 28
Referncias Bibliograficas.........................................................................pg. 29
Cdigo Fonte.....................................................................................pg. 30 a 41

[2]

OBJETIVO DO TRABALHO

O objetivo deste trabalho fazer com que se faa valer o contedo

lecionado e adquirido em sala de aula e tambm disposto no site da
Universidade Paulista UNIP, nas aulas de Banco de Dados, Estrutura de
Dados, Linguagem da Programao Orientada a Objetos e o contedo
matemtico das aulas de Geometria Analtica e lgebra Linear, para que
possamos adquirir tambm conhecimento e que, ao final do curso, possamos
estar devidamente preparados para o mundo business, uma vez formados para
o concorrido mercado de trabalho.

[3]

INTRODUO

O Texto a seguir demonstra as vrias etapas de criao que contm o nosso

trabalho, partindo da ideia de um algoritmo capaz de gerar a ordenao, seja
de um simples caractere, seja de um arquivo, sendo ele informado pelo usurio
ordenadamente ou no.
Sendo enfim explicitado ao pblico alvo, assim como tambm o objetivo e a
importncia de um algoritmo de ordenao e os cdigos nela utilizados.
Todas as informaes a seguir so verdicas e algumas trabalhadas a partir de
autores como Paulo Azeredo.

[4]

REFERENCIAL TERICO

Apresentaremos ento as tcnicas e os algoritmos de ordenao escolhidos

para a realizao das Atividades Prticas Supervisionadas:

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. As suas caractersticas que o
menor nmero de trocas e comparaes entre os algoritmos de
ordenao O(n) quando o vetor est ordenado.

O Selection sort (do ingls, ordenao por seleo) um algoritmo de

ordenao baseado em se passar sempre o menor valor do vetor para a
primeira posio (ou o maior dependendo da ordem requerida), depois o
de segundo menor valor para a segunda posio, e assim feito
sucessivamente com os (n-1) elementos restantes, at os ltimos dois
elementos. O algoritmo possui complexidade O(n)enquanto que, por
exemplo, os algoritmos Heapsort e Mergesort possuem complexidades:
O algoritmo heapsort um algoritmo de ordenao generalista, e
faz parte da famlia de algoritmos de ordenao por seleo. Foi
desenvolvido em 1964 por Robert W. Floyd e J.W.J. Williams.
Tem um desempenho em tempo de execuo muito bom em
conjuntos ordenados aleatoriamente, tem um uso de memria
bem comportado e o seu desempenho em pior cenrio
praticamente igual ao desempenho em cenrio mdio. Alguns
algoritmos de ordenao rpidos tm desempenhos
espectacularmente ruins no pior cenrio, quer em tempo de
execuo, quer no uso da memria. O Heapsort trabalha no lugar
e o tempo de execuo em pior cenrio para ordenar n elementos
de O (n lg n). L-se logaritmo (ou log) de "n" na base 2. Para

[5]
valores de n, razoavelmente grande, o termo lg n quase
constante, de modo que o tempo de ordenao quase linear
com o nmero de itens a ordenar. Comparaes no pior caso: 2n
log2n + O(n) o mesmo que 2n lgn + O(n); Trocas no pior caso: n
log2n + O(n) o mesmo que n lgn + O(n); Melhor e pior caso: O(n
log2n) o mesmo que O(n lgn). O heapsort utiliza uma estrutura
de dados chamada heap, para ordenar os elementos a medida
que os insere na estrutura. Assim, ao final das inseres, os
elementos podem ser sucessivamente removidos da raiz da heap,
na ordem desejada, lembrando-se sempre de manter a
propriedade de max-heap. A heap pode ser representada como
uma rvore (uma rvore binria com propriedades especiais 2 ) ou
como um vetor. Para uma ordenao crescente, deve ser
construdo uma heap mnima (o menor elemento fica na raiz).
Para uma ordenao decrescente, deve ser construdo uma heap
mxima (o maior elemento fica na raiz).
O merge sort, ou ordenao por mistura, um exemplo de
algoritmo de ordenao do tipo dividir-para-conquistar. Sua ideia
bsica consiste em Dividir(o problema em vrios sub-problemas e
resolver esses sub-problemas atravs da recursividade) e
Conquistar(aps todos os sub-problemas 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. Nele, possvel
implementar o merge sort utilizando somente um vetor auxiliar ao
longo de toda a execuo, tornando assim a complexidade de
espao adicional igual a (n log n). possvel tambm
implementar o algoritmo com espao adicional (1), e foi criado
por Von Neumann em 1945. Os trs passos teis dos algoritmos
dividir-para-conquistar, ou divide and conquer, que se aplicam ao
merge sort so:
1. Dividir: Dividir os dados em subsequncias pequenas;
2. Conquistar: Classificar as duas metades recursivamente
aplicando o merge sort;
3. Combinar: Juntar as duas metades em um nico
conjunto j classificado.

[6]

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 algoritmo Comb sort (ou Combo sort ou ainda algoritmo do pente1 )

um algoritmo de ordenao relativamente simples, e faz parte da famlia
de algoritmos de ordenao por troca. Foi desenvolvido em 1980 por
Wlodzimierz Dobosiewicz. Mais tarde, foi redescoberto e popularizado
por Stephen Lacey e Richard Box em um artigo publicado na revista
Byte em Abril de 1991. O Comb sort melhora o Bubble sort, e rivaliza
com algoritmos como o Quicksort. A idia bsica eliminar as tartarugas
ou pequenos valores prximos do final da lista, j que em um bubble sort
estes retardam a classificao tremendamente. (Coelhos, grandes
valores em torno do incio da lista, no representam um problema no
bubble sort). O Algoritmo repetidamente reordena diferentes pares de
itens, separados por um salto, que calculado a cada passagem.
Mtodo semelhante ao Bubble Sort, porm mais eficiente. Na Bubble
sort, quando quaisquer dois elementos so comparados, eles sempre
tm um gap (distncia um do outro) de 1. A idia bsica do Comb sort
que a diferena pode ser muito mais do que um. (O Shell sort tambm
baseado nesta idia, mas uma modificao do insertion sort em vez do
bubble sort). O gap (intervalo) comea como o comprimento da lista a
ser ordenada dividida pelo fator de encolhimento (em geral 1,3; veja
abaixo), e a lista ordenada com este valor (arredondado para um
inteiro se for necessrio) para o gap. Ento, a diferena dividida pelo
fator de encolhimento novamente, a lista ordenada com este novo gap,
e o processo se repete at que a diferena seja de 1. Neste ponto, o
Comb sort continua usando um espao de 1 at que a lista esteja
totalmente ordenada. A fase final da classificao , portanto,
equivalente a um bubble sort, mas desta vez a maioria dos elementos
"tartarugas" j foram tratados, assim o bubble sort ser eficiente.

[7]

O ALGORITMO DE ORDENAO

Durante a Histria da Computao um dos maiores desafios encontrados

como processar a maior quantidade de dados no menor intervalo de tempo
possvel. Entre as vrias formas de providenciar esse processamento, uma das
mais efetivas pela ordenao dos mesmos.
Considerando-se que a ordenao seja o ato de rearranjar um conjunto de
objetos em ordem ascendente ou descendente, e tambm a consulta e
manipulao desses dados ordenados, julga-se mais fcil processar
determinados dados que j se encontram ordenados sob algum tipo de critrio.

Ordenao interna: So mtodos que no precisam de uma memria

secundaria no processo, ou seja, o processamento feito apenas na
memria principal do computador, sem necessidade de memria
secundria ou se armazenamento.
Ordenao Externa: Quando o arquivo a ser ordenado no cabe na
memria principal do computador, e por isso precisa ser armazenado em
fita ou em disco.

A principal diferena entre a Ordenao Interna e a Externa que na

Ordenao Interna as informaes podem ser acessadas diretamente
enquanto na Ordenao Externa a informao acessada em blocos.
A ordenao em si, que o objeto dessa resenha, possui vrios mtodos de
execuo. Esses mtodos so divididos em dois grandes grupos no tocante ao
tipo de ordenao/armazenamento e aps isso ainda podem ser classificadas
como simples ou avanadas:
Esta anlise ter foco apenas nos tipos de ordenao interna, sendo que
desses mtodos, trs sero selecionados para a implementao do projeto.

Falaremos detalhadamente sobre cada um deles, separando-os por:

[8]
Tipos de Ordenao Simples:

Insertion Sort
Selection Sort
Bubble Sort
Comb Sort

Tipos de Ordenao Avanados:

Shell Sort
Quick Sort
Heap Sort
Merge Sort

Insertion Sort: Ou Ordenao por Insero uma forma simples de ordenao,

utilizada com facilidade quando aplicada a um nmero limitado de elementos.
Trata-se de um algoritmo onde o elemento retirado de sua posio, sendo
imediatamente inserido no ponto da sequncia onde deveria estar. Dessa
forma o vetor vai sendo ordenado da esquerda para a direita medida que vai
sendo percorrido.

[9]
Implementao Java:
package ordenacao;
public class InsertionSort {
public static void main(String[] args) {

int vetor[] = {22,9,7,6,1,49,35,3,0,42};

int chave;
int i;

System.out.println("Vetor no ordenado: ");

for(int j = 0; j < vetor.length; j++) {
System.out.print(vetor[j] + "\t");
chave = vetor[j];
i = j - 1;
while (i >= 0 && vetor[i] > chave) {
vetor[i+1] = vetor[i];
i = i-1;
}
vetor[i+1] = chave;
}

// imprime todos os elementos da lista reordenada

System.out.println("\n");
System.out.println("Vetor ordenado:");
for(int j = 0; j < vetor.length; j++) {
System.out.print(vetor[j] + "\t");
}

[10]
}
}

Selection Sort: Ou Ordenao por Seleo o algoritmo cujo menor objeto do

grupo sempre passado para a primeira posio do vetor, o segundo menor
para a segunda posio do vetor e assim sucessivamente, at os dois ltimos
elementos. A principal diferena desse mtodo em relao ao Insertion Sort e
ao Bubble Sort que ele realiza apenas uma troca por iterao.

Implementao Java:
package ordenacao;

public class SelectionSort {

public static void main(String[] args) {
int aux;

[11]
int menor;

int a [] = {12,7,4,50,8,15,30,8,15,30,21,18,1};

System.out.println("Vetor no ordenado: ");

for (int i = 0; i < 9; i++) {
menor = i;
System.out.print(a[i] + "\t");
for (int j = 0; j < 9; j++) {
if (a[menor] > a[j]) {
menor = j;
}
if (menor != i) {
aux = a[menor];
a[menor] = a[i];
a[i] = aux;
}
}
}
System.out.println("\n");
System.out.println("Vetor ordenado:");
for (int i = 0; i < 9; i++) {
System.out.print(a[i] + "\t");
}
}
}

[12]
Bubble Sort: Ou Ordenao por Flutuao o algoritmo simples que percorre
vrias vezes o vetor, de forma que a cada passagem o maior elemento da
sequncia flutua para o topo da mesma. Seu uso no recomendado para
sequncias com muitos elementos devido quantidade de passagens que
seriam necessrias para finalizar a ordenao.
Abaixo um exemplo de ordenao Bubble Sort

Implementao Java:
package ordenacao;
public class BubbleSort {
public static void main(String args[]){
int[] vet = {8, 9, 3, 5, 1};
int aux = 0;
int i = 0;

System.out.println("Vetor no ordenado: ");

for(i = 0; i<5; i++){
System.out.print(vet[i] + "\t");
}

[13]
for(i = 0; i<5; i++){
for(int j = 0; j<4; j++){
if(vet[j] > vet[j + 1]){
aux = vet[j];
vet[j] = vet[j+1];
vet[j+1] = aux;
}
}
}
System.out.println("\n");
System.out.println("Vetor ordenado:");
for(i = 0; i<5; i++){
System.out.print(vet[i] + "\t");
}
}
}

Comb Sort: Ou Ordenao do Pente um algoritmo de ordenao por troca.

Ele melhora o Bubble Sort eliminando os pequenos valores no fim da lista, e
assim reduzindo o tempo necessrio para execuo do algoritmo.
O algoritmo repetidamente reordena diferentes pares de itens, separados por
um salto, que calculado a cada passagem. Mtodo semelhante ao Bubble
Sort, porm mais eficiente. Apesar disso o Comb Sort uma variao do
algoritmo Insertion Sort, e no do Bubble Sort.

[14]
Implementao Java:
package ordenacao;

import java.util.ArrayList;

public class CombSort {

public CombSort() {
super();
}

public ArrayList<Integer> combSort(ArrayList<Integer> sortMe) {

int swap;
int size = sortMe.size();
int gap = size;
boolean swapped = false;

while ((gap > 1) || swapped) {

if (gap > 1) {
gap = (int) ((double)gap / 1.247330950103979);
}

swapped = false;

for (int i = 0; gap + i < size; ++i) {

// Trocando o sinal de > ou < o vetor muda para
crescente ou decrescente.
if (sortMe.get(i) - sortMe.get(i + gap) > 0) {

[15]
swap = sortMe.get(i);
sortMe.set(i, sortMe.get(i + gap));
sortMe.set(i + gap, swap);
swapped = true;
}
}
}
return sortMe;
}

public static void main(String[] args) {

ArrayList<Integer> randomArrayList = new ArrayList<Integer>(7);
randomArrayList.add(5);
randomArrayList.add(7);
randomArrayList.add(2);
randomArrayList.add(6);
randomArrayList.add(8);
randomArrayList.add(1);
randomArrayList.add(9);
CombSort combSorter = new CombSort();
System.out.println("Vetor no ordenado:");
System.out.println((randomArrayList).toString());
System.out.println();
System.out.println("Vetor ordenado:");
System.out.println(combSorter.combSort(randomArrayList).toString());
}
}

[16]
Shell Sort: Criada como um refinamento do algoritmo de insero direta por
Donald Shell, esse mtodo divide o array em vrios segmentos e aplica a
insero direta a cada um deles, ou seja, o algoritmo passa vrias vezes pela
lista, dividindo o grupo maior em grupos menores, aplicando a insero direta a
cada um desses grupos menores. A figura abaixo ilustra o funcionamento do
algoritmo.

Implementao Java:
package ordenacao;

public class ShellSort {

public static void main(String args[]) {
int[] array = new int[] { 3, 2, 5, 4, 1 };
int i1, i, j, increment, temp, number_of_elements = array.length;

[17]
System.out.println("Vetor no ordenado: ");
for(i = 0; i<5; i++){
System.out.print(array[i] + "\t");
}

for (increment = number_of_elements / 2; increment > 0;

increment /= 2) {
for (i = increment; i < number_of_elements; i++) {
temp = array[i];
for (j = i; j >= increment; j -= increment) {
if (temp < array[j - increment]) {
array[j] = array[j - increment];
} else {
break;
}
}
array[j] = temp;
}
}
System.out.println("\n");
System.out.println("Vetor ordenado:");
for (i1 = 0; i1 < 5; i1++) {
System.out.print(array[i1] + "\t");
}
}
}

[18]
Quick Sort: o algoritmo de ordenao interna mais rpido de que se tem
conhecimento, alm de, provavelmente ser m mais utilizado. Elaborado por
C.A.R. Hoare em 1960, o Quick Sort utiliza uma tcnica de dividir o problema
inicial em dois subproblemas e resolver um problema menor utilizando a
recursividade. Entretanto, em alguns casos especiais, como na diviso de
parties desequilibradas, a ordenao pode ficar excepcionalmente lenta.

[19]
Implementao Java:
package ordenacao;

public class QuickSort {

public static void main(String a[]){
int i;
int array[] = {1,9,4,3,13,11,2,22,0};
System.out.println("Vetor no ordenado: ");
for(i = 0; i < array.length; i++)
System.out.print(array[i] + "\t");
System.out.println("\n");
System.out.println("Vetor ordenado:");
quick_srt(array,0,array.length-1);
for(i = 0; i <array.length; i++)
System.out.print(array[i] + "\t");
}

public static void quick_srt(int array[],int low, int n){

int lo = low;
int hi = n;
if (lo >= n) {
return;
}
int mid = array[(lo + hi) / 2];
while (lo < hi) {
while (lo<hi && array[lo] < mid) {
lo++;

[20]
}
while (lo<hi && array[hi] > mid) {
hi--;
}
if (lo < hi) {
int T = array[lo];
array[lo] = array[hi];
array[hi] = T;
}
}
if (hi < lo) {
int T = hi;
hi = lo;
lo = T;
}
quick_srt(array, low, lo);
quick_srt(array, lo == low ? lo+1 : lo, n);
}
}

[21]
Heap Sort: Esse mtodo usa o mesmo principio do Select Sort, o Heap Sort
utiliza uma estrutura conhecida como Heap binrio para manter o prximo item
a ser selecionado.
Dos mtodos exemplificados acima, segue um quadro explicativo, sobre as
questes de complexidade e estabilidade de cada um:

Mtodo

Complexidade M(n)

Insertion Sort
Selection Sort
Bubble Sort
Comb Sort
Shell Sort
Quick Sort
Heap Sort
Merge Sort

(n-n)/2

Ordem de complexidade M(n)

Estabilidade

[22]

RESULTADOS E DISCUSSO

O programa foi desenvolvido utilizando um processo simples de

ordenao de nmeros, primeiramente o usurio deve digitar um nmero alto
(acima de 100.000), para isso foi utilizado classe Scanner para que o usurio
pudesse fazer a entrada via teclado, ao digitar o nmero ser gravada em uma
varivel o tempo atual com o mtodo TempoCompilacao no que foi iniciado o
mtodo de contagem no caso utilizamos a varivel run, feito isso o programa
decrementara o numero digitado de 1 em 1 atravs do comando for() at que o
mesmo chegue em 0, logo aps ser feita a anlise atravs do mtodo
TempoCompilacao do tempo em que o mtodo for() terminou de fazer a
contagem e ento gravamos na varivel run subtraindo o valor da varivel
final pelo valor da varivel agora e ento exibimos o resultado do tempo
decorrido para que o programa levou para chegar ao fim da sua contagem,
completando assim a anlise de desempenho do algoritmo.
Foram testados os trs mtodos de ordenao, para cada mtodo foi
testado um tamanho diferente de vetor (100, 1.000, 10.000, 100.000) e para
cada tamanho um tipo diferente (Ordenado Crescente, Ordenado Decrescente,
Ordenado Aleatrio e parcialmente Aleatrio).
Outro ponto abordado em nosso trabalho foi a comparao dos trs
modelos de algoritmos, de modo que constatssemos os mais eficientes,
velozes e que exigissem menos da maquina, e para comprovao das teorias
aqui apresentadas, realizaremos testes de desempenho com os algoritmos,
que vo desde ordenao de 100 algarismos a 2.000.000 de algarismos os
elementos do vetor so analisados do incio at o final e os pares de elementos
adjacentes so comparados e ordenados, caso estejam fora de ordem. Deste
modo, os elementos maiores vo sendo empurrados para o fim do vetor da
mesma forma como as bolhas na gua so empurradas para cima. Da vem o

[23]
nome de ordenao pelo mtodo da bolha. Para melhor exemplificar o mtodo
bolha, segue abaixo um modelo de vetor que ser ordenado.
Aps a primeira etapa, o que se verifica que ocorreu uma pequena
mudana nas posies antes registradas. O Processo segue at os algarismos
estarem em ordem, o que pode levar um grande tempo quando se tratando de
muitos nmeros, fazendo assim, com que o bubble seja um dos mtodos mais
conhecidos, porem menos utilizados.
A estratgia consiste em reorganizar as chaves de modo que as chaves
"menores" antecedam 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. Os passos so: 1. Escolha um elemento da
lista, denominado piv; 2. Rearranje a lista de forma que todos os elementos
anteriores ao piv sejam menores que ele, e todos os elementos posteriores ao
piv sejam maiores que ele. Ao fim do processo o piv estar em sua posio
final e haver duas sublistas no ordenadas. Essa operao denominada
partio; 3. Recursivamente ordene a sublista dos elementos menores e a
sublista dos elementos maiores.
A base da recurso so as listas de tamanho zero ou um, que esto
sempre ordenadas. O processo finito, pois a cada iterao pelo menos um
elemento posto em sua posio final e no ser mais manipulado na iterao
seguinte.
Em cincia da computao, um algoritmo de ordenao um algoritmo
que coloca elementos de uma lista numa determinada ordem. As ordenaes
mais usadas so as numricas e as lexicogrficas. A ordenao eficiente
importante para otimizar o uso de outros algoritmos que necessitam de listas
ordenadas de alguma maneira para funcionarem corretamente. Devido ao
limitado uso de ordenao nos algoritmos utilizados, viu-se a necessidade de
estudar atentamente os algoritmos de ordenao Bubblesort e Quicksort.
Bubblesort um mtodo de ordenao de dados bem direto e simples,
utilizado amplamente no ensino de algoritmos de ordenao. O algoritmo
comea no incio do conjunto de dados, compara os dois primeiros elementos,
e se o primeiro maior que o segundo, troca as posies dos mesmos. Isso
continua para cada par de elementos adjacentes at o final do conjunto de
dados. Ento, comea novamente com os dois primeiros elementos, repetindo

[24]
at que nenhuma troca de posio tenha ocorrido na ltima passagem.
Enquanto que simples, o algoritmo extremamente ineficiente e raramente
usado, a no ser em educao.
J o Quicksort um algoritmo que segue o princpio de dividir para
conquistar, que tem por base operaes de particionamento: para particionar
uma lista, escolhe-se um elemento, chamado piv, movem-se todos os
elementos.
Atravs dos estudos bibliogrficos e de projeto desenvolvidos, foi
possvel analisar e validar satisfatoriamente algoritmos eficientes e seguros
para comutao automtica de ordenao. Foi notrio o fato de que algumas
tecnologias antes no previstas tiveram que ser adicionadas para estudo ao
longo do decorrer do projeto, ao passo que outras no foram to necessrias.
No obstante, todas tiveram crucial validade na pesquisa realizada.
Durante a realizao da pesquisa, pode-se notar que a anlise de mais
um tipo de abordagem bastante vlida, em termos de comparao de
performance, especialmente em se tratando de algoritmos. Alm disso, atravs
do estudo de caso feito com sucesso, onde se escreveu cerca de mil linhas de
cdigo em linguagem Java, ficou clara a enorme importncia dos diagramas
UML e de todo o processo de Engenharia de Software utilizado para a
concluso do projeto.
Ao final deste trabalho, tendo em vista os resultados obtidos, observouse que o cronograma definido na proposta da presente pesquisa foi
devidamente cumprido, o que possibilitou ao pesquisador efetuar, de forma
eficiente, a sua capacitao nas tecnologias envolvidas, bem como realizar um
estudo de caso vlido menor que o piv para antes dele e todos os maiores
para depois dele. Aps um particionamento, o algoritmo ordena recursivamente
as sublistas menores e maiores.
Implementaes eficientes do Quicksort so tipicamente ordenaes
instveis e de certa forma complexas, mas est entre os algoritmos de
ordenao mais rpidos na prtica, o que torna o Quicksort um dos algoritmos
de ordenao mais populares atualmente. O ponto mais complexo do Quicksort
reside na escolha de um bom elemento piv, constantemente escolhas erradas
de pivs podem resultar numa performance bastante lenta, no entanto, se a

[25]
cada passo da recurso do algoritmo, o elemento mediano escolhido como
piv, o algoritmo tem tima performance.
Aps comparao de eficincia, e devido ao destino no projeto do
algoritmo de comutao automtica, optou-se pela utilizao do Quicksort
como algoritmo de ordenao, sendo que o mesmo ser utilizado para o tipo
double.
A anlise deve ser feita sobre o nmero de comparaes, atribuies e
tempo de execuo dos algoritmos. Procure organizar inteligentemente os
dados coletados em tabelas, e tambm construa grficos a partir dos dados.
Ento, disserte sobre os dados nas tabelas e grficos. Grande parte da
avaliao ser realizada sobre a anlise dos resultados, ou seja, sobre o que
voc dissertar.
Neste trabalho, esto sendo disponibilizadas (no site da disciplina)
implementaes de algoritmos a serem utilizados para anlise da segunda
parte do trabalho.
A compilao, interpretao e uso deste cdigo constitui parte da
avaliao deste trabalho prtico. A implementao dos outros algoritmos a
serem utilizados na primeira parte fica por sua conta. Voc dever entender o
padro de programao do cdigo fornecido e implementar os novos
algoritmos seguindo esse padro.
Uma parte crucial do algoritmo a funo partio que tm que
rearranjar o vetor, dadas suas posies inicial e final, por meio da escolha de
um elemento piv, de tal forma que ao final os elementos menores que o piv
est a sua esquerda e os elementos maiores esto a sua direita.
Foram executados alguns testes para vetores de 10, 100, 1000, 10000 e
100000 elementos ordenados, quase ordenados, aleatrios e inversamente
ordenados.
Este trabalho possibilitou um aprofundamento sobre os algoritmos de
ordenao vistos em sala de aula bem como a anlise do nmero de
atribuies, comparaes e tempo de execuo de forma bem eficiente. Pelos
testes executados pde-se concluir que:
- Vale a pena inserir a verificao de ordenao (houve troca) no algoritmo
BubbleSort;
- No vale a pena usar o algoritmo InsertSort com elemento sentinela;

[26]
- Vale a pena inserir uma verificao (Min == i) para evitar a troca, no mtodo
SelectSort.
- O QuickSort o algoritmo mais eficiente para ordenar vetores de grandes
Dimenses.
- Vale a pena usar os algoritmos simples at vetores de 70 elementos, acima
desse valor deve-s usar os algoritmos eficientes.
As dificuldades encontradas foram devido ao fato haver vrias alteraes no
cdigo, implementao do InsertSort com cursores e de gerar os grficos com
eficincia.
As mesmas foram sanadas com o auxilio da bibliografia citada e a ajuda
do professor e monitores.
O conceito do nosso algoritmo e de como desenvolv-lo tratando do
assunto em aulas com natureza terica acompanhadas da aplicao prtica, de
forma paralela. Esta disciplina aborda o estudo da programao de
computadores dentro do paradigma procedural estruturado, envolvendo os
conceitos bsicos de lgica de programao, como conceitos de variveis,
tipos de dados, constantes, operadores aritmticos, expresses, atribuio,
estruturas de controle, modulao de algoritmos e noes de tipos compostos
de dados. Para atingir o objetivo de capacitar o aluno a construir programas
estruturados de dificuldade simples/ mediana, utiliza uma linguagem de
programao (Linguagem C/C++), com reconhecidas aplicaes desenvolvidas
tanto para o mercado de trabalho como para a rea cientfica.
considerada a tecnologia da cincia, auxilia a pesquisa desde o seu
planejamento at a interpretao dos dados, atravs da construo e anlise
de tabelas e grficos. Apresenta ao aluno uma tcnica de coleta e
apresentao de dados atravs das principais medidas de posio (mdia
aritmtica, moda e mediana) e de disperso (desvio padro e varincia).
Oferece

uma

ferramenta

estocsticos),

de

modelagem

de

(probabilidade
anlise

processos
indutiva

(inferncia: testes e estimao) e de previso e controle (verificao). Utiliza

uma matemtica adequada aos objetivos da rea, priorizando o aprendizado
dos conceitos de estatstica ao invs de um processo decorativo.
A

funo

de desenvolvimento

de sistemas

de informao tem

a responsabilidade geral de desenvolver, implementar e coordenar uma

[27]
infraestrutura

de

tecnologia

da

informao (computadores

e comunicao), dados (internos e externos) e sistemas que abrangem toda

a organizao. Tem a responsabilidade de fazer prospeco de novas
tecnologias

da informao e

estratgias, planejamento e

auxiliar na sua

prticas

da

incorporao s

organizao. A funo tambm

apoia sistemas de tecnologia da informao departamentais e individuais.

A atividade

de

desenvolvimento de

organizacionais

sistemas para processos

interorganizacionais envolve o uso

criativo de tecnologia da informao para aquisio de dados,

coordenao,

anlise

e apoio

deciso.

H mtodos,

tecnologia e metodologias para essa atividade. A criao de

organizaes inclui questes de inovao,
mquina,

interfaces

homem

gerenciamento de mudanas.

por todas as funes organizacionais.

sistemas

tcnicas,

sistemas em

qualidade, sistemas homem

mquina, projetos
Os

comunicao,

scio

tcnicos e

de informao so difundidos

[28]

CONSIDERAES FINAIS

Conclumos ento que, a incumbida tarefa de realizar este trabalho nos

proporcionou uma forma de conhecimento da qual no tnhamos
conhecimento, e que podemos tambm dizer que existem vrias razes para
se ordenar uma sequncia, sendo que uma das principais a possibilidade se
acessar seus dados de modo mais eficiente, e, com este trabalho, aprendemos
que podemos encontrar mais de uma forma para fazer com que o programa
proposto a ser desenvolvido encontre o valor desejado, com diferentes formas
de ordenao, e que os resultados grficos para isso podem variar, de acordo
com o tipo de ordenao escolhida para tal.

[29]

REFERNCIAS BIBLIOGRFICAS

Bubble Sort - http://www.devmedia.com.br/entendendo-o-algoritmo-bubble-sortem-java/24812

Comb Sort - http://www.guj.com.br/java/280462-comb-sort-o-que-e-e-comofazer
Heap
Sort
ftp://ftp.awl.com/cseng/authors/gaddismuganda/Source_Code/Chapter
%2022/Heapsort.java
Insertion
Sort
insertion-sort/

http://www.flaviamissi.com.br/algoritmos-de-ordenacao-

Merge Sort - http://www.roseindia.net/

Quick Sort- http://www.roseindia.net/
Selection Sort - AZEREDO, Paulo A.. Mtodos de Classificao de Dados e
Anlise de suas Complexidades
Shell Sort - http://forgetcode.com/Java/1327-Shell-Sort

[30]

CDIGO FONTE

O programa realizado constitudo de um total de dez classes. So estas:

AdicionaBancoDados.java

package geoprocessamento;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

public class AdicionaBancoDados {

private Connection conexao;

public AdicionaBancoDados() throws SQLException {

this.conexao = ConexaoMysql.getConnection();
}

public List<BuscaInformacao> getTodosarquivos() throws SQLException

{

[31]
String sql = "select * from busca order by 1";
PreparedStatement stmt = conexao.prepareStatement(sql);
ResultSet rs = stmt.executeQuery();
List<BuscaInformacao>
ArrayList<BuscaInformacao>();

buscaList

new

while (rs.next()) {
buscaList.add(new
rs.getString("dsbusca")));
}

rs.close();
stmt.close();

return buscaList;
}
}

BuscaBancoDados.java

package geoprocessamento;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

public class BuscaBancoDados {

BuscaInformacao(rs.getInt("idbusca"),

[32]
private Connection connection;
private BuscaInformacao busca;

public void BuscaDAO() throws SQLException {

this.connection = ConexaoMysql.getConnection();
}

public BuscaInformacao
throws SQLException {

buscaArquivos(BuscaInformacao

arquivos)

PreparedStatement
stmt
=
(PreparedStatement)
this.connection.prepareStatement("SELECT * FROM contato WHERE nome
like ?%");
stmt.setString(1, BuscaInformacao.getNome());
ResultSet rs = (ResultSet) stmt.executeQuery();
while(rs.next()) {
BuscaInformacao.setNome(rs.getString("Nome"));
System.out.print(rs.getString("Nome"));
}

rs.close();
stmt.close();
connection.close();
return busca;
}
}
BuscaBinaria.java
package geoprocessamento;
import java.util.ArrayList;

[33]
import java.util.List;

public class BuscaBinaria {

List<id> buscaList = new ArrayList<id>();

public static boolean buscabinaria(int vet[],int x) {

final int n = vet.length;
int inicio = 0,fim = n-1, meio;

while (inicio <= fim) {

meio = (inicio + fim) / 2;
if (x == vet[meio])
return true;
else
if (vet[meio] < x)
inicio = meio+1;
else
fim = meio-1;
}
return false;
}

public static class id {

public id() {

}
}

[34]
}

BuscaInformacao.java

package geoprocessamento;

public class BuscaInformacao {

public static String getNome() {

throw new UnsupportedOperationException("Sem suporte");
}

public static void setNome(String string) {

throw new UnsupportedOperationException("Sem suporte");
}

BuscaInformacao(int aInt, String string) {

throw new UnsupportedOperationException("Sem suporte");
}
}
BuscaLista.java
package geoprocessamento;
import java.io.FileReader;
import java.util.ArrayList;
import java.util.Scanner;

public class BuscaLista {

[35]
public static void main(String[] args) throws Exception {
ListaCampos list = null;
ArrayList<ListaCampos>
ArrayList<ListaCampos>();

Resultado

ArrayList<String> teste = new ArrayList<String>();

FileReader file = new FileReader("User-PC/busca.txt");
Scanner in = new Scanner(file);
String b = "";
String b1 = "";
String c = "";
String c1 = "";
String id= "";
String cincoAntes = "";

while(in.hasNext()) {
c = in.nextLine();
teste.add(c);
}

for (int i = 0; i < teste.size(); i++) {

String aux = teste.get(i).toLowerCase();
b1 = b;
b.replace('_', ' ');
String aux12 = " "+ b.toLowerCase() +" ";
if (aux.contains(aux12)) {
list = new ListaCampos(id,b1,c1, i, "busca");
list.setCincopalavras(cincoAntes);

new

[36]
Resultado.add(list);
}
}

for(ListaCampos aux: Resultado) {

System.out.println(aux.toString());
}

in.close();
file.close();
}
}
ConexaoMysql.java

package geoprocessamento;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class ConexaoMysql {

public static Connection getConnection() throws SQLException {

try {
Class.forName("com.mysql.jdbc.Driver");
return
PC/busca", "aps", "1234");

DriverManager.getConnection("jdbc:mysql://User-

} catch (ClassNotFoundException e){

[37]
throw new SQLException(e.getMessage());
}
}
}

FazerBusca.java

package geoprocessamento;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;
import java.util.Date;
import java.util.Timer;

public class FazerBusca {

private static int QuantidadedeID;
private static double escolha;
private static char opcao;
private static BuscaBancoDados BuscaBancoDados;
private static BuscaLista BuscaLista;

public static void main ( String args [] ) {

Scanner enter = new Scanner(System.in);

[38]
System.out.print("Escolha Sua Opo:
Binria\n2: Busca DAO \n3: Busca Array List\n");

\n\n1:

Busca

Tipo

opcao = enter.nextLine().charAt(0);
Timer timer = new Timer();
Date data = new Date();
timer.schedule(new TempoCompilacao(), 1000, 1000);

switch (opcao) {

case 1:
List<BuscaBinaria.id>
ArrayList<BuscaBinaria.id>();

buscaLista

new

BufferedReader entrada;
entrada
InputStreamReader(System.in));

new

BufferedReader(new

int vetor[], i, z;
final int n;
try {
n = QuantidadedeID;
vetor = new int[ n ];
for(i = 0; i < vetor.length; i++ ){
System.out.print("Entre

com o ID a ser

pesquisado:\n");
vetor[i] = Integer.parseInt(entrada.readLine());
}
Arrays.sort(vetor);
System.out.print("\nDigite o nmero que voc quer
buscar:\n");
z = Integer.parseInt(entrada.readLine());

[39]
if(buscabinaria(vetor, z))
System.out.print("\nValor Encontrado\n");
else
System.out.print("\nValor No Encontrado\n");
}
catch (Exception e) {
System.out.println("Ocorreu

um

erro

durante

leitura!");
}
break;

case 2:
BuscaBancoDados = new BuscaBancoDados();
break;

case 3:
BuscaLista = new BuscaLista();
break;

default: System.out.println("Erro de Opo");

}
}

private static boolean buscabinaria(int[] vetor, int z) {

throw new UnsupportedOperationException("Sem suporte");
}
}

[40]

ListaCampos.java

package geoprocessamento;

public class ListaCampos {

public ListaCampos() {
}

public ListaCampos(String id, String b1, String c1, int i, String texto) {
throw new UnsupportedOperationException("Sem suporte");
}

public void setCincopalavras(String cincoAntes) {

throw new UnsupportedOperationException("Sem suporte");
}
}

Resultado.java

package geoprocessamento;

public class Resultado {

public Resultado() {
}
}

[41]
TempoCompilacao.java

package geoprocessamento;
import java.util.TimerTask;

public class TempoCompilacao extends TimerTask {

private int hora = 0;
private int minuto = 0;
private int segundo = 0;

public void run() {

System.out.println(hora + ":" + minuto + ":" + segundo);
segundo++;
if ( segundo == 59 ) {
segundo = 0;
minuto++;
if ( minuto == 59 ) {
minuto = 0;
hora++;
if ( hora == 23 ) {
hora = 0;
}
}
}
}
}