Hola esta bien tu código pero me pregunto, necesitas un arreglo para almacenar los registro y otro del mismo tamaño para saber en que posición se encontrarían ordenados? siendo muy estrictos realmente no es un método de ordenamiento ya que los datos siguen como en su estado original.

Pero bueno tomemos tu algoritmo como valido y comparemoslo frente a otros algoritmos amplia-mente documentados y como serian bubble sort y Quick sort como se comporta

Para ello necesitamos algunas subrutinas que nos midan el tiempo de procesamiento de nuestros algoritmos lamentablemente hacer esto no siempre es muy preciso y depende del sistema operativo y arquitectura de la computadora donde se ejecuten estas pruebas.

La primera prueba que vamos a hacer es con tu algoritmo para ello lo encapsule en una función y decidí tomar algunas muestras

#include <stdio.h>
#include<windows.h>
#include <time.h>
 
double performancecounter_diff(LARGE_INTEGER *a, LARGE_INTEGER *b){
    LARGE_INTEGER freq;
    QueryPerformanceFrequency(&freq);
    return (double)(a->QuadPart - b->QuadPart) / (double)freq.QuadPart;
}
 
 
 
void rellenarOrdenarDatos(int numeros[],int ordenar[],int tamano){
    int i,j,ingreso;
    srand(time(NULL));
 
    for( i=0; i<tamano; i++){
 
        ingreso = rand()%100;
        numeros[i]=ingreso;
        ordenar[i] = 1;
 
        if(i>0){
            j=0;
            while(j<i){
                if( ingreso < numeros[j] ){
                    ordenar[j] += 1;
                }
                else{
                    ordenar[i] += 1;
                }
                j++;
            }
        }
    }
}
 
int main()
{
    const int TAMANO=15000;
    int *arreglo=malloc(sizeof(int)*TAMANO);
    int *ordenar=malloc(sizeof(int)*TAMANO);
 
    LARGE_INTEGER t_ini, t_fin;
    double secs;
 
    QueryPerformanceCounter(&t_ini);
 
    rellenarOrdenarDatos(arreglo,ordenar,TAMANO);
 
    QueryPerformanceCounter(&t_fin);
 
    secs = performancecounter_diff(&t_fin, &t_ini);
    printf("%.16g milliseconds\n", secs * 1000.0);
 
    free(arreglo);
    free(ordenar);
 
    return 0;
}

Entre las muestras que obtuve fueron estos tiempos en milisegundos

Ahora la prueba con BubbleSort

#include <stdio.h>
#include<windows.h>
#include <time.h>
 
double performancecounter_diff(LARGE_INTEGER *a, LARGE_INTEGER *b){
    LARGE_INTEGER freq;
    QueryPerformanceFrequency(&freq);
    return (double)(a->QuadPart - b->QuadPart) / (double)freq.QuadPart;
}
 
 
 
 
void rellenarArreglo(int numeros[],unsigned int tamano){
    srand(time(NULL));
    int i=0;
 
    for(i=0; i<tamano; i++)
    {
        int r = rand()%100+1;
        numeros[i]=r;
    }
}
 
void bubbleSort(int numeros[],int tamano){
    int i,j,temp;
    for (i=1; i<tamano; i++){
      for(j=0 ; j<tamano - 1; j++){
         if (numeros[j] > numeros[j+1]){
            temp = numeros[j];
            numeros[j] = numeros[j+1];
            numeros[j+1] = temp;
         }
      }
    }
}
 
 
 
int main()
{
    const int TAMANO=15000;
    int *arreglo=malloc(sizeof(int)*TAMANO);
 
 
    LARGE_INTEGER t_ini, t_fin;
    double secs;
 
    QueryPerformanceCounter(&t_ini);
 
    rellenarArreglo(arreglo,TAMANO);
    bubbleSort(arreglo,TAMANO);
 
    QueryPerformanceCounter(&t_fin);
 
    secs = performancecounter_diff(&t_fin, &t_ini);
    printf("%.16g milliseconds\n", secs * 1000.0);
 
    free(arreglo);
 
 
    return 0;
}

Utilizando el algoritmo bubble sort el tiempo de procesamiento fue mas alto por ende menos optimo aproximadamente 1500 milsegundos en promedio, en este caso te debo los tiempos exactos

Por ultimo utilize el algoritmo Quick Sort y la diferencia fue abismal
El siguiente codigo es similar al anterior salvo por el metodo de ordenamiento

void qs(int lista[],int limite_izq,int limite_der)
{
    int izq,der,temporal,pivote;
 
    izq=limite_izq;
    der = limite_der;
    pivote = lista[(izq+der)/2];
 
    do{
        while(lista[izq]<pivote && izq<limite_der)izq++;
        while(pivote<lista[der] && der > limite_izq)der--;
        if(izq <=der)
        {
            temporal= lista[izq];
            lista[izq]=lista[der];
            lista[der]=temporal;
            izq++;
            der--;
 
        }
 
    }while(izq<=der);
    if(limite_izq<der){qs(lista,limite_izq,der);}
    if(limite_der>izq){qs(lista,izq,limite_der);}
 
}
 
void quicksort(int lista[],int n)
{
    qs(lista,0,n-1);
}
 
 
 
int main()
{
    const int TAMANO=15000;
    int *arreglo=malloc(sizeof(int)*TAMANO);
 
 
    LARGE_INTEGER t_ini, t_fin;
    double secs;
 
    QueryPerformanceCounter(&t_ini);
 
    rellenarArreglo(arreglo,TAMANO);
    quicksort(arreglo,TAMANO);
 
    QueryPerformanceCounter(&t_fin);
 
    secs = performancecounter_diff(&t_fin, &t_ini);
    printf("%.16g milliseconds\n", secs * 1000.0);
 
    free(arreglo);
 
 
    return 0;
}

Aqui una lista de tiempos obtenidos

En promedio 2 mili-segundos el tiempo de procesamiento

En conclusion yo te recomendaria usar une metodo de ordenamiento ya que ademas de que evitas reservar memoria inecesaria el performance es mejor.

SI hay dudas o no estas de acuerdo con algo no dudes en hacermelo saber.
Saludos....

Tu idea esta bien, te sirve bastante si no quieres estar moviendo los registros "fisicamente" en su posicion del archivo.

Asi solo guardas en un arreglo externo que el registro X del archivo esta en el orden TAL.

Y podrias implementar una busqueda casi binaria por ejemplo tienes 1000 Registros y buscas por la letra T o no se la palabra tocar, vez quien es el registro 500 y si la palabra tocar es mayor te desplazas 250 registros mas adelante y buscas en el registro 750 y si es mayor o menor te desplazas 125 registros adelante o atras y asi sucesivamente. Para buscar rapidamente la palabra tal....

Saludos!

No estoy seguro de cuales son los datos ingresados pero el problema puede ser el strcmp, ya que solo lo tienes mejor que cero y strcmp puede devolver -1, 0 o 1 segun sea menor, igual o mayor deberias de cambiarlo por !=

strcmp( tmp.ingles, idiomas.ingles ) != 0

Saludos!

Nunca lo he provado de esa forma prefiero manejarlo desde el SEEK_SET para hacerlo desde el inicio del archivo. lo que me gusta hacer es tener un contador para saber cual es el numero de registro actual y si quiero regrersar al que previamente lei lo que hago es

fseek(file, (contador-1)*sizeof(Idiomas), SEEK_SET);

Tendria que probar con la posición SEEK_CUR como lo mencionas.

Saludos!

De las 2 formas es valido.

Si es la misma cantidad de registros no hay por que preocuparse...

Se mueve a la posicion 0 con fseek y se escribe registro por registro.

En caso de que quieraa reescribir (borrar y escribir)

Solo hay que cerrar el archivo actual y abrir uno nuevo con el mismo nombre y en modo "w" o "wb" segun sea de texto o binario y asi escribir registro por registro en el archivo nuevo.

Saludos