Commit 820516fd authored by Felipe's avatar Felipe

relatorio feito

parent dde8a076
......@@ -172,3 +172,149 @@
Tempo de execução total para QuickSort Iterativo: 4.242587
- Programa encerrado.
-----------------------------------------------------------------------
- Programa iniciado. - Sun Dec 13 17:47:22 2015
- Gerando nova configuração de vetores.
Novo tamanho máximo do vetor: 10
Novo tamanho máximo do vetor: 10
Novo vetor aleatório gerado.
- Ordenando vetor com o algoritmo QuickSort Iterativo.
- Inicio do teste de tempo de execução com 10000 vetores de 10 elementos.
Tempo de execução total para SelectSort: 0.051517
Tempo de execução total para BubbleSort: 0.050174
Tempo de execução total para QuickSort Recursivo: 0.049301
Tempo de execução total para QuickSort Iterativo: 0.055056
- Programa encerrado.
-----------------------------------------------------------------------
- Programa iniciado. - Sun Dec 13 18:55:47 2015
- Gerando nova configuração de vetores.
Novo tamanho máximo do vetor: 100
Novo tamanho máximo do vetor: 100
Novo vetor aleatório gerado.
- Ordenando vetor com o algoritmo SelectSort.
- Gerando nova configuração de vetores.
Novo tamanho máximo do vetor: 1000
Novo tamanho máximo do vetor: 1000
Novo vetor aleatório gerado.
- Ordenando vetor com o algoritmo SelectSort.
- Inicio do teste de tempo de execução com 10000 vetores de 1000 elementos.
Tempo de execução total para SelectSort: 42.829554
Tempo de execução total para BubbleSort: 99.083867
Tempo de execução total para QuickSort Recursivo: 3.256738
Tempo de execução total para QuickSort Iterativo: 4.073045
- Inicio do teste de tempo de execução com 10000 vetores de 1000 elementos.
Tempo de execução total para SelectSort: 43.512922
Tempo de execução total para BubbleSort: 99.382374
Tempo de execução total para QuickSort Recursivo: 3.183821
Tempo de execução total para QuickSort Iterativo: 4.116582
- Inicio do teste de tempo de execução com 10000 vetores de 1000 elementos.
Tempo de execução total para SelectSort: 42.627498
Tempo de execução total para BubbleSort: 97.514318
Tempo de execução total para QuickSort Recursivo: 3.309957
Tempo de execução total para QuickSort Iterativo: 4.104320
- Inicio do teste de tempo de execução com 10000 vetores de 1000 elementos.
Tempo de execução total para SelectSort: 41.735053
Tempo de execução total para BubbleSort: 98.311596
Tempo de execução total para QuickSort Recursivo: 3.197065
Tempo de execução total para QuickSort Iterativo: 4.083340
- Inicio do teste de tempo de execução com 10000 vetores de 1000 elementos.
Tempo de execução total para SelectSort: 42.643731
Tempo de execução total para BubbleSort: 97.940441
Tempo de execução total para QuickSort Recursivo: 3.125175
Tempo de execução total para QuickSort Iterativo: 4.159149
- Gerando nova configuração de vetores.
Novo tamanho máximo do vetor: 100
Novo tamanho máximo do vetor: 100
Novo vetor aleatório gerado.
- Ordenando vetor com o algoritmo SelectSort.
- Inicio do teste de tempo de execução com 10000 vetores de 100 elementos.
Tempo de execução total para SelectSort: 0.590868
Tempo de execução total para BubbleSort: 0.974847
Tempo de execução total para QuickSort Recursivo: 0.299725
Tempo de execução total para QuickSort Iterativo: 0.399697
- Imprimindo vetor ordenado:
[2 3 4 5 5 5 6 7 11 12 14 14 19 20 20 20 21 21 22 22 22 22 23 24 24 29 30 31 32 32 33 34 34 34 35 37 38 38 40 44 44 44 44 45 46 46 47 48 51 52 54 55 56 56 59 62 62 62 62 64 65 67 68 70 70 72 72 72 73 73 75 75 76 76 78 79 80 82 83 83 84 84 87 87 87 88 88 90 90 91 91 92 92 93 94 95 96 97 98 100]
- Inicio do teste de tempo de execução com 10000 vetores de 100 elementos.
Tempo de execução total para SelectSort: 0.637357
Tempo de execução total para BubbleSort: 1.044971
Tempo de execução total para QuickSort Recursivo: 0.298597
Tempo de execução total para QuickSort Iterativo: 0.397531
- Inicio do teste de tempo de execução com 10000 vetores de 100 elementos.
Tempo de execução total para SelectSort: 0.632526
Tempo de execução total para BubbleSort: 0.925457
Tempo de execução total para QuickSort Recursivo: 0.287984
Tempo de execução total para QuickSort Iterativo: 0.406131
- Inicio do teste de tempo de execução com 10000 vetores de 100 elementos.
Tempo de execução total para SelectSort: 0.631148
Tempo de execução total para BubbleSort: 1.057293
Tempo de execução total para QuickSort Recursivo: 0.294353
Tempo de execução total para QuickSort Iterativo: 0.396476
- Inicio do teste de tempo de execução com 10000 vetores de 100 elementos.
Tempo de execução total para SelectSort: 0.626256
Tempo de execução total para BubbleSort: 0.851222
Tempo de execução total para QuickSort Recursivo: 0.295972
Tempo de execução total para QuickSort Iterativo: 0.387129
- Gerando nova configuração de vetores.
Novo tamanho máximo do vetor: 10
Novo tamanho máximo do vetor: 10
Novo vetor aleatório gerado.
- Ordenando vetor com o algoritmo BubbleSort.
- Inicio do teste de tempo de execução com 10000 vetores de 10 elementos.
Tempo de execução total para SelectSort: 0.077689
Tempo de execução total para BubbleSort: 0.060813
Tempo de execução total para QuickSort Recursivo: 0.065397
Tempo de execução total para QuickSort Iterativo: 0.090299
- Inicio do teste de tempo de execução com 10000 vetores de 10 elementos.
Tempo de execução total para SelectSort: 0.057259
Tempo de execução total para BubbleSort: 0.082478
Tempo de execução total para QuickSort Recursivo: 0.080200
Tempo de execução total para QuickSort Iterativo: 0.090040
- Inicio do teste de tempo de execução com 10000 vetores de 10 elementos.
Tempo de execução total para SelectSort: 0.061054
Tempo de execução total para BubbleSort: 0.078058
Tempo de execução total para QuickSort Recursivo: 0.081007
Tempo de execução total para QuickSort Iterativo: 0.066966
- Inicio do teste de tempo de execução com 10000 vetores de 10 elementos.
Tempo de execução total para SelectSort: 0.058647
Tempo de execução total para BubbleSort: 0.081275
Tempo de execução total para QuickSort Recursivo: 0.077205
Tempo de execução total para QuickSort Iterativo: 0.090092
- Inicio do teste de tempo de execução com 10000 vetores de 10 elementos.
Tempo de execução total para SelectSort: 0.065734
Tempo de execução total para BubbleSort: 0.082322
Tempo de execução total para QuickSort Recursivo: 0.081242
Tempo de execução total para QuickSort Iterativo: 0.067447
- Programa encerrado.
......@@ -201,8 +201,8 @@ int PesqBin(int vetor[], int elem, int esq, int dir)
void TempoExecucao(int vetor[], int tam, int numMax)
{
int i;
clock_t begin, end; //VER RELATÓRIO[5]
double time_spent;
clock_t inicio, fim; //VER RELATÓRIO[5]
double tempo;
//Inicio da mensagem para o Log
ToLogFile("\n- Inicio do teste de tempo de execução com ");
......@@ -215,75 +215,75 @@ void TempoExecucao(int vetor[], int tam, int numMax)
//Fim da mensagem para o Log
//Teste para o SelectSort
begin = clock();
inicio = clock();
for(i = 1; i < TESTES; i++)
{
GeraVetor(vetorDes, tam, numMax);
SelectSort(vetorDes, tam);
}
end = clock();
time_spent = (double)(end - begin) / CLOCKS_PER_SEC;
printf("\tTempo do SelectSort: %lf s\n", time_spent);
fim = clock();
tempo = (double)(fim - inicio) / CLOCKS_PER_SEC;
printf("\tTempo do SelectSort: %lf s\n", tempo);
//Inicio da mensagem para o Log
ToLogFile("\tTempo de execução total para SelectSort: ");
sprintf(buffer, "%f", time_spent);
sprintf(buffer, "%f", tempo);
ToLogFile(buffer);
ToLogFile("\n");
//Fim da mensagem para o Log
//Teste para o BubbleSort
begin = clock();
inicio = clock();
for(i = 1; i < TESTES; i++)
{
GeraVetor(vetorDes, tam, numMax);
BubbleSort(vetorDes, tam);
}
end = clock();
time_spent = (double)(end - begin) / CLOCKS_PER_SEC;
printf("\tTempo do BubbleSort: %lf s\n", time_spent);
fim = clock();
tempo = (double)(fim - inicio) / CLOCKS_PER_SEC;
printf("\tTempo do BubbleSort: %lf s\n", tempo);
//Inicio da mensagem para o Log
ToLogFile("\tTempo de execução total para BubbleSort: ");
sprintf(buffer, "%f", time_spent);
sprintf(buffer, "%f", tempo);
ToLogFile(buffer);
ToLogFile("\n");
//Fim da mensagem para o Log
//Teste para o QuickSort Recursivo
begin = clock();
inicio = clock();
for(i = 1; i < TESTES; i++)
{
GeraVetor(vetorDes, tam, numMax);
QuickRec(vetorDes, 1, tam);
}
end = clock();
time_spent = (double)(end - begin) / CLOCKS_PER_SEC;
printf("\tTempo do QuickSort Recursivo: %lf s\n", time_spent);
fim = clock();
tempo = (double)(fim - inicio) / CLOCKS_PER_SEC;
printf("\tTempo do QuickSort Recursivo: %lf s\n", tempo);
//Inicio da mensagem para o Log
ToLogFile("\tTempo de execução total para QuickSort Recursivo: ");
sprintf(buffer, "%f", time_spent);
sprintf(buffer, "%f", tempo);
ToLogFile(buffer);
ToLogFile("\n");
//Fim da mensagem para o Log
//Teste para o QuickSort Iterativo
begin = clock();
inicio = clock();
tipoPilha pilha;
InicPilha(&pilha);
InicPilha(&pilha);
for(i = 1; i < TESTES; i++)
{
GeraVetor(vetorDes, tam, numMax);
QuickIt(vetorDes, &pilha, 1, tam);
}
end = clock();
time_spent = (double)(end - begin) / CLOCKS_PER_SEC;
printf("\tTempo do QuickSort Iterativo: %lf s\n", time_spent);
fim = clock();
tempo = (double)(fim - inicio) / CLOCKS_PER_SEC;
printf("\tTempo do QuickSort Iterativo: %lf s\n", tempo);
//Inicio da mensagem para o Log
ToLogFile("\tTempo de execução total para QuickSort Iterativo: ");
sprintf(buffer, "%f", time_spent);
sprintf(buffer, "%f", tempo);
ToLogFile(buffer);
ToLogFile("\n");
//Fim da mensagem para o Log
......
Objetivos e métodos:
O objetivo desse trabalho era a utilização de vários tipos de algoritmos diferentes para realizar pesquisa e ordenação de vetores, para um jogo chamado MegaQuadra, onde o próprio jogador tem controle das suas ações nas apostas.
O desafio era a otimização máxima de cada algoritmo diferente de pesquisa e ordenação para uma possível comparação no final de quais são mais eficientes em vetores de tamanho grande. Testes sempre foram realizados em quanto era implementado o programa e nem sempre batiam com o esperado. Porém com a maior eficiência em cada algoritmo atingimos um resultado aceitável com o esperado.
O programa começa sempre atualizando os dados do tamanho do vetor e valor máximo para ser gerado, tudo realizado dentro da função Setup. Como a especificação pede para um controle constante do programa, já é pedido uma forma de ordenação daquele vetor nas seguintes opção: SelectSort, BubbleSort, QuickSort recursivo e QuickSort iterativo. Após isso entramos no menu principal do programa. O vetor ordenado e desordenado pode ser sempre visualizado pelo jogador. Quando é selecionado a opção para apostar os quatro valores, o programa utiliza os algoritmos da Pesquisa Sequencial (PesqSec) e Pesquisa Binaria (PesqBin) para checar os acertos do jogador. Como é especificado que deveria ser realizado a pesquisa com ambos algoritmos, sempre é checado se o resultado encontrado pela PesqSec é o mesmo de PesqBin para mostrar a funcionalização de ambos.
Dificuldades na implementação:
Para um tratamento mais fácil no vetor, concordamos em utilizar a proposta dada em sala de aula que é deixar o primeiro elemento livre e trabalhar num vetor que vai de índice 1 até o tamanho N.
QuickSort iterativo foi o maior desafio do trabalho, precisando implementar do zero, a pilha foi a solução mais viável para um melhor desempenho. Ainda testamos a pilha com alocação estática de memoria, e os resultados de tempo foram catastróficos com quase 10 vezes mais atraso que BubbleSort e SelectSort.
Medições de tempo:
O programa possui a opção de gerar 10000 vetores diferentes e ordená-los pelos 4 algoritmos diferentes e ainda mostrar o tempo de execução de cada um. Deve ser levado em consideração que o tempo gasto para gerar cada vetor é o mesmo para o teste de cada algoritmo portanto não influencia no tempo, porém mostra que os algoritmos podiam ser mais eficientes se não precisasse gerar sempre vetores diferentes. Outro ponto é que não são os mesmo 10000 vetores para cada algoritmo, portanto pode acontecer que um algoritmo tenha mais vetores próximos do seu melhor caso aumentando o seu desempenho por isso foi realizado uma media para um melhor resultado.
Como visto nas aulas de implementação de cada algoritmo e nas aulas de complexidade. Era esperado que o BubbleSort fosse o pior algoritmo de busca seguido pelo SelectSort já que o numero de comparações e de mudanças de elementos da memoria é constante. Entre os QuickSort era difícil saber qual teriam um desempenho melhor, mas o chute era que o melhor algoritmo de ordenação seria o QuickSort recursivo.
os resultados atingiram as expectativas quando se trata de vetores grandes. Porém em vetores pequenos e médio a diferença chega a ser zero, isso quando até mesmo SelectSort em algumas vezes era o melhor algoritmo em execução. Abaixo temos uma media para vetores de 1000 elementos:
SelectSort - 42,6697514 s
BubbleSort - 98,4465192 s
QuickSort recursivo - 3,2145512 s
QuickSort iterativo - 4,1072872 s
Media para vetores de 100 elementos:
SelectSort - 0,623631 s
BubbleSort - 0,970758 s
QuickSort recursivo - 0,2953262 s
QuickSort iterativo - 0,3973928 s
Media para vetores de 10 elementos:
SelectSort - 0,064077 s
BubbleSort - 0,0769892 s
QuickSort recursivo - 0,0770102 s
QuickSort iterativo - 0,0809688 s
Observações comentadas no código C:
1- A função Limpa foi criada para limpar o buffer do teclado sempre que for necessário. Se existir algo na memoria do teclado, eventualmente, esse conteúdo poderia ser copiado em algum scanf. Portanto sempre antes de realizar a leitura de algo no teclado essa função foi chamada. Com a preocupação de que os scanfs pudessem copiar mais informação do que deveriam, limpamos o buffer.
2- A função ToLogFile é sempre chamada para a inserção dos passos seguidos no código para o log. O log será criado num arquivo a parte para melhor legibilidade do código enquanto ele é executado. O desafio que essa função gerou era que apenas strings podiam ser lidas para o log, portanto valores float/double como o tempo gasto em cada ordenação não era representado no log. Então foi criado um vetor strings auxiliar (buffer) que passava qualquer valor float/double para o formato string, com a receita de código abaixo:
sprintf (buffer, "%.2f", variavel.float); //aqui a variável float será convertida para o vetor string buffer.
ToLogFile(buffer); //agora passa o buffer formato string para o log.
3- Na função do QuickSort Recursivo, sempre que calculava o índice da mediana naquele caso. Era colocado o pivô na posição 1 do vetor, posição chamada de esq (esquerda), e assim a função tratava o vetor para a ordenação.
4- As implementações mostradas em sala de aula, sempre retornavam o valor que era procurado na pesquisa. Nesse caso, era preciso saber apenas se o vetor contém aquele elemento, portanto no main quando é chamada as pesquisas as funções de pesquisa são atribuídas a uma variável que checa o numero de acertos do jogador. Se fosse retornado o valor do elemento achado, seria impossível controlar o números de acertos.
5- A medição de tempo para os testes de 40 mil ordenações, para um valor mais preciso dos resultados foi feito em double. As variáveis inicio e fim controlam o clock quando são chamadas. Para calcular o tempo gasto nas ordenações é feito uma conta simples de (fim - inicio) onde cada variável guardou o valor do clock quando foi chamado. Ainda é divido pela macro CLOCKS_PER_SEC que pertence a biblioteca time.h para transformar o resultado de ns para segundos. O calculo segue a receite de codigo abaixo:
inicio = clock(); //marca o valor que era do clock quando foi chamado
/* codigo que quer ser calculado tempo*/
fim = clock();
tempo_gasto = (double)(fim - inicio) / CLOCKS_PER_SEC; //calcula o tempo entre as marcações do clock e calcula em segundos
printf("Tempo: %lf", tempo_gasto);
6- Como foi pedido na especificação, sempre que preciso, devia ser informado o vetor desordenado. Portanto sempre era duplicado o vetor desordenado e no seu auxiliar sempre ocorria as ordenações
7- Função já existente na linguagem C para randomizar números com um valor limite
8- Para uma visualização mais limpa e clara no terminal, decidimos sempre dar um clear na tela para um novo comando ser executado. Para isso utilizamos a função 'System("clean");' inclusa na biblioteca STDLIB.
9- A biblioteca time.h foi incluída para que toda vez que o programa fosse iniciado, no log, fosse escrito o horário de início do programa. Tornando o log ainda mais informativo e organizado para a pessoa que utilizar o programa, uma vez que se pode checar as diferentes execuções pelos horários que o programa foi executado.
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment