En este post de programación en C te mostraré cómo ordenar un arreglo de cadenas de manera alfabética en orden ascendente. Es decir, ordenar un array de strings en C de la A a la Z.

Ordenar un arreglo de cadenas en C es distinto a hacerlo con uno de tipo numérico, pues para comparar cadenas usamos strcmp. Además, el tipo string no existe como tal, así que debemos usar arreglos de arreglos.

Lecturas recomendadas

Antes de continuar te recomiendo que leas la introducción a los arreglos de cadenas en C, así como al método de la burbuja con enteros.

De hecho podemos usar cualquier método que ordene arreglos, pero usaré el método de la burbuja para ordenar las cadenas porque es el método más sencillo de entender.

Ordenar arreglo de cadenas en C

La función recibe un arreglo de cadenas para ser ordenado y la longitud del arreglo, de ese modo podemos hacer un ciclo for que lo recorre. En cada paso, usamos strcmp para comparar las cadenas y realizar el ordenamiento.

En caso de que exista la necesidad de hacer el intercambio de valores usamos memcpy para intercambiar elementos de arreglos de cadenas en C.

Por lo tanto el método que ordena se ve así:

// Implementación del método de la burbuja en C, para arreglos de cadenas
void burbuja(char arreglo[][MAXIMA_LONGITUD_CADENA], int longitud)
{
    // Ú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 mayor 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
}

Los comentarios ayudan a explicar el código. Básicamente ordena el arreglo y lo modifica internamente.

Poniendo todo junto

Anteriormente vimos el método en cuestión, ahora veamos cómo usarlo. Para ello primero declaramos un arreglo, calculamos su longitud y lo imprimimos para ilustrar:

char palabras[][MAXIMA_LONGITUD_CADENA] = {
  "Maria",
  "Luis",
  "Bojack",
  "Leon",
  "Maggie",
  "Link",
  "Mario",
  "Claire",
  "Zanahoria",
  "Baroness Von Bon Bon",
};
int longitud = sizeof(palabras)/sizeof(palabras[0]);
// Imprimimos el arreglo antes de ordenarlo, solo para ilustrar
printf("---Imprimiendo arreglo sin ordenar---\n");
int i;
for (i = 0; i < longitud; i++)
{
    printf("%s\n", palabras[i]);
}

Después, ordenamos el arreglo de cadenas en C invocando a burbuja y finalmente imprimimos el arreglo ya ordenado alfabéticamente:

// Lo ordenamos
burbuja(palabras, longitud);
// Volvemos a imprimir
printf("---Imprimiendo arreglo ordenado---\n");
for (i = 0; i < longitud; i++)
{
    printf("%s\n", palabras[i]);
}

El código completo queda así:

#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

// Implementación del método de la burbuja en C, para arreglos de cadenas
void burbuja(char arreglo[][MAXIMA_LONGITUD_CADENA], int longitud)
{
    // Ú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 mayor 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
}

/*
	https://parzibyte.me/blog
*/

int main()
{
    char palabras[][MAXIMA_LONGITUD_CADENA] = {
        "Maria",
        "Luis",
        "Bojack",
        "Leon",
        "Maggie",
        "Link",
        "Mario",
        "Claire",
        "Zanahoria",
        "Baroness Von Bon Bon",
    };
    int longitud = sizeof(palabras) / sizeof(palabras[0]);
    // Imprimimos el arreglo antes de ordenarlo, solo para ilustrar
    printf("---Imprimiendo arreglo sin ordenar---\n");
    int i;
    for (i = 0; i < longitud; i++)
    {
        printf("%s\n", palabras[i]);
    }
    // Lo ordenamos
    burbuja(palabras, longitud);
    // Volvemos a imprimir
    printf("---Imprimiendo arreglo ordenado---\n");
    for (i = 0; i < longitud; i++)
    {
        printf("%s\n", palabras[i]);
    }
    return 0;
}