¿Se puede optimizar el siguiente codigo?

[aguml]

Hola amigos, he estado liado con el tema de verificar archivos por lotes usando un hash. El problema surgio cuando la aplicacion que probé me creaba un archivo con todos los md5 en un orden para un directorio y luego me creaba otro archivo con todos los md5 en otro orden para una copia del mismo directorio. No se porque hacia eso y no me los muestra todos ordenados pero me puse a crearme una solucion rapida en C que lo que hace es abrir el primer archivo y va buscando cada md5 en el segundo y los va poniendo en un tercer archivo en el mismo orden.
Ciertamente cada linea tiene el hash y al lado la ruta relativa al archivo con lo que lo que busco para ordenar es la ruta y no el md5 ya que este puede haber cambiado y no lo encontraria.
El caso es que aparentemente parece que funciona pero tarda para unas 70000 lineas como 5 minutos para ordenarlas en un tercer archivo. ¿Hay alguna manera de optimizarlo sin usar bases de datos?
Aqui el codigo:

Código C:

//---------------------------------------------------------------------------
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <errno.h>
#include <limits.h>
#define SIZEMAX 1024
//---------------------------------------------------------------------------
 
typedef enum {
    STR2INT_SUCCESS,
    STR2INT_OVERFLOW,
    STR2INT_UNDERFLOW,
    STR2INT_INCONVERTIBLE
} str2int_errno;
 
int CheckFileError(FILE *fichero,char *fullpath)
{
    int error=0;
 
    if(fichero == NULL){
        printf("No se pudo abrir el archivo %s. Asegurese de que la ruta y el nombre son correctos.\n",fullpath);
        error=-1;
    }
    return error;
}
//---------------------------------------------------------------------------
 
void CerrarArchivos(FILE **origen1,FILE **origen2,FILE **destino2)
{
    if(*origen1 != NULL){
        fclose(*origen1);
        *origen1=NULL;
        if(*origen2 != NULL){
            fclose(*origen2);
            *origen2=NULL;
            if(*destino2 != NULL){
                fclose(*destino2);
                *destino2=NULL;
            }
        }
    }
}
//---------------------------------------------------------------------------
 
int AbrirArchivos(FILE **origen1,FILE **origen2,FILE **destino2,char *pathOrigen1,char *pathOrigen2,char *pathDestino2)
{
    int error;
 
    *origen1=fopen(pathOrigen1,"r");
    if((error=CheckFileError(*origen1,pathOrigen1))!=0){
        CerrarArchivos(origen1,origen2,destino2);
        system("pause");
        return error;
    }
 
    *origen2=fopen(pathOrigen2,"r");
    if((error=CheckFileError(*origen2,pathOrigen2))!=0){
        CerrarArchivos(origen1,origen2,destino2);
        system("pause");
        return error;
    }
 
    *destino2=fopen(pathDestino2,"w");
    if((error=CheckFileError(*destino2,pathDestino2))!=0){
        CerrarArchivos(origen1,origen2,destino2);
        system("pause");
        return error;
    }
    return error;
}
//---------------------------------------------------------------------------
 
void clean(void)
{
    char a;
    while(getchar()!='\n');
}
//---------------------------------------------------------------------------
 
void ObtenerRutas(char *pathOrigen1,char *pathOrigen2,char *pathDestino2,int *largoHash)
{
    int largo;
 
    printf("Introduce la ruta completa hacia el primer archivo:\n\t");
    fgets(pathOrigen1,SIZEMAX,stdin);
    largo=strlen(pathOrigen1);
    if(pathOrigen1[largo-1]!='\n'){
        clean();
        printf("Ruta demasiado larga.\n");
    }else{
        pathOrigen1[largo-1]='\0';
    }
    printf("Introduce la ruta completa hacia el segundo archivo:\n\t");
    fgets(pathOrigen2,SIZEMAX,stdin);
    largo=strlen(pathOrigen2);
    if(pathOrigen2[largo-1]!='\n'){
        clean();
        printf("Ruta demasiado larga.\n");
    }else{
        pathOrigen2[largo-1]='\0';
    }
    printf("Introduce la ruta completa para el archivo de salida:\n\t");
    fgets(pathDestino2,SIZEMAX,stdin);
    largo=strlen(pathDestino2);
    if(pathDestino2[largo-1]!='\n'){
        clean();
        printf("Ruta demasiado larga.\n");
    }else{
        pathDestino2[largo-1]='\0';
    }
    printf("Introduce el numero de caracteres del hash: ");
    scanf("%d",largoHash);
}
//---------------------------------------------------------------------------
 
//Para convertir el parametro del largo del hash de cadena a entero
str2int_errno str2int(int *out, char *s, int base) {
    char *end;
    long l;
    
    if (s[0] == '\0' || isspace((unsigned char) s[0]))
        return STR2INT_INCONVERTIBLE;
    errno = 0;
    l = strtol(s, &end, base);
 
    if (l > INT_MAX || (errno == ERANGE && l == LONG_MAX))
        return STR2INT_OVERFLOW;
    if (l < INT_MIN || (errno == ERANGE && l == LONG_MIN))
        return STR2INT_UNDERFLOW;
    if (*end != '\0')
        return STR2INT_INCONVERTIBLE;
    *out = l;
    return STR2INT_SUCCESS;
}
//---------------------------------------------------------------------------
 
int CheckParams(int nParametros, char *parametros[], char *pathOrigen1,char *pathOrigen2,char *pathDestino2,int *largoHash)
{
    str2int_errno error_param_hash;
    char mensaje[SIZEMAX];
    
    if(nParametros == 5){
        strcpy(pathOrigen1,parametros[1]);
        strcpy(pathOrigen2,parametros[2]);
        strcpy(pathDestino2,parametros[3]);
        error_param_hash=str2int(largoHash,parametros[4],10);
        switch(error_param_hash){
            case STR2INT_OVERFLOW:
                strcpy(mensaje,"STR2INT_OVERFLOW");
            break;
 
            case STR2INT_UNDERFLOW:
                strcpy(mensaje,"STR2INT_UNDERFLOW");
            break;
 
            case STR2INT_INCONVERTIBLE:
                strcpy(mensaje,"STR2INT_INCONVERTIBLE");
            break;
        }
        if(error_param_hash != STR2INT_SUCCESS){
            printf("Error en el parametro para el largo del hash. Error: %s\n",mensaje);
            system("pause");
            return -1;
        }
        if(*largoHash < 0){
            printf("El valor asignado al largo del hash no puede ser menor que '0'.\nSi no hay hash ponga '0'.\n");
            system("pause");
            return -1;
        }
    }else if(nParametros > 1){
        printf("parametros incorrectos.\n");
        system("pause");
        return -1;
    }else{
        ObtenerRutas(pathOrigen1,pathOrigen2,pathDestino2,largoHash);
    }
    return 0;
}
//---------------------------------------------------------------------------
 
void CrearFicheroOrdenado(char *pathOrigen1,char *pathOrigen2,char *pathDestino2,int largoHash)
{
    char buffer1[SIZEMAX];
    char buffer2[SIZEMAX];
    FILE *origen1=NULL,*origen2=NULL,*destino2=NULL;
    int encontrado,largo,noEncontrados=0;
 
    if(AbrirArchivos(&origen1,&origen2,&destino2,pathOrigen1,pathOrigen2,pathDestino2)==0){
        printf("Ha comenzado el proceso. No cierre esta ventana hasta que termine el proceso.");
        while(!feof(origen1) && fgets(buffer1,sizeof(buffer1),origen1) != NULL){
            encontrado=0;
            rewind(origen2);
            while(!feof(origen2) && fgets(buffer2,sizeof(buffer2),origen2) != NULL && encontrado == 0){
                largo=strlen(&buffer1[largoHash]);
                if(strncmp(&buffer1[largoHash],&buffer2[largoHash],largo)==0){
                    encontrado=1;
                    break;
                }
            }
            if(encontrado==1)
                fputs(buffer2,destino2);
            else{
                fputs("\n",destino2);
                noEncontrados++;
            }
        }
        CerrarArchivos(&origen1,&origen2,&destino2);
        printf("Proceso finalizado.\n");
        if(noEncontrados > 0)
            printf("No se encontraron en \"%s\" %d entradas.\n",origen2,noEncontrados);
        system("pause");
    }
}
//---------------------------------------------------------------------------
 
//Se puede usar con parametros tambien
int main(int argc, char* argv[])
{
    char pathOrigen1[SIZEMAX];
    char pathOrigen2[SIZEMAX];
    char pathDestino2[SIZEMAX];
    int largoHash;
 
    if(CheckParams(argc,argv,pathOrigen1,pathOrigen2,pathDestino2,&largoHash) == 0)
        CrearFicheroOrdenado(pathOrigen1,pathOrigen2,pathDestino2,largoHash);
    return 0;
}
//---------------------------------------------------------------------------
 

El caso es que si está mas o menos ordenado al empezar pues cuanto mas avance mas tardará en encontrar el siguiente y asi hasta el final y si es muy largo el archivo pues se puede hacer eterno jajaja.

[enrieto]

Hola. Sin intención de ofender, por favor, pero para hacer el universo de respuestas un poco más manejables yo cambiaría la pregunta por "¿hay alguna forma de hacerlo peor?" Si el archivo origen1 tuviera 70.000 líneas, igual que el archivo origen2, este sorprendente algoritmo necesitaría 4.900 millones de comparaciones. Extraordinario.

Una primera intención: ¿el archivo origen2 puede cargarse en memoria? Si fuera posible: qsort para ordenarlo y búsqueda binaria.

Si origen2 no cupiera en memoria: segunda intención: [URL="https://en.wikipedia.org/wiki/External_sorting"]External sorting[/URL] y la búsqueda binaria sobre el archivo ordenado.

Y bueno, cualquier otra solución que se te ocurra que incluya "orden" entre sus premisas, no puede resultar peor que las 4.900 millones de comparaciones :)

[eferion]

Un hash de digamos 64 caracteres mas una ruta de digamos 500 caracteres, en 70.000 líneas nos daría un consumo aproximado de 38MB (que será menos si conviertes el hash a entero), no veo qué problema puede presentar leer dos ficheros de esas características en memoria y realizar la ordenación directamente en memoria, como te está proponiendo enrieto.

Para ordenar desde el fichero puedes optar por crearte un índice en memoria que te indique en qué posición empieza cada línea del fichero a ordenar e iterar sobre dicho índice. Usar el índice te permite ir al inicio de cada registro directamente sin tener que hacer cálculos repetitivos. Cada vez que ordenas un elemento eliminas dicha entrada del índice (o lo marcas como usado) y te ahorras futuras comprobaciones sobre dicho elemento.

Opciones hay bastantes unas más rápidas pero más complejas de implementar y otras más lentas pero con una algorítmica más sencilla.

Un saludo.

[aguml]

A ver, pensé en hacer una búsqueda binaria y qsort pero me encontré con un problema. Lo que comparo no son valores numéricos sino ruta a archivos y son cadenas ¿como puedo saber si una ruta es mayor o menor que otra para poder hacer una búsqueda binaria?

[eferion]

strcmp permite comparar cadenas. ¿Cómo lo hace? algo así:

Código C:

int strcmp(const char* cad1, const char* cad2)
{
  int ret = 0;
  for( int i=0; ret==0 && cad1[i] != 0; i++)
    ret = cad1[i] - cad2[i];
  return ret;
}
 

Es decir, recorre las dos cadenas y realiza una resta del valor de los caracteres en cada posición. Si las dos cadenas son iguales la resta dará 0 mientras que en caso contrario el resultado será un valor positivo si cad1 es mayor o más larga que cad2 o negativo en caso contrario.

Puedes aprovechar ese mismo principio para ordenar los ficheros.

Otra cosa es que desees un orden determinado. En ese caso te tocará introducir algunos cambios para adaptar la ordenación a tus necesidades.

Un saludo.

[aguml]

Muy bien, siguiendo vuestros consejos estoy intentando reconducir el codigo y de momento estoy probando con esto:

Código C:

/* funcion para comparar strings de C para qsort */
int cstring_cmp(const void *a, const void *b)
{
    const char **ia = (const char **)a;
    const char **ib = (const char **)b;
    return strcmp(*ia, *ib);
}
//---------------------------------------------------------------------------
 
//Se puede usar con parametros tambien
int main(int argc, char* argv[])
{
    char pathOrigen1[SIZEMAX];
    char pathOrigen2[SIZEMAX];
    char pathDestino2[SIZEMAX];
    char **buffer;
    int largoHash,nElementos;
    FILE *origen1=NULL,*origen2=NULL,*destino2=NULL;
 
    if(CheckParams(argc,argv,pathOrigen1,pathOrigen2,pathDestino2,&largoHash) == 0){
        if((nElementos=CargarFicheroEnMemoria(origen2,pathOrigen2,&buffer)) > 0){
            qsort(buffer, nElementos, sizeof(char *), cstring_cmp);
        }
    }
    return 0;
}
 

Me encuentro con 2 problemas:
1- En la funcion CargarFicheroEnMemoria realloc falla porque hago algo mal y no doy con la tecla.
2- En la funcion que compara las strings el problema es que no quiero comparar las dos cadenas enteras, o sea, querria comparar ambas cadenas a partir de la posicion 32 de cada una por ejemplo y tampoco se como indicarle eso. Se me ocurre ponerlo asi pero no se si es correcto y hasta que no solucione el primer problema no podre probarlo:

Código C:

/* funcion para comparar strings de C para qsort */
int cstring_cmp(const void *a, const void *b)
{
    const char **ia = (const char **)a;
    const char **ib = (const char **)b;
    return strcmp(&(*ia[32]), &(*ib[32]));
}
 

[eferion]

Código C:

int cstring_cmp(const void *a, const void *b)
{
    const char **ia = (const char **)a;
    const char **ib = (const char **)b;
    return strcmp(*ia, *ib);
}
 

¿por qué tanto odio en esa función? ¿No te valía con usar punteros simples?

Código C:

int cstring_cmp(const void *a, const void *b)
{
    const char *ia = (const char *)a;
    const char *ib = (const char *)b;
    return strcmp(ia, ib);
}
 

Aparte que convertir un void* en un char** o, lo que es lo mismo, un puntero simple en uno doble, no parece buena idea.

[aguml]

Iniciado por eferion

Código C:

int cstring_cmp(const void *a, const void *b)
{
    const char **ia = (const char **)a;
    const char **ib = (const char **)b;
    return strcmp(*ia, *ib);
}
 

¿por qué tanto odio en esa función? ¿No te valía con usar punteros simples?

Código C:

int cstring_cmp(const void *a, const void *b)
{
    const char *ia = (const char *)a;
    const char *ib = (const char *)b;
    return strcmp(ia, ib);
}
 

Aparte que convertir un void* en un char** o, lo que es lo mismo, un puntero simple en uno doble, no parece buena idea.

La verdad es que para ello tuve que buscar info por internet y en todas partes veo que lo hacen asi y me basé en este codigo: http://www.anyexample.com/programmin...nd_structs.xml

[eferion]

El problema es que has intentado innovar y has puesto un doble puntero donde ellos usan un puntero simple:

Copiado del enlace que facilitas:

Código C:

/* qsort int comparison function */ 
int int_cmp(const void *a, const void *b) 
{ 
    const int *ia = (const int *)a; // casting pointer types 
    const int *ib = (const int *)b;
    return *ia  - *ib; 
    /* integer comparison: returns negative if b > a 
    and positive if a > b */ 
}
 

[aguml]

Esa función que pones es la que usa para comparar enteros. Si miras la que usa para comparar cadenas veras que es diferente.

[eferion]

Ya no recordaba la de putadas que se hacían en C con los tipos.

[aguml]

Jajaja.
Lo más urgente ahora es resolver el problema que tengo al reservar la memoria para volcar el archivo. Lo otro cuando funcione esto ya veremos si hay que llamar a los artificieros para que no explote el pc jijiji.
He hecho esta modificacion porque he leido que si falla realloc se produciria una fuga de memoria como yo lo estaba haciendo y que habia que usar un puntero auxiliar asi que asi lo he dejado:

Código C:

void LiberarMemoria(char ***buffer,int nlines)
{
    int index;
 
    if(buffer != NULL && *buffer != NULL){
        for(index=0;index < nlines;index++)
            free(*buffer[index]);
        free(*buffer);
    }
}
//---------------------------------------------------------------------------
 
int CargarFicheroEnMemoria(FILE *origen, char *path,char ***pbuffer)
{
    int nlines=0,largo;
    char aux[SIZEMAX];
    char **paux;
 
    origen=fopen(path,"r");
 
    if(origen != NULL){
        *pbuffer=NULL;
        while(!feof(origen)){
            memset(aux,'\0',SIZEMAX);
            fgets(aux,SIZEMAX,origen);
            largo=strlen(aux);
            nlines++;
            paux=(char**)realloc(*pbuffer,nlines*sizeof(char**));
            if(paux != NULL){
                *pbuffer=paux;
                *pbuffer[nlines-1]=(char*)malloc(sizeof(char*)*largo);
                strcpy(*pbuffer[nlines-1],aux);
            }else{
                printf("No hay suficiente memoria disponible para volcar el archivo.\n");
                LiberarMemoria(pbuffer,nlines-1);
            }
        }
    }
    return nlines;
}
 

Sigue teniendo el mismo fallo y es porque no hago bien el trabajo de punteros y no se que hago mal al respecto. ¿podeis ayudarme?

[aguml]

Bueno, al final he encontrado una manera de codear lo que quiero y optimizando muy mucho el tiempo aunque ocupando mas memoria. Este es el codigo:

Código C:

//---------------------------------------------------------------------------
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <errno.h>
#include <limits.h>
#define SIZEMAX 1024
 
 
typedef enum {
    STR2INT_SUCCESS,
    STR2INT_OVERFLOW,
    STR2INT_UNDERFLOW,
    STR2INT_INCONVERTIBLE
} str2int_errno;
 
int largoHash;
//---------------------------------------------------------------------------
 
void clean(void)
{
    char a;
    while(getchar()!='\n');
}
//---------------------------------------------------------------------------
 
void ObtenerRutas(char *pathOrigen1,char *pathOrigen2,char *pathDestino2,int *largoHash)
{
    int largo;
 
    printf("Introduce la ruta completa hacia el primer archivo:\n\t");
    fgets(pathOrigen1,SIZEMAX,stdin);
    largo=strlen(pathOrigen1);
    if(pathOrigen1[largo-1]!='\n'){
        clean();
        printf("Ruta demasiado larga.\n");
    }else{
        pathOrigen1[largo-1]='\0';
    }
    printf("Introduce la ruta completa hacia el segundo archivo:\n\t");
    fgets(pathOrigen2,SIZEMAX,stdin);
    largo=strlen(pathOrigen2);
    if(pathOrigen2[largo-1]!='\n'){
        clean();
        printf("Ruta demasiado larga.\n");
    }else{
        pathOrigen2[largo-1]='\0';
    }
    printf("Introduce la ruta completa para el archivo de salida:\n\t");
    fgets(pathDestino2,SIZEMAX,stdin);
    largo=strlen(pathDestino2);
    if(pathDestino2[largo-1]!='\n'){
        clean();
        printf("Ruta demasiado larga.\n");
    }else{
        pathDestino2[largo-1]='\0';
    }
    printf("Introduce el numero de caracteres del hash: ");
    scanf("%d",largoHash);
}
//---------------------------------------------------------------------------
 
//Para convertir el parametro del largo del hash de cadena a entero
str2int_errno str2int(int *out, char *s, int base) {
    char *end;
    long l;
 
    if (s[0] == '\0' || isspace((unsigned char) s[0]))
        return STR2INT_INCONVERTIBLE;
    errno = 0;
    l = strtol(s, &end, base);
 
    if (l > INT_MAX || (errno == ERANGE && l == LONG_MAX))
        return STR2INT_OVERFLOW;
    if (l < INT_MIN || (errno == ERANGE && l == LONG_MIN))
        return STR2INT_UNDERFLOW;
    if (*end != '\0')
        return STR2INT_INCONVERTIBLE;
    *out = l;
    return STR2INT_SUCCESS;
}
//---------------------------------------------------------------------------
 
int CheckParams(int nParametros, char *parametros[], char *pathOrigen1,char *pathOrigen2,char *pathDestino2,int *largoHash)
{
    str2int_errno error_param_hash;
    char mensaje[SIZEMAX];
 
    if(nParametros == 5){
        strcpy(pathOrigen1,parametros[1]);
        strcpy(pathOrigen2,parametros[2]);
        strcpy(pathDestino2,parametros[3]);
        error_param_hash=str2int(largoHash,parametros[4],10);
        switch(error_param_hash){
            case STR2INT_OVERFLOW:
                strcpy(mensaje,"STR2INT_OVERFLOW");
            break;
 
            case STR2INT_UNDERFLOW:
                strcpy(mensaje,"STR2INT_UNDERFLOW");
            break;
 
            case STR2INT_INCONVERTIBLE:
                strcpy(mensaje,"STR2INT_INCONVERTIBLE");
            break;
        }
        if(error_param_hash != STR2INT_SUCCESS){
            printf("Error en el parametro para el largo del hash. Error: %s\n",mensaje);
            return -1;
        }
        if(*largoHash < 0){
            printf("El valor asignado al largo del hash no puede ser menor que '0'.\nSi no hay hash ponga '0'.\n");
            return -2;
        }
    }else if(nParametros > 1){
        printf("parametros incorrectos.\n");
        return -3;
    }else{
        ObtenerRutas(pathOrigen1,pathOrigen2,pathDestino2,largoHash);
    }
    return 0;
}
//---------------------------------------------------------------------------
 
void DescartarElemento(char **buffer,int pos,int *nElementos)
{
    int i;
 
    for(i=pos; i < *nElementos-1; i++){
        buffer[i]=buffer[i+1];
    }
    (*nElementos)--;
}
//---------------------------------------------------------------------------
 
int CrearFicheroOrdenado(char **bufferFile1,char **bufferFile2,char *pathDestino,int largoHash,int nElementosBufferFile1,int nElementosBufferFile2)
{
    FILE *destino=NULL;
    int encontrado,noEncontrados=0;
    int i,j,retval=0;
    char **arrayAuxiliar;
 
    destino=fopen(pathDestino,"w");
 
    if(destino == NULL)
        return -1;
 
    printf("Ha comenzado el proceso. No cierre esta ventana hasta que termine el proceso.\n");
    arrayAuxiliar=malloc(nElementosBufferFile2 * sizeof(char**));
 
    if(arrayAuxiliar == NULL){
        fclose(destino);
        remove(pathDestino);
        return -2;
    }
 
    memcpy(arrayAuxiliar,bufferFile2,nElementosBufferFile2 * sizeof(char**));
 
    for(i=0; i < nElementosBufferFile1; i++){
        encontrado=0;
        for(j=0; j < nElementosBufferFile2; j++){
            if(strcmp(bufferFile1[i],arrayAuxiliar[j])==0){
                encontrado=1;
                break;
            }
        }
        if(encontrado==1){
            fputs(arrayAuxiliar[j],destino);
            DescartarElemento(arrayAuxiliar,j,&nElementosBufferFile2);
        }else{
            fputs("\n",destino);
            noEncontrados++;
        }
    }
    free(arrayAuxiliar);
    fclose(destino);
 
    if(noEncontrados > 0)
        retval=noEncontrados;
 
    return retval;
}
//---------------------------------------------------------------------------
 
void LiberarMemoria(char **buffer,int nlines)
{
    int index;
 
    if(buffer != NULL){
        for(index=0;index < nlines;index++)
            free(buffer[index]);
        free(buffer);
        buffer=NULL;
    }
}
//---------------------------------------------------------------------------
 
char** CargarFicheroEnMemoria(char *path,int *nlines)
{
    int largo;
    char aux[SIZEMAX];
    char **pbuffer,**paux;
    FILE *origen;
    origen=fopen(path,"r");
 
    *nlines=0;
    if(origen != NULL){
        pbuffer=NULL;
        do{
            memset(aux,'\0',SIZEMAX);
            fgets(aux,SIZEMAX,origen);
            if(!feof(origen)){
                largo=strlen(aux);
                (*nlines)++;
                paux=(char**)realloc(pbuffer,*nlines*sizeof(char**));
                if(paux != NULL){
                    pbuffer=paux;
                    pbuffer[*nlines-1]=(char*)malloc(sizeof(char*)*largo);
                    strcpy(pbuffer[*nlines-1],aux);
                }else{
                    printf("No hay suficiente memoria disponible para volcar el archivo.\n");
                    LiberarMemoria(pbuffer,*nlines-1);
                }
            }
        }while(!feof(origen));
        fclose(origen);
    }
    return pbuffer;
}
//---------------------------------------------------------------------------
 
/* funcion para comparar strings de C para qsort */
int cstring_cmp(const void *a, const void *b)
{
    const char **ia = (const char **)a;
    const char **ib = (const char **)b;
    return strcmp(*ia+largoHash, *ib+largoHash);
}
//---------------------------------------------------------------------------
 
//Se puede usar con parametros tambien
int main(int argc, char* argv[])
{
    char pathOrigen1[SIZEMAX];
    char pathOrigen2[SIZEMAX];
    char pathDestino[SIZEMAX];
    char **bufferFile1,**bufferFile2;
    int nElementosFile1,nElementosFile2,retval;
 
    if(CheckParams(argc,argv,pathOrigen1,pathOrigen2,pathDestino,&largoHash) == 0){
        if((bufferFile1=CargarFicheroEnMemoria(pathOrigen1,&nElementosFile1)) > 0){
            if((bufferFile2=CargarFicheroEnMemoria(pathOrigen2,&nElementosFile2)) > 0){
                //Ordeno los elementos
                qsort(bufferFile2, nElementosFile2, sizeof(char *), cstring_cmp);
                retval=CrearFicheroOrdenado(bufferFile1,bufferFile2,pathDestino,largoHash,nElementosFile1,nElementosFile2);
 
                switch(retval){
                    case 0:
                        printf("Proceso finalizado correctamente.\n");
                        break;
                    case -1:
                        printf("Proceso finalizado con errores.\n");
                        printf("No se pudo abrir el archivo \"%s\".\n",pathOrigen2);
                        break;
                    case -2:
                        printf("Proceso finalizado con errores.\n");
                        printf("No se pudo obtener memoria suficiente.\n");
                        break;
                    default:
                        printf("Proceso finalizado.\n");
                        printf("No se encontraron %d entradas en \"%s\".\n",retval,pathOrigen2);
                }
                //Libero la memoria solicitada para guardar el archivo en ella
                LiberarMemoria(bufferFile2,nElementosFile2);
            }
            LiberarMemoria(bufferFile1,nElementosFile1);
        }
    }
    system("pause");
    return 0;
}
//---------------------------------------------------------------------------
 

[aguml]

La unica pega que tengo es que he tenido que colocar la variable largoHash como global porque tengo que usarla en la funcion cstring_cmp que es la que le paso como parametro a qsort y si intento ponerle otro parametro no me deja asi que si alguien tiene una sugerencia para no tener que ponerla como global soy todo oidos jejeje.
Por otro lado acepto criticas constructivas para mejorar el codigo y mi aptitud a la hora de codear pero por favor, criticas del estilo "¿se puede hacer peor?" no aportan nada y pueden desmoralizar a aquellos que empezamos y que, mas que ese tipo de criticas, necesitamos apoyo para no desanimarnos y acabar abandonando. A mi no me ha molestado eso aunque despues de varias horas codeando y esforzandome a tope por intentar hacerlo lo menor posible, ese comentario me cayó como un jarro de agua fria y la verdad es que me ha desanimado bastante y casi acabo borrando el codigo y olvidarme de el pero soy muy cabezon y me gusta mucho esto como para dejarlo de lado.
Al margen de eso, el tiempo ha mejorado de tardar unos 5 minutos a tardar unos 10 segundos .

[enrieto]

Hola; lamento que mi comentario te haya desmoralizado; releyendo veo que quedó bastante rudo, pero no fue intencional.
Como comentaste que estás empezando, permitime sugerirte que aproveches este mismo programa como incentivo y caso de estudio para el tema "ordenación y búsqueda", que creo que te va a resultar interesante.
Por ejemplo, yo te había sugerido (Thug Life mode) ordenar primero y "bsearch" después. Una búsqueda binaria sobre la segunda lista en memoria seguramente va a mejorar mucho. Te dejo un link básico, que tiene un ejemplo:
http://pubs.opengroup.org/onlinepubs/009695399/functions/bsearch.html
(básico, no trivial, claro; a partir de ahí podés buscar otros ejemplos y explicaciones).
Y como comentario medio irresponsable, porque no me puse a analizar tu código como si fuera para entregar mañana, se me ocurren un par de cosas mucho menos relevantes que hacer una búsqueda binaria antes que n x n secuenciales, como que me parece que sólo necesitas cargar en memoria y ordenar el segundo archivo, y el primero podés ir leyéndolo línea por línea así como está.
Otra cosa que puede mejorar los tempos un poquito más es tratar de evitar los realloc, lo más posible. Por ejemplo, quizá puedas leer las líneas del segundo archivo y ponerlas en un array de tamaño predeterminado; la cantidad de líneas la podés obtener dividiendo el largo del archivo por la longitud de cada línea. Ese arrya de cadenas pude ocupar un poco más de memoria, pero por un lado estarías cargando en memoria un solo archivo y no dos, y por el otro, la diferencia vale la pena en términos de "performance".

Si se tratara de mis prioridades y mis tiempos, yo dedicaría: dos días al tema "ordenación y búsqueda" (lecturas, desarrollo de ejemplos, comparaciones); un día para acomodar mi programa a lo nuevo que haya aprendido; un día para corregir y optimizar; 2 horas más para anotar y comentar mis conclusiones. Y con eso, y un par de oportunidades donde aplicar lo aprendido, ya me quedaría en paz con el tema hasta la próxima oportunidad.

[aguml]

Te comento algunos detalles:
No sabia de la existencia de qsort y bsearch y me parecen geniales. Sólo tengo una duda ¿que tan eficientes son? Lo digo porque, por ejemplo entre usar memset y un bucle, el bucle es más rápido y en temas de fuerza bruta es mejor evitar memset y no se si estas funciones adolecen del mismo problema. Otra cosa que he visto es que bsearch dice que si hay elementos duplicados el resultado es impredecible.
El tema de leer el archivo entero y obtener el número de elementos dividiendo por un tamaño determinado... creo que no es posible ya que no es un archivo secuencial y cada línea tiene un tamaño diferente.
Lo de leer el primer archivo línea a línea sin volcarlo en memoria, ciertamente ya lo leo línea a línea y no se porque lo metí en memoria jajaja. Tendré que probar ese cambio a ver que pasa.
Me parece que la mejora que ha tenido en tiempo es brutal y sabia que era más eficiente trabajar con memoria que con archivos pero no me esperaba tanta diferencia.
También tengo entendido que en eficiencia el único lenguaje capaz de plantar cara a C y ganarle es ASM ¿es cierto eso?

[enrieto]

qsort y bsearch

¿que tan eficientes son?

Creo que es el patrón más eficiente incluido en la biblioteca estándar del C. bsearch implementa el concepto de búsqueda binaria sobre una secuencia ordenada. Información razonable acá:
https://en.wikipedia.org/wiki/Binary_search_algorithm

Me parece que la mejora que ha tenido en tiempo es brutal

Si usaras una búsqueda binaria tendrías que llegar a los milisegundos.

el único lenguaje capaz de plantar cara a C y ganarle es ASM ¿es cierto eso?

No, no lo creo; el C++ es casi siempre más eficiente que el C, y en el peor de los casos es igual. Por ejemplo, el std::sort del C++ es entre 2 o 3 veces más rápido que qsort.

Ah, me olvidaba

bsearch dice que si hay elementos duplicados el resultado es impredecible

Código C:

void *bsearch(const void *key, const void *base, size_t nel,
       size_t width, int (*compar)(const void *, const void *));
 

bseach devuelve un puntero al valor en "base" que se corresponde con la "key"; si "base" tuviera valores repetidos, bsearch va a devolver un puntero a uno de esos, que puede ser el primero en la secuencia o no, no sabremos cuál.