first commit

t1/main.c

+#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;
+}

t1/makefile

+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)

t1/ordenacao.c

+#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;
+}
+

t1/ordenacao.h

+#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_