Commit dde8a076 authored by Ivo Júnior's avatar Ivo Júnior

Código comentado

parent d3ba55a3
//#######################################################################
//## TP1 ALGORITMOS II 2015/2 - Loja de Vinis VINILERA ##
//## Nomes: Ivo de Souza Bueno Júnior - GRR20154004 ##
//## Felipe Lopes Pereira - GRR20153190 ##
//#######################################################################
//"VER RELATORIO[N] significa que aquele pedaco de codigo e as decisoes
//tomadas sobre ele será explicado no relatorio no item N.
#include"loteria.h"
//VER RELATORIO[1]
void Limpa()
{
char c;
while((c = getchar()) != '\n' && c != EOF);
}
//VER RELATÓRIO[2]
void ToLogFile(char string[MAXSTR])
{
FILE *log = fopen("log.txt", "a+");
......@@ -13,6 +24,9 @@ void ToLogFile(char string[MAXSTR])
fclose(log);
}
//Algoritmo de ordenação SelectSort
//vetor[] = vetor a ser ordenado
//tam = tamanho do vetor
void SelectSort(int vetor[], int tam)
{
int i, j, min, aux;
......@@ -31,6 +45,9 @@ void SelectSort(int vetor[], int tam)
}
}
//Algoritmo de ordenação BubbleSort
//vetor[] = vetor a ser ordenado
//tam = tamanho do vetor
void BubbleSort(int vetor[], int tam)
{
int i, j, aux;
......@@ -47,6 +64,9 @@ void BubbleSort(int vetor[], int tam)
}
}
//Descobre a mediana de 3 valores
//vetor[] = vetor que contem os 3 valores
//esq, meio, dir = as posições dos 3 valores dos quais queremos saber quem é o do meio
int Mediana(int vetor[], int esq, int meio, int dir)
{
if(vetor[esq] >= vetor[dir])
......@@ -65,10 +85,15 @@ int Mediana(int vetor[], int esq, int meio, int dir)
return dir;
}
//Particiona o vetor em subvetores para o QuickSort
//vetor[] = vetor a ser particionado
//esq, dir = indices que delimitam os subvetores
//*posiçãoPivo = marca o indice da posição do pivo
void Particao(int vetor[], int esq, int dir, int *posicaoPivo)
{
int i, j, pivo, aux, mdn;
//VER RELATÓRIO[3]
mdn = Mediana(vetor, esq, (esq + dir)/2, dir);
aux = vetor[esq];
vetor[esq] = vetor[mdn];
......@@ -94,6 +119,9 @@ void Particao(int vetor[], int esq, int dir, int *posicaoPivo)
*posicaoPivo = j;
}
//Algoritmo de ordenação QuickSort Recursivo
//vetor[] = vetor a ser ordenado
//esq, dir = indices que delimitam os subvetores
void QuickRec(int vetor[], int esq, int dir)
{
int posicaoPivo;
......@@ -106,6 +134,10 @@ void QuickRec(int vetor[], int esq, int dir)
}
}
//Algoritmo de ordenação QuickSort Iterativo
//vetor[] = vetor a ser ordenado
//*pilha = pilha que contém os delimitadores dos subvetores
//esq, dir = indices que delimitam os subvetores
void QuickIt(int vetor[], tipoPilha *pilha, int esq, int dir)
{
......@@ -123,6 +155,11 @@ void QuickIt(int vetor[], tipoPilha *pilha, int esq, int dir)
}
}
//Algoritmo de Pesquisa Sequencial
//vetor[] = vetor contendo os todos os valores
//tam = tamanho do vetor
//elem = elemento a ser procurando no vetor
//VER RELATÓRIO[4]
int PesqSec(int vetor[], int tam, int elem)
{
int i;
......@@ -131,12 +168,17 @@ int PesqSec(int vetor[], int tam, int elem)
while(i > 0)
{
if(elem == vetor[i])
return 1;
return 1;
i--;
}
return 0;
}
//Algoritmo de Pesquisa Binária
//vetor[] = vetor contendo os todos os valores
//elem = elemento a ser procurando no vetor
//esq, dir = indices que delimitam os subvetores
//VER RELATÓRIO[4]
int PesqBin(int vetor[], int elem, int esq, int dir)
{
int meio;
......@@ -152,12 +194,17 @@ int PesqBin(int vetor[], int elem, int esq, int dir)
return PesqBin(vetor, elem, esq, meio-1);
}
//Função que calcula o tempo de execução de cada algoritmo de ordenação
//vetor[] = vetor contendo os todos os valores
//tam = tamanho do vetor
//numMax = valor máximo para os elementos do vetor
void TempoExecucao(int vetor[], int tam, int numMax)
{
int i;
clock_t begin, end;
clock_t begin, end; //VER RELATÓRIO[5]
double time_spent;
//Inicio da mensagem para o Log
ToLogFile("\n- Inicio do teste de tempo de execução com ");
sprintf(buffer, "%d", TESTES);
ToLogFile(buffer);
......@@ -165,9 +212,10 @@ void TempoExecucao(int vetor[], int tam, int numMax)
sprintf(buffer, "%d", tam);
ToLogFile(buffer);
ToLogFile(" elementos.\n");
//Fim da mensagem para o Log
//Teste para o SelectSort
begin = clock();
for(i = 1; i < TESTES; i++)
{
GeraVetor(vetorDes, tam, numMax);
......@@ -177,11 +225,14 @@ void TempoExecucao(int vetor[], int tam, int numMax)
time_spent = (double)(end - begin) / CLOCKS_PER_SEC;
printf("\tTempo do SelectSort: %lf s\n", time_spent);
//Inicio da mensagem para o Log
ToLogFile("\tTempo de execução total para SelectSort: ");
sprintf(buffer, "%f", time_spent);
ToLogFile(buffer);
ToLogFile("\n");
//Fim da mensagem para o Log
//Teste para o BubbleSort
begin = clock();
for(i = 1; i < TESTES; i++)
{
......@@ -192,11 +243,14 @@ void TempoExecucao(int vetor[], int tam, int numMax)
time_spent = (double)(end - begin) / CLOCKS_PER_SEC;
printf("\tTempo do BubbleSort: %lf s\n", time_spent);
//Inicio da mensagem para o Log
ToLogFile("\tTempo de execução total para BubbleSort: ");
sprintf(buffer, "%f", time_spent);
ToLogFile(buffer);
ToLogFile("\n");
//Fim da mensagem para o Log
//Teste para o QuickSort Recursivo
begin = clock();
for(i = 1; i < TESTES; i++)
{
......@@ -207,11 +261,14 @@ void TempoExecucao(int vetor[], int tam, int numMax)
time_spent = (double)(end - begin) / CLOCKS_PER_SEC;
printf("\tTempo do QuickSort Recursivo: %lf s\n", time_spent);
//Inicio da mensagem para o Log
ToLogFile("\tTempo de execução total para QuickSort Recursivo: ");
sprintf(buffer, "%f", time_spent);
ToLogFile(buffer);
ToLogFile("\n");
//Fim da mensagem para o Log
//Teste para o QuickSort Iterativo
begin = clock();
tipoPilha pilha;
InicPilha(&pilha);
......@@ -224,89 +281,135 @@ void TempoExecucao(int vetor[], int tam, int numMax)
time_spent = (double)(end - begin) / CLOCKS_PER_SEC;
printf("\tTempo do QuickSort Iterativo: %lf s\n", time_spent);
//Inicio da mensagem para o Log
ToLogFile("\tTempo de execução total para QuickSort Iterativo: ");
sprintf(buffer, "%f", time_spent);
ToLogFile(buffer);
ToLogFile("\n");
//Fim da mensagem para o Log
}
//Decide qual será o método de ordenação utilizado
//vetorDes[] = vetor a ser ordenado
//vetorOrd[] = vetor ordenado
//ordenação = inteiro que representa o tipo de ordenação a ser utilizado
//tam = tamanho do vetor
void OrdenaVetor(int vetorDes[], int vetorOrd[], int ordenacao, int tam)
{
int i;
//VER RELATÓRIO[6]
for(i = 1; i <= tam; i++)
vetorOrd[i] = vetorDes[i];
//Inicio da mensagem para o Log
ToLogFile("\n- Ordenando vetor com o algoritmo ");
//Fim da mensagem para o Log
switch(ordenacao)
{
case 1:
case 1: //Ordenando com o SelectSort
//Inicio da mensagem para o Log
ToLogFile("SelectSort.\n");
//Fim da mensagem para o Log
SelectSort(vetorOrd, tam);
break;
case 2:
case 2: //Ordenando com o BubbleSort
//Inicio da mensagem para o Log
ToLogFile("BubbleSort.\n");
//Fim da mensagem para o Log
BubbleSort(vetorOrd, tam);
break;
case 3:
case 3: //Ordenando com o QuickSort Recursivo
//Inicio da mensagem para o Log
ToLogFile("QuickSort Recursivo.\n");
//Fim da mensagem para o Log
QuickRec(vetorOrd, 1, tam);
break;
case 4: ;
case 4: //Ordenando com o QuickSort Iterativo
//Inicio da mensagem para o Log
ToLogFile("QuickSort Iterativo.\n");
//Fim da mensagem para o Log
tipoPilha pilha;
InicPilha(&pilha);
ToLogFile("QuickSort Iterativo.\n");
QuickIt(vetorOrd, &pilha, 1, tam);
break;
}
}
//Gera vetor de números aleatórios
//vetor[] = vetor que conterá os elementos aleatórios
//tam = tamanho do vetor
//numMax = valor máximo para elementos do vetor
void GeraVetor(int vetor[], int tam, int numMax)
{
int i;
srand(time(NULL));
srand(time(NULL)); //VER RELATÓRIO[7]
for(i = 1; i <= tam; i++)
vetor[i] = (rand() % numMax) + 1;
}
//Obtém os valores necessário para a geração do vetor
//vetorDes[] = vetor a ser ordenado
//vetorOrd[] = vetor ordenado
//*tam = tamanho do vetor
//*numMax = valor máximo para os elementos do vetor
void Setup(int vetorDes[], int vetorOrd[], int *tam, int *numMax)
{
int ordenacao;
//Inicio da mensagem para o Log
ToLogFile("\n- Gerando nova configuração de vetores.\n");
//Fim da mensagem para o Log
printf("\n\tEntre com o tamanho máximo do vetor(4 - 16384): ");
//Obtém o tamanho do vetor
printf("\n\tEntre com o tamanho máximo do vetor(4 - 10000): ");
scanf("%d", tam);
while((*tam < 4) || (*tam > MAXVETOR))
{
printf("\n\tO número nao está dentro do intervalo.\n\tEntre com o tamanho máximo do vetor(4 - 16384): ");
printf("\n\tO número nao está dentro do intervalo.\n\tEntre com o tamanho máximo do vetor(4 - 10000): ");
scanf("%d", tam);
};
//Inicio da mensagem para o Log
ToLogFile("\tNovo tamanho máximo do vetor: ");
sprintf(buffer, "%d", *tam);
ToLogFile(buffer);
ToLogFile("\n");
//Fim da mensagem para o Log
printf("\n\tEntre com um valor máximo positivo,\n\tdiferente de zero, para os elementos do vetor: ");
//Obtém o valor máximo dos elementos do vetor
printf("\n\tEntre com um valor para os elementos do vetor(1 - 10000): ");
scanf("%d", numMax);
while(*numMax <= 0)
while((*numMax <= 0) || (*numMax > MAXVALOR))
{
printf("\n\tO número não é positivo ou diferente de zero.\n\tEntre com um valor máximo positivo, diferente de zero,\n\tpara os elementos do vetor: ");
printf("\n\tO número está fora do intervalo.\n\tEntre com um valor para os elementos do vetor(1 - 10000): ");
scanf("%d", numMax);
};
//Inicio da mensagem para o Log
ToLogFile("\tNovo tamanho máximo do vetor: ");
sprintf(buffer, "%d", *numMax);
ToLogFile(buffer);
ToLogFile("\n");
//Fim da mensagem para o Log
//Gera o vetor dentro das especificações definidas pelo usuário
GeraVetor(vetorDes, *tam, *numMax);
//Inicio da mensagem para o Log
ToLogFile("\tNovo vetor aleatório gerado.\n");
//Fim da mensagem para o Log
//Obtém qual método de ordenação utilizar
printf("\n\tQual método de ordenação utilizar?\n\t1: SelectSort;\n\t2: BubbleSort;\n\t3: QuickSort Recursivo;\n\t4: QuickSort Iterativo;\n\t:");
scanf("%d", &ordenacao);
while((ordenacao < 1) || (ordenacao > 4))
......@@ -315,10 +418,15 @@ void Setup(int vetorDes[], int vetorOrd[], int *tam, int *numMax)
scanf("%d", &ordenacao);
};
//Ordena o vetor no método escolhido pelo usuário
OrdenaVetor(vetorDes, vetorOrd, ordenacao, *tam);
system("clear");
system("clear");//VER RELATÓRIO[8]
}
//Imprime o vetor
//vetor[] = vetor a se imprimir
//tam = tamanho do vetor
void ImprimeVetor(int vetor[], int tam)
{
int i;
......@@ -326,27 +434,35 @@ void ImprimeVetor(int vetor[], int tam)
printf("\t[");
for(i = 1; i <= tam - 1; i++)
{
//Inicio da mensagem para o Log
sprintf(buffer, "%d", vetor[i]);
ToLogFile(buffer);
ToLogFile(" ");
//Fim da mensagem para o Log
printf("%d ",vetor[i]);
}
//Inicio da mensagem para o Log
sprintf(buffer, "%d", vetor[i]);
ToLogFile(buffer);
ToLogFile("]\n");
//Fim da mensagem para o Log
printf("%d]\n", vetor[i]);
}
//Programa principal
main(){
int tam, numMax, i, menu, acertosSeq, acertosBin;
int vetorPalpite[4];
char voltar;
time_t t;
if(access("log.txt", 0) == -1)
time_t t; //VER RELATÓRIO[9]
t = time(NULL);
//Inicio da mensagem para o Log
if(access("log.txt", 0) == -1) //Testa se o arquivo log já existe, caso não, imprime o cabeçalho
{
ToLogFile("#######################################################################\n");
ToLogFile("## TP2 ALGORITMOS II 2015/2 - MEGA QUADRA ##\n");
......@@ -359,7 +475,8 @@ main(){
ToLogFile("\n- Programa iniciado. - ");
ToLogFile(asctime(localtime(&t)));
ToLogFile("\n");
//Fim da mensagem para o Log
menu = 1;
system("clear");
puts("########################################################\n");
......@@ -378,35 +495,43 @@ main(){
switch(menu)
{
case 0:
case 0: //Sair do programa
ToLogFile("\n- Programa encerrado.\n");
break;
case 1:
case 1: //Apostar
system("clear");
printf("\n\tDigite sua aposta(4 números entre 1 e %d), e BOA SORTE!\n\t:", numMax);
//Inicio da mensagem para o Log
ToLogFile("\n- Iniciando aposta. Jogador entrará com 4 números.\n");
//Fim da mensagem para o Log
acertosSeq = 0;
acertosBin = 0;
//Obtém os valores dos palpites do jogador e guarda no "vetorPalpite"
for(i = 0; i < 4; i++)
{
scanf("%d", &vetorPalpite[i]);
while((vetorPalpite[i] < 1) || (vetorPalpite[i] > numMax))
{
//Inicio da mensagem para o Log
ToLogFile("\t## ERRO: Número está fora do intervalo. ##\n");
//Fim da mensagem para o Log
printf("\n\tO número não está dentro do intervalo(1 - %d). Digite sua aposta novamente: ", numMax);
scanf("%d", &vetorPalpite[i]);
}
//Inicio da mensagem para o Log
ToLogFile("\t");
sprintf(buffer, "%d", vetorPalpite[i]);
ToLogFile(buffer);
ToLogFile("\n");
ToLogFile("\n");
//Fim da mensagem para o Log
//Acertos aumentam de acordo com o número de elementos encontrados no vetor
acertosSeq += PesqSec(vetorDes, tam, vetorPalpite[i]);
acertosBin += PesqBin(vetorOrd, vetorPalpite[i], 1, tam);
}
......@@ -420,27 +545,31 @@ main(){
else
printf("\n\tVocê acertou %d números. Tente outra vez... :(\n", acertosSeq);
//Inicio da mensagem para o Log
ToLogFile("\n\tO jogador acertou ");
sprintf(buffer, "%d", acertosBin);
ToLogFile(buffer);
ToLogFile(" números.\n");
//Fim da mensagem para o Log
printf("Pressione enter para voltar: ");
Limpa();
scanf("%c", &voltar);
break;
case 2:
case 2: //Setup
system("clear");
puts("\n########################################################\n");
Setup(vetorDes, vetorOrd, &tam, &numMax);
puts("\n########################################################\n");
break;
case 3:
case 3://Imprime desordenado
system("clear");
ToLogFile("\n- Imprimindo vetor desordenado:\n\t[");
//Inicio da mensagem para o Log
ToLogFile("\n- Imprimindo vetor desordenado:\n\t[");
//Fim da mensagem para o Log
puts("\n########################################################\n");
ImprimeVetor(vetorDes, tam);
......@@ -450,10 +579,12 @@ main(){
scanf("%c", &voltar);
break;
case 4:
case 4://Imprime Ordenado
system("clear");
ToLogFile("\n- Imprimindo vetor ordenado:\n\t[");
//Inicio da mensagem para o Log
ToLogFile("\n- Imprimindo vetor ordenado:\n\t[");
//Fim da mensagem para o Log
puts("\n########################################################\n");
ImprimeVetor(vetorOrd, tam);
......@@ -463,7 +594,7 @@ main(){
scanf("%c", &voltar);
break;
case 5:
case 5://Calcula tempo de execução
system("clear");
puts("\n########################################################\n");
TempoExecucao(vetorOrd, tam, numMax);
......
//#######################################################################
//## TP1 ALGORITMOS II 2015/2 - Loja de Vinis VINILERA ##
//## Nomes: Ivo de Souza Bueno Júnior - GRR20154004 ##
//## Felipe Lopes Pereira - GRR20153190 ##
//#######################################################################
#ifndef _LOTERIA_H
#define _LOTERIA_H
......@@ -6,21 +12,27 @@
#include<time.h>
#include"pilha.h"
#define MAXVETOR 16384
//Macros
#define MAXVETOR 10000
#define TESTES 10000
#define MAXVALOR 10000
#define MAXSTR 32
//Declaração de variáveis locais
int vetorDes[MAXVETOR], vetorOrd[MAXVETOR];
char buffer[32];
//Algoritmos de ordenação
void SelectSort(int vetor[], int tam);
void BubbleSort(int vetor[], int tam);
void QuickRec(int vetor[], int esq, int dir);
void QuickIt(int vetor[], tipoPilha *pilha ,int esq, int dir);
//Algoritmos de pesquisa
int PesqSec(int vetor[], int tam, int elem);
int PesqBin(int vetor[], int elem, int esq, int dir);
//Outros algoritmos utilizados
void Limpa();
void ToLogFile(char string[MAXSTR]);
int Mediana(int vetor[], int esq, int meio, int dir);
......
//#######################################################################
//## TP1 ALGORITMOS II 2015/2 - Loja de Vinis VINILERA ##
//## Nomes: Ivo de Souza Bueno Júnior - GRR20154004 ##
//## Felipe Lopes Pereira - GRR20153190 ##
//#######################################################################
#ifndef _PILHA_H
#define _PILHA_H
#include<stdio.h>
#include<stdlib.h>
//Macros
#define MAXPILHA 16862
//Definição de estruturas
typedef struct{
int cesq;
int cdir;
......@@ -20,6 +28,8 @@ typedef struct{
int tamanho;
}tipoPilha;
//Inicializa a pilha
//*pilha = pilha a ser inicializada
void InicPilha(tipoPilha *pilha)
{
pilha->topo = (struct tipoElemento*)malloc(sizeof(struct tipoElemento));
......@@ -27,11 +37,16 @@ void InicPilha(tipoPilha *pilha)
pilha->tamanho = 0;
}
//Checa se a pilha está vazia
//pilha = pilha a ser checada se vazia
int VaziaPilha(tipoPilha pilha)
{
return (pilha.tamanho == 0);
}
//Insere novo elemento à pilha
//*pilha = pilha a qual será inserido o elemento
//esquerda, direita = elementos que formam a coordenada a ser inserida na pilha
void Push(tipoPilha *pilha, int esquerda, int direita)
{
if(esquerda < direita)
......@@ -46,6 +61,8 @@ void Push(tipoPilha *pilha, int esquerda, int direita)
}
}
//Remove elemento do topo da pilha e retorna ele
//*pilha = pilha a qual será removido o elemento do topo
tipoCoordenada Pop(tipoPilha *pilha)
{
if(!VaziaPilha(*pilha))
......
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