implementa merge com todas melhoras e hibrido, reorganiza os logs

analise.c

@@ -18,7 +18,7 @@ int main () {
 	/* Mude aqui o numero de iterações, tamanho maximo e nome do algoritmo */
 	int MAX_IT = 100;
 	int TAM_MAX = 1000000;
-	char *algoritmo = "mergesort_melhorado2 (R)";
+	char *algoritmo = "mergesort_melhorado (R)";
 
 	for ( tam=10; tam <= TAM_MAX; tam*=10 ) 
 	{
@@ -31,9 +31,6 @@ int main () {
 		soma_tempo = 0;
 		for (i=0; i<MAX_IT; i++) 
 		{
-			/*printf ("\n");
-			imprime_vetor (v, tam);*/
-
 			ini = timestamp();
 			/* Mude aqui o algoritmo usado */
 			mergesort_melhorado (v,0,tam-1); 
@@ -41,7 +38,6 @@ int main () {
 
 			soma_tempo += (fim-ini);
 
-			/*imprime_vetor (v, tam);*/
 			embaralha_vetor (v,tam);
 		}
 		

lib_ordena.c

@@ -4,6 +4,8 @@
 
 #include "lib_ordena.h"
 
+#define LIMITE_INSERTION 50
+
 void imprime_vetor (int v[], int tam) {
     int i;
 
@@ -269,7 +271,7 @@ int particiona_mediana5 (int v[], int ini, int fim, int pivo)
 	}
 }
 
-/* calcula a mediana de 3 entre v[ini], v[meio] e v[fim] usando vetor e insertion */
+/* calcula a mediana de 5 usando vetor e insertion */
 int mediana5_vetor (int v[], int ini, int fim)
 {
 	/* achar uma implementação mais eficiente */
@@ -306,17 +308,6 @@ void copia_vetor (int v[], int aux[], int ini, int fim)
 	}
 }
 
-void copia_vetor2 (int v[], int aux[], int ini, int fim)
-{
-	int i, tam = fim-ini+1;
-
-	for ( i=0; i < tam; i++ )
-	{
-		v[ini] = aux[i];
-		ini++;
-	}
-}
-
 /* intercala sem melhorias */
 void intercala_basico (int v[], int ini, int meio, int fim) 
 {
@@ -378,17 +369,20 @@ void mergesort_basico (int v[], int ini, int fim)
 	}
 }
 
-/* intercala com melhorias */
-void intercala_melhorado (int v[], int ini, int meio, int fim) 
+void copia_vetor_melhorado (int v[], int aux[], int ini, int fim)
 {
-	/* implementar passar o vetor por parametro */
-	int tam_aux = fim-ini+1;
-	int aux[tam_aux];
-
+	for ( ini=ini; ini <= fim; ini++ )
+		v[ini] = aux[ini];
+}
 
+/* intercala com melhorias */
+void intercala_melhorado (int v[], int aux[], int ini, int meio, int fim) 
+{
+	/* indices do vetor v */
 	int i = ini;
 	int j = meio +1;
-	int k = 0;
+	/* indice do vetor aux */
+	int k = ini;
 
 	/* intercala entre as duas seções do vetor aux */
 	while ( (i <= meio) && (j <= fim) )
@@ -423,30 +417,43 @@ void intercala_melhorado (int v[], int ini, int meio, int fim)
 		k++;
 	}
 	
-	copia_vetor2 (v, aux, ini, fim);
+	copia_vetor_melhorado (v, aux, ini, fim);
 }
 
 /* testa se duas particoes do merge já estao ordenadas */
-int esta_ordenado (int v[], int meio)
+int esta_ordenado (int v[], int aux[], int meio)
 {
-	if ( v[meio] < v[meio+1] )
+	if ( v[meio] < aux[meio+1] )
 		return 1;
 
 	return 0;
 }
 
 /* mergesort com melhorias */
-void mergesort_melhorado (int v[], int ini, int fim) 
+void mergesort_melhorado_com_aux (int v[], int aux[], int ini, int fim) 
 {
 	/* evita overflow */
 	int meio = ini + (fim - ini)/2;
 
-	if (ini < fim)
+	if (ini + LIMITE_INSERTION > fim)
+		insertionsort (v, ini, fim);
+
+	else
 	{
-		/* implementar intercalar o aux e o v */
-		mergesort_melhorado (v, ini, meio);
-		mergesort_melhorado (v, meio+1, fim);
-		if (!esta_ordenado (v, meio))
-			intercala_melhorado (v, ini, meio, fim);
+		mergesort_melhorado_com_aux (v, aux, ini, meio);
+		mergesort_melhorado_com_aux (aux, v, meio+1, fim);
+		if (!esta_ordenado (v, aux, meio))
+			intercala_melhorado (v, aux, ini, meio, fim);
 	}
 }
+
+void mergesort_melhorado (int v[], int ini, int fim)
+{
+	int *aux;
+	aux = (int*) malloc ((fim+1)*sizeof(int));
+
+	copia_vetor (v, aux, ini, fim);
+	mergesort_melhorado_com_aux (v, aux, ini, fim);
+	
+	free (aux);
+}

quick_vs_merge.log → logs/quick_vs_merge.log

@@ -31,17 +31,10 @@ Algoritmo:    quicksort_mediana3 (R) | Iterações:   100 | Tamanho:      10000
 Algoritmo:    quicksort_mediana3 (R) | Iterações:   100 | Tamanho:     100000 | Tempo:       18.152781 milisegundos.
 Algoritmo:    quicksort_mediana3 (R) | Iterações:   100 | Tamanho:    1000000 | Tempo:      209.309841 milisegundos.
 
-Algoritmo:  mergesort_melhorado1 (R) | Iterações:     100 | Tamanho:         10 | Tempo:        0.002588 milisegundos.
-Algoritmo:  mergesort_melhorado1 (R) | Iterações:     100 | Tamanho:        100 | Tempo:        0.016948 milisegundos.
-Algoritmo:  mergesort_melhorado1 (R) | Iterações:     100 | Tamanho:       1000 | Tempo:        0.168647 milisegundos.
-Algoritmo:  mergesort_melhorado1 (R) | Iterações:     100 | Tamanho:      10000 | Tempo:        1.963350 milisegundos.
-Algoritmo:  mergesort_melhorado1 (R) | Iterações:     100 | Tamanho:     100000 | Tempo:       23.164280 milisegundos.
-Algoritmo:  mergesort_melhorado1 (R) | Iterações:     100 | Tamanho:    1000000 | Tempo:      271.175571 milisegundos.
-
-Algoritmo:  mergesort_melhorado2 (R) | Iterações:     100 | Tamanho:         10 | Tempo:        0.002358 milisegundos.
-Algoritmo:  mergesort_melhorado2 (R) | Iterações:     100 | Tamanho:        100 | Tempo:        0.038579 milisegundos.
-Algoritmo:  mergesort_melhorado2 (R) | Iterações:     100 | Tamanho:       1000 | Tempo:        0.242908 milisegundos.
-Algoritmo:  mergesort_melhorado2 (R) | Iterações:     100 | Tamanho:      10000 | Tempo:        1.882322 milisegundos.
-Algoritmo:  mergesort_melhorado2 (R) | Iterações:     100 | Tamanho:     100000 | Tempo:       22.596338 milisegundos.
-Algoritmo:  mergesort_melhorado2 (R) | Iterações:     100 | Tamanho:    1000000 | Tempo:      267.566848 milisegundos.
+Algoritmo:   mergesort_melhorado (R) | Iterações:     100 | Tamanho:         10 | Tempo:        0.001213 milisegundos.
+Algoritmo:   mergesort_melhorado (R) | Iterações:     100 | Tamanho:        100 | Tempo:        0.024856 milisegundos.
+Algoritmo:   mergesort_melhorado (R) | Iterações:     100 | Tamanho:       1000 | Tempo:        0.066545 milisegundos.
+Algoritmo:   mergesort_melhorado (R) | Iterações:     100 | Tamanho:      10000 | Tempo:        0.615146 milisegundos.
+Algoritmo:   mergesort_melhorado (R) | Iterações:     100 | Tamanho:     100000 | Tempo:        8.090613 milisegundos.
+Algoritmo:   mergesort_melhorado (R) | Iterações:     100 | Tamanho:    1000000 | Tempo:      114.690315 milisegundos.