ANHANGUERA EDUCACIONAL LTDAFACULDADE ANHANGUERA DE SO JOS DOS CAMPOSCINCIA DA COMPUTAO

ATPS Programao Orientada a objetos IProf. MonalisaSo Jos dos Campos, 7 de abril de 2015Sumrio

RELATRIO 1 PESQUISA DE DADOS.............................................................................................. pg. 3

CDIGO USADO................................................................................................................... pg. 5

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

BIBLIOGRAFIA................................................................................................................................ pg. 10RELATRIO 1 PESQUISA DE DADOSMelhor 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 TESTETAMANHO VETORQUANTIDADE TESTES

Busca Linear1.0001.000

Busca Linear com Sentinela1.0001.000

Busca Binria1.0009

Bubble Sort1.000244.968

Seleo1.00056.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 PesquisaDescription: Bateria de testes de busca linear, linear com sentinela e binriaordenao bubble sort e seleo*/

#include#include#include#include

#define tempo 2000#define search_p 87#define search_s 100001

//prototipos das funesvoid 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 variaveisint 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 aleatriosGerador de distribuicao uniforme retorna um numerodouble (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 (*seedRELATRIO 2 MTODOS DE ORDENAOO 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 instanciaDentro 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.BIBLIOGRAFIAApostila de Algoritmo Estruturado

JUNIOR, J. M. R. S. Disponvel em: 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)