Hoy vamos a resolver un ejercicio de programación en lenguaje C que trata sobre ordenar una lista de palabras contenidas en un archivo de texto. Dice algo así:

Dado un archivo con extensión txt cuyo contenido es una lista de palabras (separadas por un salto de línea) se leerá usando el lenguaje C, y después se va a imprimir esa misma lista pero con las palabras ya ordenadas de la Z a la A. Por ejemplo, si la lista es:
– Abraham
– Pedro
– Luis

El resultado en la consola será:
– Pedro
– Luis
– Abraham

Es decir, ordenado en orden descendente de la Z a la A.

Veamos cómo resolverlo.

Solución del problema

Lo primero que tenemos que hacer es ver la lista de palabras que será como se ve a continuación. En este caso solo son 20 palabras:

manzana
agua
pera
perro
zanahoria
papel
teclado
monitor
bocina
mesa
escritorio
alumno
celular
naranja
abraham
guayaba
rosa
maria
luis
lenguaje

A continuación leemos el archivo de texto y lo pasamos a un arreglo. Ahora que ya lo tenemos como arreglo, ordenamos ese arreglo de forma alfabética. Finalmente imprimimos el arreglo.

Te recomiendo que leas los artículos que he mencionado anteriormente, puedes hacer clic en el enlace para leerlo antes de continuar.

Ahora veamos el código.

Abrir archivo y pasarlo a arreglo

Leemos el contenido del archivo y lo copiamos a un array para una manipulación más sencilla.

// Arreglo de cadenas: aquí almacenamos todas las palabras
char palabras[CANTIDAD_PALABRAS][MAXIMA_LONGITUD_CADENA];
// Útil para leer el archivo
char buferArchivo[MAXIMA_LONGITUD_CADENA];
// Abrir el archivo...
FILE *archivo = fopen(NOMBRE_ARCHIVO, "r");
if (archivo == NULL)
{
    printf("No se puede abrir el archivo");
    return 0;
}
// Necesitamos este ayudante para saber en qué línea vamos
int indice = 0;
// Mientras podamos leer una línea del archivo
while (fgets(buferArchivo, MAXIMA_LONGITUD_CADENA, archivo))
{
    // Remover salto de línea
    strtok(buferArchivo, "\n");
    // Copiar la línea a nuestro arreglo, usando el índice
    memcpy(palabras[indice], buferArchivo, MAXIMA_LONGITUD_CADENA);
    // Aumentarlo en cada iteración
    indice++;
}

// Terminamos de leer
fclose(archivo);

Ordenar arreglo

Ahora veamos la función que ordena un arreglo con el método de la burbuja. Es muy parecida a la que cité anteriormente, solo que la he modificado porque en este caso necesitamos un orden descendente.

void burbuja(char arreglo[CANTIDAD_PALABRAS][MAXIMA_LONGITUD_CADENA])
{
    int longitud = CANTIDAD_PALABRAS;
    // Útil para hacer intercambio de cadenas
    char temporal[MAXIMA_LONGITUD_CADENA];
    int x, indiceActual;
    for (x = 0; x < longitud; x++)
    {
        for (indiceActual = 0; indiceActual < longitud - 1;
             indiceActual++)
        {
            int indiceSiguienteElemento = indiceActual + 1;
            // Si la cadena es menor que la siguiente (alfabeticamente) entonces intercambiamos
            if (strcmp(arreglo[indiceActual], arreglo[indiceSiguienteElemento]) <= 0)
            {
                // Movemos la cadena actual a la temporal
                memcpy(temporal, arreglo[indiceActual], MAXIMA_LONGITUD_CADENA);
                // Movemos al actual el siguiente elemento
                memcpy(arreglo[indiceActual], arreglo[indiceSiguienteElemento], MAXIMA_LONGITUD_CADENA);
                // Y en el siguiente elemento, lo que había antes en el actual pero ahora está en temporal
                memcpy(arreglo[indiceSiguienteElemento], temporal, MAXIMA_LONGITUD_CADENA);
            }
        }
    }
    // No hay necesidad de devolver nada, pues modificamos al arreglo de manera interna
}

Una vez definida, podemos invocarla para ordenar el arreglo:

// Ahora ya tenemos el arreglo. Vamos a ordenarlo.
// La función no devuelve nada, pues modifica al arreglo de manera interna
burbuja(palabras);
// Lo que resta ahora es imprimir, pues ya tenemos el arreglo ordenado
int i;
for (i = 0; i < CANTIDAD_PALABRAS; i++)
{
    printf("%s\n", palabras[i]);
}
return 0;

Y así es como hacemos que una lista desordenada (traída de un archivo) esté ordenada. En otras palabras, así ordenamos el contenido de un archivo de texto, pues más tarde podemos guardar el arreglo en otro archivo de salida.

Poniendo todo junto

El código completo para que puedas probar el ejercicio queda así:

/*
  ____          _____               _ _           _       
 |  _ \        |  __ \             (_) |         | |      
 | |_) |_   _  | |__) |_ _ _ __ _____| |__  _   _| |_ ___ 
 |  _ <| | | | |  ___/ _` | '__|_  / | '_ \| | | | __/ _ \
 | |_) | |_| | | |  | (_| | |   / /| | |_) | |_| | ||  __/
 |____/ \__, | |_|   \__,_|_|  /___|_|_.__/ \__, |\__\___|
         __/ |                               __/ |        
        |___/                               |___/         
    
____________________________________
/ Si necesitas ayuda, contáctame en \
\ https://parzibyte.me               /
 ------------------------------------
        \   ^__^
         \  (oo)\_______
            (__)\       )\/\
                ||----w |
                ||     ||
Creado por Parzibyte (https://parzibyte.me). Este encabezado debe mantenerse intacto,
excepto si este es un proyecto de un estudiante.
*/#include <stdio.h>
#include <string.h>
// Debe ser de la máxima + 1. Por ejemplo, si la máxima es 4, defínela como 5
#define MAXIMA_LONGITUD_CADENA 1000
// Las palabras que contiene el archivo
#define CANTIDAD_PALABRAS 20
#define NOMBRE_ARCHIVO "lista.txt"

// Implementación del método de la burbuja en C, para arreglos de cadenas
void burbuja(char arreglo[CANTIDAD_PALABRAS][MAXIMA_LONGITUD_CADENA])
{
    int longitud = CANTIDAD_PALABRAS;
    // Útil para hacer intercambio de cadenas
    char temporal[MAXIMA_LONGITUD_CADENA];
    int x, indiceActual;
    for (x = 0; x < longitud; x++)
    {
        for (indiceActual = 0; indiceActual < longitud - 1;
             indiceActual++)
        {
            int indiceSiguienteElemento = indiceActual + 1;
            // Si la cadena es menor que la siguiente (alfabeticamente) entonces intercambiamos
            if (strcmp(arreglo[indiceActual], arreglo[indiceSiguienteElemento]) <= 0)
            {
                // Movemos la cadena actual a la temporal
                memcpy(temporal, arreglo[indiceActual], MAXIMA_LONGITUD_CADENA);
                // Movemos al actual el siguiente elemento
                memcpy(arreglo[indiceActual], arreglo[indiceSiguienteElemento], MAXIMA_LONGITUD_CADENA);
                // Y en el siguiente elemento, lo que había antes en el actual pero ahora está en temporal
                memcpy(arreglo[indiceSiguienteElemento], temporal, MAXIMA_LONGITUD_CADENA);
            }
        }
    }
    // No hay necesidad de devolver nada, pues modificamos al arreglo de manera interna
}

int main()
{
    // Arreglo de cadenas: aquí almacenamos todas las palabras
    char palabras[CANTIDAD_PALABRAS][MAXIMA_LONGITUD_CADENA];
    // Útil para leer el archivo
    char buferArchivo[MAXIMA_LONGITUD_CADENA];
    // Abrir el archivo...
    FILE *archivo = fopen(NOMBRE_ARCHIVO, "r");
    if (archivo == NULL)
    {
        printf("No se puede abrir el archivo");
        return 0;
    }
    // Necesitamos este ayudante para saber en qué línea vamos
    int indice = 0;
    // Mientras podamos leer una línea del archivo
    while (fgets(buferArchivo, MAXIMA_LONGITUD_CADENA, archivo))
    {
        // Remover salto de línea
        strtok(buferArchivo, "\n");
        // Copiar la línea a nuestro arreglo, usando el índice
        memcpy(palabras[indice], buferArchivo, MAXIMA_LONGITUD_CADENA);
        // Aumentarlo en cada iteración
        indice++;
    }

    // Terminamos de leer
    fclose(archivo);
    // Ahora ya tenemos el arreglo. Vamos a ordenarlo.
    // La función no devuelve nada, pues modifica al arreglo de manera interna
    burbuja(palabras);
    // Lo que resta ahora es imprimir, pues ya tenemos el arreglo ordenado
    int i;
    for (i = 0; i < CANTIDAD_PALABRAS; i++)
    {
        printf("%s\n", palabras[i]);
    }
    return 0;
}

Si lo ejecutas, recuerda que la lista de palabras debe estar en el mismo directorio en donde se encuentra el ejecutable.