diff --git a/T1/.gitkeep b/T1/.gitkeep deleted file mode 100644 index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000 diff --git a/t1/main.c b/t1/main.c new file mode 100644 index 0000000000000000000000000000000000000000..38486833deeb8460f063a9eb1887240220ce63c5 --- /dev/null +++ b/t1/main.c @@ -0,0 +1,302 @@ +#include <stdio.h> +#include <stdlib.h> +#include <time.h> + +#include "ordenacao.h" + +void imprimeVetor(int v[], int tam) { + printf("\n["); + for (int i=0;i<10;i++) { + printf("%d ", v[i]); + } + printf("...%d]\n", v[tam-1]); +} + +void geraVetorAleatorio(int v[], int tam) { + for (int i=0;i<tam;i++) { + v[i] = rand() % 100000 + 1; + } +} + +void geraVetor(int v[], int tam) { + for (int i=0;i<tam;i++) { + v[i] = i; + } +} + +int main(){ + char nome[MAX_CHAR_NOME]; + int idxBusca; + int numComp; + double total; + clock_t start, end;//variáveis do tipo clock_t + srand(10); + + //Dica: somente é posśivel criar vetores grandes utilizando alocação dinâmica de memória + //Veja um exemplo de alocação dinâmica a seguir + int tamVetor = 10000; + int* vetor = malloc(tamVetor * sizeof(int)); + getNome(nome); + printf("Trabalho de %s\n", nome); + printf("GRR %u\n", getGRR()); + + if(vetor == NULL){ + printf("Falha fatal. Impossível alocar memoria."); + return 1; + } + + int* vetor1 = malloc(tamVetor * sizeof(int)); + if(vetor1 == NULL){ + printf("Falha fatal. Impossível alocar memoria."); + return 1; + } + + printf("----------------------------------------------------\n"); + printf("Comecando os teste com os vetores de busca...\n"); + printf("----------------------------------------------------\n"); + + printf("\n--->BUSCA SEQUENCIAL\n"); + + //TESTE 1 + numComp=0; + printf("\nbuscando o valor -6 no vetor..."); + geraVetor(vetor,100); + imprimeVetor(vetor, 100); + start = clock();//start recebe o "ciclo" corrente + idxBusca = buscaSequencial(vetor,100, -6, &numComp); + end = clock();//end recebe o "ciclo" corrente + total = ((double)end - start)/CLOCKS_PER_SEC; + printf("(Encontrado no indice: %d | Nº de comp: %d | Tempo total: %f)\n", idxBusca, numComp, total); + + + //TESTE 2 + numComp=0; + printf("\nbuscando o valor 100 no vetor..."); + geraVetor(vetor,1000); + imprimeVetor(vetor, 1000); + start = clock();//start recebe o "ciclo" corrente + idxBusca = buscaSequencial(vetor,1000, 100, &numComp); + end = clock();//end recebe o "ciclo" corrente + total = ((double)end - start)/CLOCKS_PER_SEC; + printf("(Encontrado no indice: %d | Nº de comp: %d | Tempo total: %f)\n", idxBusca, numComp, total); + + + //TESTE 3 + numComp=0; + printf("\nbuscando o valor 7500 no vetor..."); + geraVetor(vetor,10000); + imprimeVetor(vetor, 10000); + start = clock();//start recebe o "ciclo" corrente + idxBusca = buscaSequencial(vetor,10000, 7500, &numComp); + end = clock();//end recebe o "ciclo" corrente + total = ((double)end - start)/CLOCKS_PER_SEC; + printf("(Encontrado no indice: %d | Nº de comp: %d | Tempo total: %f)\n", idxBusca, numComp, total); + + + + printf("\n--->BUSCA BINARIA\n"); + geraVetor(vetor,100); + + + //TESTE 1 + numComp=0; + printf("\nbuscando o valor -6 no vetor..."); + imprimeVetor(vetor, 100); + start = clock();//start recebe o "ciclo" corrente + idxBusca = buscaBinaria(vetor,100, -6, &numComp); + end = clock();//end recebe o "ciclo" corrente + total = ((double)end - start)/CLOCKS_PER_SEC; + printf("(Encontrado no indice: %d | Nº de comp: %d | Tempo total: %f)\n", idxBusca, numComp, total); + + + //TESTE 2 + numComp=0; + printf("\nbuscando o valor 100 no vetor..."); + geraVetor(vetor,1000); + imprimeVetor(vetor, 1000); + start = clock();//start recebe o "ciclo" corrente + idxBusca = buscaBinaria(vetor,1000, 100, &numComp); + end = clock();//end recebe o "ciclo" corrente + total = ((double)end - start)/CLOCKS_PER_SEC; + printf("(Encontrado no indice: %d | Nº de comp: %d | Tempo total: %f)\n", idxBusca, numComp, total); + + + //TESTE 3 + numComp=0; + printf("\nbuscando o valor 2500 no vetor..."); + geraVetor(vetor,10000); + imprimeVetor(vetor, 10000); + start = clock();//start recebe o "ciclo" corrente + idxBusca = buscaBinaria(vetor,10000, 2500, &numComp); + end = clock();//end recebe o "ciclo" corrente + total = ((double)end - start)/CLOCKS_PER_SEC; + printf("(Encontrado no indice: %d | Nº de comp: %d | Tempo total: %f)\n", idxBusca, numComp, total); + + + printf("\n----------------------------------------------------\n"); + printf("Comecando os teste com os vetores de ordenacao...\n"); + printf("----------------------------------------------------\n"); + + printf("\n--->INSERTION SORT\n"); + + //TESTE 1 + geraVetorAleatorio(vetor,10); + printf("\nOrdenando um vetor tam = 100"); + imprimeVetor(vetor, 10); + start = clock();//start recebe o "ciclo" corrente + numComp = insertionSort(vetor,10); + end = clock();//end recebe o "ciclo" corrente + total = ((double)end - start)/CLOCKS_PER_SEC; + imprimeVetor(vetor, 10); + printf("(Nº de comp: %d | Tempo total: %f)\n",numComp, total); + + + //TESTE 2 + geraVetorAleatorio(vetor,1000); + printf("\nOrdenando um vetor tam = 1000"); + imprimeVetor(vetor, 1000); + start = clock();//start recebe o "ciclo" corrente + numComp = insertionSort(vetor,1000); + end = clock();//end recebe o "ciclo" corrente + total = ((double)end - start)/CLOCKS_PER_SEC; + imprimeVetor(vetor, 1000); + printf("(Nº de comp: %d | Tempo total: %f)\n",numComp, total); + + + //TESTE 3 + geraVetorAleatorio(vetor,10000); + printf("\nOrdenando um vetor tam = 10000"); + imprimeVetor(vetor, 10000); + start = clock();//start recebe o "ciclo" corrente + numComp = insertionSort(vetor,10000); + end = clock();//end recebe o "ciclo" corrente + total = ((double)end - start)/CLOCKS_PER_SEC; + imprimeVetor(vetor, 10000); + printf("(Nº de comp: %d | Tempo total: %f)\n",numComp, total); + + printf("\n"); + + + printf("\n--->SELECTION SORT\n"); + + //TESTE 1 + geraVetorAleatorio(vetor,100); + printf("\nOrdenando um vetor tam = 100"); + imprimeVetor(vetor, 100); + start = clock();//start recebe o "ciclo" corrente + numComp = selectionSort(vetor,100); + end = clock();//end recebe o "ciclo" corrente + total = ((double)end - start)/CLOCKS_PER_SEC; + imprimeVetor(vetor, 100); + printf("(Nº de comp: %d | Tempo total: %f)\n",numComp, total); + + + //TESTE 2 + geraVetorAleatorio(vetor,1000); + printf("\nOrdenando um vetor tam = 1000"); + imprimeVetor(vetor, 1000); + start = clock();//start recebe o "ciclo" corrente + numComp = selectionSort(vetor,1000); + end = clock();//end recebe o "ciclo" corrente + total = ((double)end - start)/CLOCKS_PER_SEC; + imprimeVetor(vetor, 1000); + printf("(Nº de comp: %d | Tempo total: %f)\n",numComp, total); + + + //TESTE 3 + geraVetorAleatorio(vetor,10000); + printf("\nOrdenando um vetor tam = 10000"); + imprimeVetor(vetor, 10000); + start = clock();//start recebe o "ciclo" corrente + numComp = selectionSort(vetor,10000); + end = clock();//end recebe o "ciclo" corrente + total = ((double)end - start)/CLOCKS_PER_SEC; + imprimeVetor(vetor, 10000); + printf("(Nº de comp: %d | Tempo total: %f)\n",numComp, total); + + printf("\n"); + + printf("\n--->MERGE SORT\n"); + + //TESTE 1 + geraVetorAleatorio(vetor,100); + printf("\nOrdenando um vetor tam = 100"); + imprimeVetor(vetor, 100); + start = clock();//start recebe o "ciclo" corrente + numComp = mergeSort(vetor,100); + end = clock();//end recebe o "ciclo" corrente + total = ((double)end - start)/CLOCKS_PER_SEC; + imprimeVetor(vetor, 100); + printf("(Nº de comp: %d | Tempo total: %f)\n",numComp, total); + + + //TESTE 2 + geraVetorAleatorio(vetor,1000); + printf("\nOrdenando um vetor tam = 1000"); + imprimeVetor(vetor, 1000); + start = clock();//start recebe o "ciclo" corrente + numComp = mergeSort(vetor,1000); + end = clock();//end recebe o "ciclo" corrente + total = ((double)end - start)/CLOCKS_PER_SEC; + imprimeVetor(vetor, 1000); + printf("(Nº de comp: %d | Tempo total: %f)\n",numComp, total); + + + //TESTE 3 + geraVetorAleatorio(vetor,10000); + printf("\nOrdenando um vetor tam = 10000"); + imprimeVetor(vetor, 10000); + start = clock();//start recebe o "ciclo" corrente + numComp = mergeSort(vetor,10000); + end = clock();//end recebe o "ciclo" corrente + total = ((double)end - start)/CLOCKS_PER_SEC; + imprimeVetor(vetor, 10000); + printf("(Nº de comp: %d | Tempo total: %f)\n",numComp, total); + + printf("\n"); + + printf("\n--->QUICK SORT\n"); + + //TESTE 1 + geraVetorAleatorio(vetor,100); + printf("\nOrdenando um vetor tam = 100"); + imprimeVetor(vetor, 100); + start = clock();//start recebe o "ciclo" corrente + numComp = quickSort(vetor,100); + end = clock();//end recebe o "ciclo" corrente + total = ((double)end - start)/CLOCKS_PER_SEC; + imprimeVetor(vetor, 100); + printf("(Nº de comp: %d | Tempo total: %f)\n",numComp, total); + + + //TESTE 2 + geraVetorAleatorio(vetor,1000); + printf("\nOrdenando um vetor tam = 1000"); + imprimeVetor(vetor, 1000); + start = clock();//start recebe o "ciclo" corrente + numComp = quickSort(vetor,1000); + end = clock();//end recebe o "ciclo" corrente + total = ((double)end - start)/CLOCKS_PER_SEC; + imprimeVetor(vetor, 1000); + printf("(Nº de comp: %d | Tempo total: %f)\n",numComp, total); + + + //TESTE 3 + geraVetorAleatorio(vetor,10000); + printf("\nOrdenando um vetor tam = 10000"); + imprimeVetor(vetor, 10000); + start = clock();//start recebe o "ciclo" corrente + numComp = quickSort(vetor,10000); + end = clock();//end recebe o "ciclo" corrente + total = ((double)end - start)/CLOCKS_PER_SEC; + imprimeVetor(vetor, 10000); + printf("(Nº de comp: %d | Tempo total: %f)\n",numComp, total); + + printf("\n"); + + //É obrigatório que você libere a memória alocada dinâmicamente via fee + free(vetor); + free(vetor1); + + return 0; +} diff --git a/t1/main.o b/t1/main.o new file mode 100644 index 0000000000000000000000000000000000000000..324e61451b6ea13fa7d561eb207846e763003ac6 Binary files /dev/null and b/t1/main.o differ diff --git a/t1/makefile b/t1/makefile new file mode 100644 index 0000000000000000000000000000000000000000..2ed9e7f9438a6411ac8f2e2b5d8d4051982fed3b --- /dev/null +++ b/t1/makefile @@ -0,0 +1,16 @@ +parametrosCompilacao=-Wall #-Wshadow +nomePrograma=trab1grr20206873 + +all: $(nomePrograma) + +$(nomePrograma): main.o ordenacao.o + gcc -o $(nomePrograma) main.o ordenacao.o $(parametrosCompilacao) + +main.o: main.c + gcc -c main.c $(parametrosCompilacao) + +ordenacao.o: ordenacao.h ordenacao.c + gcc -c ordenacao.c $(parametrosCompilacao) + +clean: + rm -f *.o *.gch $(nomePrograma) diff --git a/t1/ordenacao.c b/t1/ordenacao.c new file mode 100644 index 0000000000000000000000000000000000000000..9ce1ed02aae8b9b5ffd0b378d103410d7e1bf4e5 --- /dev/null +++ b/t1/ordenacao.c @@ -0,0 +1,284 @@ +#include "ordenacao.h" +#include <string.h> +#include <stdio.h> +#include <stdlib.h> + + +void getNome(char nome[]){ + //substitua por seu nome + strncpy(nome, "Vinicius Fontoura de Abreu", MAX_CHAR_NOME); + nome[MAX_CHAR_NOME-1] = '\0';//adicionada terminação manual para caso de overflow +} + +unsigned int getGRR(){ + return 20206873; +} + +//a função a seguir deve retornar o seu número de GRR +unsigned int getGRR(); + +int buscaSequencialCompleta(int vetor[],int a, int b, int valor, int* numComparacoes) { + //printf("%d\n",b); + if (a>b) + return a-1; + + *numComparacoes+=1; + if (valor==vetor[b]) { + return b; + } + return buscaSequencialCompleta(vetor,a,b-1,valor,numComparacoes); +} + +int buscaSequencial(int vetor[], int tam, int valor, int* numComparacoes){ + int a = 0; + //caso base + if (a > tam) + return -1; + + return buscaSequencialCompleta(vetor,0,tam-1,valor,numComparacoes); +} + +//usada para processar a busca binaria corretamente +int buscaBinariaCompleta(int vetor[], int tam, int inicio, int valor, int* numComparacoes) { + int meio; + if (inicio > tam) + return -1; + + meio = (tam+inicio)/2; + + if (vetor[meio] == valor) { + *numComparacoes+=1; + return meio; + } + + //busca a esquerda + if (vetor[meio] > valor) { + *numComparacoes+=1; + return buscaBinariaCompleta(vetor,meio-1,inicio,valor,numComparacoes); + } + //busca a direita + *numComparacoes+=1; + return buscaBinariaCompleta(vetor,tam,meio+1,valor,numComparacoes); +} + +int buscaBinaria(int vetor[], int tam, int valor, int* numComparacoes){ + int a,b,meio; + a = 0; + b = tam; + meio = tam/2; + if (a > b) { + return -1; + } + + if (vetor[meio] == valor) { + *numComparacoes+=1; + return meio; + } + + // busca a esquerda + if (vetor[meio] > valor) { + *numComparacoes+=1; + return buscaBinariaCompleta(vetor,meio-1,a,valor,numComparacoes); + } + //busca a direita + *numComparacoes+=1; + return buscaBinariaCompleta(vetor,b,meio+1,valor,numComparacoes); +} + + +void troca(int vetor[], int a, int b) { + int x; + x = vetor[a]; + vetor[a] = vetor[b]; + vetor[b] = x; +} + + +void insere(int vetor[], int a, int b,int* numComparacoes) { + int posicao,i; + //busca a posicao correta do ultimo elemento + posicao = buscaSequencial(vetor,b-1,vetor[b],numComparacoes); + i = b; + //enquanto o ultimo elemento for maior que o elemento na sua posicao correta + while (i > posicao+1) { + //faz a troca ate chegar na posicao correta + troca(vetor,i,i-1); + i--; + } +} + +int insertionSortCompleto(int vetor[], int a, int b, int* numComparacoes) { + if (a >= b) + return b; + //vai ser chamado ate chegar no vetor de tamanho 1 + insertionSortCompleto(vetor,a,b-1,numComparacoes); + //insere cada elemento na posicao correta + insere(vetor,a,b,numComparacoes); + return *numComparacoes; +} + + +int insertionSort(int vetor[], int tam){ + int numComparacoes; + numComparacoes = 0; + //caso base + if (0 >= tam) + return tam; + //faz a primeira chamada + insertionSortCompleto(vetor,0,tam,&numComparacoes); + + return numComparacoes; +} + +//wrapper para fazer a contagem do numero de comparacoes +int selectionSortCompleto(int vetor[], int a, int b, int* numComparacoes) { + int inicio, menor; + if (a >= b) + return a; + inicio = a; + //o menor elemento dentro do vetor(sera procurado ainda) + menor = a; + + //do inicio ate o fim do vetor, checamos qual eh o menor valor + for (int i=a;i<b;i++) { + //se o valor em i for < que o valor em inicio + if (vetor[i]<vetor[inicio]) { + *numComparacoes+=1; + //marca o elemento em i como o menor + menor = i; + //ajusta o inicio para i + inicio = i; + } + } + //faz a troca do primeiro com o + troca(vetor,a,menor); + //retorna a funcao para o proximo item do vetor + return selectionSortCompleto(vetor, a+1, b, numComparacoes); + +} + + +int selectionSort(int vetor[], int tam){ + int a, numComparacoes; + numComparacoes = 0; + a = 0; + //caso base + if (a >= tam) + return a; + //primeira chamada + selectionSortCompleto(vetor, a, tam, &numComparacoes); + return numComparacoes; +} + +//copia para o vetor V com inicio em a e final em b a partir do vetor aux +void copiar(int v[], int a, int b, int aux[]) { + int i = 0; + while (i <= b-a) { + v[a+i] = aux[i]; + i++; + } + return; +} + +void merge(int v[], int a, int m, int b, int* numComparacoes) { + int k,i,j,p; + int u[b]; + //caso base + if (a >= b) + return; + //iterador do vetor auxiliar + k=0; + //iterador do vetor a esquerda + i=a; + //iterador do vetor a direita + j=m+1; + //enquanto o vetor auxiliar nao estiver preenchido por completo + while (k <= b-a) { + //se o vetor a direita tiver acabado OU + //o vetor a esquerda acabo E + //o elemento do primeiro for <= ao elemento do segundo + if (j > b || (i <= m && v[i] <= v[j])) { + *numComparacoes+=1; + //marca o elemento em i + p = i; + i++; + } + else { + //marca o elemento em j + p = j; + j++; + } + //copia o valor em p para o vetor aux + u[k] = v[p]; + k++; + } + //copia o vetor aux para o vetor original + copiar(v,a,b,u); + return; +} + +//wraper para o MergeSort +int mergeSortCompleto(int vetor[], int a, int b, int* numComparacoes) { + int m; + //caso base + if (a >= b) + return b; + // valor de M + m = (a+b)/2; + //faz a primeira chamada e ordena recursivamente cada metade gerada + mergeSortCompleto(vetor,a,m,numComparacoes); + mergeSortCompleto(vetor,m+1,b,numComparacoes); + //junta cada metade gerada apos todas as chamadas recursivas + merge(vetor,a,m,b,numComparacoes); + return *numComparacoes; +} + +int mergeSort(int vetor[], int tam){ + int numComparacoes = 0; + //faz a primeira chamada + mergeSortCompleto(vetor,0,tam,&numComparacoes); + return numComparacoes; +} + +//coloca o pivo na posicao correta +int particionar(int v[], int a, int b,int* numComparacoes) { + int x,m; + //pivo da particao + x = v[b]; + m = a; + //percorre o vetor e faz a troca se o elemento em i é <= ao pivo + for (int i=a;i<b;i++) { + if (v[i] <= x) { + *numComparacoes+=1; + troca(v,m,i); + m++; + } + } + //troca o ultimo elemento com o primeiro + troca(v,m,b); + return m; +} + +int quickSortCompleto(int vetor[],int a, int b, int* numComparacoes) { + int m; + //caso base + if (a >= b) + return a; + //faz a primeira particao ordena recursivamente cada metade gerada + m = particionar(vetor,a,b,numComparacoes); + quickSortCompleto(vetor,a,m-1,numComparacoes); + quickSortCompleto(vetor,m+1,b,numComparacoes); + return *numComparacoes; +} + +int quickSort(int vetor[], int tam){ + int a; + int numComparacoes = 0; + if (0 >= tam) + return -1; + a = 0; + + quickSortCompleto(vetor,a,tam,&numComparacoes); + return numComparacoes; +} + diff --git a/t1/ordenacao.h b/t1/ordenacao.h new file mode 100644 index 0000000000000000000000000000000000000000..822207a745a53a4a06cd03b75e035a222416b994 --- /dev/null +++ b/t1/ordenacao.h @@ -0,0 +1,43 @@ +#ifndef ORDENACAO_H_ +#define ORDENACAO_H_ + +#define MAX_CHAR_NOME 50 + +//a função getNome deve colocar o seu nome dentro da chamada +//seu nome pode ter no máximo MAX_CHAR_NOME - 1 caracteres +void getNome(char nome[]); + +//a função a seguir deve retornar o seu número de GRR +unsigned int getGRR(); + +//Assum que os vetores estão ordenados ao chamar as funções de busca +//As funções de busca não devem alterar o vetor +//O retorno das funções de busca é o índice do elemento no vetor, +//ou -1 caso o elemeno não exista no vetor +//Você deve armazenar no ponteiro int* numComparacoes o número de comparações +//envolvendo elementos do vetor feito pelo seu algoritmo na chamada + + + +//a busca sequencial é a busca ingênua +int buscaSequencial(int vetor[], int tam, int valor, int* numComparacoes); + +//wrapper para busca binaria +int buscaBinariaCompleta(int vetor[], int tam, int inicio, int valor, int* numComparacoes); + +//busca binária no vetor +int buscaBinaria(int vetor[], int tam, int valor, int* numComparacoes); + +//Cada uma das funções deve ordenar o vetor passado como parâmetro +//O retorno das funções de ordenação é o número de comparações +//entre elementos do vetor + +int insertionSort(int vetor[], int tam); + +int selectionSort(int vetor[], int tam); + +int mergeSort(int vetor[], int tam); + +int quickSort(int vetor[], int tam); + +#endif // ORDENACAO_H_ diff --git a/t1/ordenacao.o b/t1/ordenacao.o new file mode 100644 index 0000000000000000000000000000000000000000..274fefcd09e92e1a11fac79618779b8ff9bfbae3 Binary files /dev/null and b/t1/ordenacao.o differ diff --git a/t1/relatorio.pdf b/t1/relatorio.pdf new file mode 100644 index 0000000000000000000000000000000000000000..50c340b9c2cce2625d58b2b5f1fd2c344f81e4a0 Binary files /dev/null and b/t1/relatorio.pdf differ