Você está na página 1de 10

ANHANGUERA EDUCACIONAL LTDA

FACULDADE ANHANGUERA DE SO JOS DOS CAMPOS


CINCIA DA COMPUTAO

ATPS Programao Orientada a objetos I

Prof. Monalisa

So Jos dos Campos, 7 de abril de 2015


Sumrio

RELATRIO 1 PESQUISA DE
DADOS.............................................................................................. pg. 3
CDIGO
USADO...................................................................................................................
pg. 5

RELATRIO 2 MTODOS DE
ORDENAO.................................................................................... pg. 7

BIBLIOGRAFIA........................................................................................................
........................ pg. 10

RELATRIO 1 PESQUISA DE DADOS

Melhor desempenho computacional - Mtodo


Considerando os parmetros de testes definidos, foi possvel identificar que o melhor mtodo
de busca sem a ordenao dos dados o linear com sentinela, porm se o valor procurado no
estiver no vetor, o tempo e a quantidade de testes realizados sero exatamente iguais ao da
busca linear, pois a chave ser localizada apenas no final da base de dados.
O clculo de tempo foi realizado atravs da quantidade de ciclos do processador (clock), mas
como a base utilizada nos testes pequena o processo muito rpido para realizar uma
comparao precisa entre os algoritmos, alm de que foi possvel notar que os valores
definidos para busca no ATPS no esto disponveis aps a gerao dos nmeros aleatrios e
dessa forma os algoritmos de busca no localizaro os valores o que forara percorrer o vetor
at o final.

Busca binria x busca linear x busca linear com sentinela Desempenho


Aps a ordenao dos dados fica claro que o melhor mtodo de busca a binria como mostra
a Figura 1, pois tanto o tempo quanto a quantidade de processamento muito menor do que as
outras tcnicas de busca.
O principal ponto se a ordenao da base de dados vivel para aplicar esse tipo de tcnica,
pois dependendo do tamanho da base a ordenao pode se tornar muito lenta e exigir muito
processamento.
A ordenao atravs de algoritmos como bubblesort e seleo demonstraram bons resultados,
mas ainda assim exigem mais processamento do que as buscas em bases que no foram
ordenadas, porem se a ordenao for realizada periodicamente ou no momento em que os
dados so inseridos a busca binria torna-se vivel, pois a localizao e o tempo de
processamento so muito mais rpidos do que as demais tcnicas.

TIPO DE TESTE

TAMANHO VETOR

QUANTIDADE TESTES

Busca Linear

1.000

1.000

Busca Linear com


Sentinela

1.000

1.000

Busca Binria

1.000

Bubble Sort

1.000

244.968

Seleo

1.000

56.738

Aps a realizao das baterias de testes foi possvel concluir que existem algoritmos de
localizao e ordenao mais eficientes do que outros, porm a aplicao e a utilizao de
cada um depende da situao e principalmente do tamanho da base de dados que ser
manipulada.
Considerando os parmetros utilizados nesses testes observamos que o melhor
comportamento dos algoritmos de ordenao e seleo foram obtidos pelo mtodo seleo e a
busca binria, mas isso no significa que so os melhores para todas as situaes, pois todos
possuem suas particularidades e deficincias.

CDIGO COMPLETO PARA USO DA BATERIA


/*
Name: ATPS - Classificao e Pesquisa
Description: Bateria de testes de busca linear, linear com sentinela e binria
ordenao bubble sort e seleo
*/
#include
#include
#include
#include
#define tempo 2000
#define search_p 87
#define search_s 100001
//prototipos das funes
void bateria_testes(int tam, int t);
void linear(int n, int t, int *p_int, double *p);
void linear_sentinela(int n, int t, int *p_int, double *p);
void binaria(int n, int t, int *p_int, double *p);
void bubblesort(int n, int t, int *p_int, double *p);
void selecao(int n, int t, int *p_int, double *p);
double unif(long int *seed, double low, double high);
int inteiros_unif(long int *seed, int low, int high);
main(){
//declarao de variaveis
int op=0, tipo;
while (op!=5){
system("cls");
//cabealho com os parametros de teste
printf("\n ATPS - Classifica%c%co e Pesquisa \n",135,198);
printf(" \n +------+--------+-----+--------+------------+----------+-------------+");
printf(" \n | OP | N | low | high | seed | N. Proc. | S. N. Proc. |");

printf(" \n +------+--------+-----+--------+------------+----------+-------------+");
printf(" \n | 01 | 100 | 0 | 100000 | 1234554321 | 87 | 100001 |");
printf(" \n +------+--------+-----+--------+------------+----------+-------------+");
printf(" \n | 02 | 1000 | 0 | 100000 | 1234554321 | 87 | 100001 |");
printf(" \n +------+--------+-----+--------+------------+----------+-------------+");
printf(" \n | 03 | 10000 | 0 | 100000 | 1234554321 | 87 | 100001 |");
printf(" \n +------+--------+-----+--------+------------+----------+-------------+");
printf(" \n | 04 | 100000 | 0 | 100000 | 1234554321 | 87 | 100001 |");
printf(" \n +------+--------+-----+--------+------------+----------+-------------+");
printf("\n\n Selecione os par%cmetros de teste [ 1 - 4 ]: ",131);
scanf("%d",&op);
if(op5){
printf("\n Opcao invalida !");
getch();
}
break;
}
}
}
/*-----------------------------------------------------------------------------Algoritmo 1 Gerador de nmeros reais aleatrios
Gerador de distribuicao uniforme retorna um numero
double (real com longa preciso) na faixa low high,ou seja, [low,high].
------------------------------------------------------------------------------*/
double unif(long int *seed, double low, double high){
double unif_ret;
long int m,a,b,c, k;
double value_0_1;
m = 2147483647;
a = 16807;
b = 127773;
c = 2836;
k = *seed/b;
*seed = a * (*seed % b) - k*c;
if (*seed

RELATRIO 2 MTODOS DE ORDENAO


O Quick Sort no melhor caso sempre escolhe o elemento mediano da sua lista de entrada
como piv. O pior caso do Quicksort justamente na pior escolha do piv: um elemento
extremo da lista (no incio ou no nal). Testes com entradas aleatrias e pivs escolhidos
aleatoriamente mostram que a complexidade do Quicksort, mesmo nestes casos, se aproxima
muito do tempo de O (n log n).
* melhor caso: O(n log n)
* pior caso: O(n2)
* caso mdio: O(n log n)
* No estvel
O Mergesort no melhor caso similar ao tempo do Quicksort com pouco mais de O(log n).
Qualquer que seja o caso ele sempre ter a complexidade de ordem n log n. Isso pelo motivo
de que o Mergesort independentemente em que situao se encontra o vetor, ele sempre ir
dividir e intercalar.
* melhor caso: O(n log n)
* pior caso: O(n log n)
* caso mdio: O(n log n)
* Estvel (Implementado corretamente)
O algoritmo de insero linear faz uma busca linear para encontrar a posio para fazer a
insero. No entanto, uma vez que o elemento inserido numa sequncia que j est
ordenada, o ideal usar uma pesquisa binria, em vez de uma busca linear. Considerando que
uma busca linear requer O(n) comparaes no pior caso, uma busca binria requer apenas
O(log n) comparaes.
* melhor caso: O(n log n)
* pior caso: O(n2)
* caso mdio: O(n2)
* Estvel
O algoritmo Quicksort, nos testes executados apresenta o maior nmero de comparaes e o
menor nmero de trocas. um algoritmo eficiente apesar do seu pior caso ser O(n2). O
Mergesort possui um pior caso O(n log n), no entanto utiliza memria auxiliar e possui um
alto consumo de memria. J o Insero Binria apresenta um pior caso O(n2), e mesmo
apresentando um melhor caso O(n log n) ainda sim um algoritmo de insero. Dessa forma
possvel inferir que o algoritmo Quicksort possivelmente o mais indicado para diversas
situaes.
O Comportamento do Quicksort demonstrado nas seguintes imagens.

(a) Melhor caso, quando os dados de entrada so aleatrios ou parcialmente ordenados e o


piv o registro do meio.
(b) Caso Mdio.
(c) Pior Caso, ocorre quando o vetor esta ordenado (asc. ou desc.). Dessa forma o algoritmo
ir particionar o arranjo com n elementos em 2 arranjos sendo 1 com n-1 elementos e outro
com apenas 1 elemento, diminuindo o problema em apenas 1 elemento.
Nesta etapa o desafio consiste em usar vrios algoritmos de ordenao e medir o desempenho
de cada um deles com tabelas de dados. Essas tabelas tero 500, 5000, 50000 de tamanho,
cada uma com trs instncias diferentes.
O desafio pede para usarmos novos valores para que as funes que geram nmeros aleatrios
possam variar de tabela para tabela. Para isso optamos pelos seguintes parmetros:
Valores usados para gerar os nmeros de cada instancia
Dentro do arquivo atpsData.h podemos encontrar a funo iniciarTabelas() que ser
responsvel por usar esses valores e preencher o total de nove instncias senda trs para cada
tamanho de tabela.
Ao executar o programa pela primeira vez nos deparamos com a opo de rodar a verso 1.0,
que tem todo o contedo da primeira etapa desse desafio ou a verso 2.0, essa sim nosso
objetivo principal nesse momento.
Primeira tela do sistema
Ao escolher a opo 2.0 do sistema, todas as instncias foram automaticamente geradas e as
tabelas esto disponveis para testes. Sendo assim s escolher o algoritmo a ser usado. No
exemplo abaixo vamos usar o quickSort como exemplo:
Menu para os algoritmos de ordenao
Quicksort selecionado
Com o tipo de algoritmo selecionado, vamos escolher o tipo de dados para o teste. De acordo
com o desafio, podemos testar o algoritmo com uma tabela com dados aleatrios, ascendentes
ou descendentes. Vamos escolher Dados Aleatrios, nesse momento o programa ir enviar
para o algoritmo todas as trs instancias de cada tabela e nos dar os resultados, como na
prxima imagem.
Resultado do quickSort para a ordenao das tabelas
Aps realizar teste com todos os algoritmos o grupo chegou a concluso de que, mesmo com
dados j ordenados de forma ascendente, descendente ou aleatrias os resultados foram bem
prximos. Levando em conta que todos os algoritmos so de ordenao, provavelmente em

um problema real a tabela a ser ordenada ser aleatria. Sendo assim os algoritmos com
melhor desempenho foram quickSort e mergeSort. Ambos apresentaram resultados rpidos e
com menor ndice de comparaes e trocas.

BIBLIOGRAFIA

Apostila de Algoritmo Estruturado


JUNIOR, J. M. R. S. Disponvel em: <https://docs.google.com/open?id=0Bx2ZnHfy
Wt9Qd3doSl81Rk01MDQ>
Introduo do livro texto da disciplina de Classificao e Pesquisa
(ZIVIANI, Nvio. Projeto de Algoritmos: com implementao em Pascal e C. 2 ed. So
Paulo: Pioneira Thomson Learning. p. 2 a 29)
Pesquisa em Memria Primaria do livro texto da disciplina de Classificao e Pesquisa
(ZIVIANI, Nvio. Projeto de Algoritmos: com implementao em Pascal e C. 2 ed. So
Paulo: Pioneira Thomson Learning. p. 153 a 157)
Ordenao do livro texto da disciplina de Classificao e Pesquisa
(ZIVIANI, Nvio. Projeto de Algoritmos: com implementao em Pascal e C. 2 ed. So
Paulo: Pioneira Thomson Learning. p. 95 a 143)