El algoritmo de ordenamiento de burbuja o método de la burbuja en C es un algoritmo para ordenar arreglos; no es el más rápido, pero es uno que sirve para introducir los conceptos de ordenamiento de arreglos en C.

Ordenar un arreglo en C usando el método de la burbuja es sencillo; simplemente se recorre el arreglo en un ciclo for, y dentro de ese ciclo, se hace otro ciclo; es decir, tenemos dos ciclos.

En el segundo ciclo (que va desde 0 hasta la longitud del arreglo menos el paso del primer ciclo) comparamos el elemento actual con el siguiente, y si el actual es mayor, intercambiamos los valores.

Esto se repite y al final el arreglo estará ordenado.

Recuerda; si quieres ver un algoritmo más complejo pero a la vez más rápido, mira el algoritmo quicksort.

Método de la burbuja en C

Nota: si quieres saltar al código, mira el siguiente apartado.

El algoritmo es sencillo; hay que recorrer todo el arreglo y si encontramos que el elemento actual (arreglo[x]) es menor al elemento siguiente (arreglo[x+1]) entonces los intercambiamos.

Es importante hacer este recorrido hasta la longitud menos 1 para que cuando lleguemos al penúltimo elemento y hagamos un x+1 el índice no esté fuera de los límites del arreglo.

Con esto habremos ordenado solo una parte del arreglo; hay que hacer todo este recorrido de nuevo, específicamente N veces en donde N es la longitud del arreglo; al terminar, el arreglo estará ordenado.

Código del ordenamiento de burbuja en C

Ahora veamos el código. Por cierto, para intercambiar los elementos vamos a usar una función que ya expuse hace tiempo, no es estrictamente necesaria pero ayuda a ahorrar líneas de código; la misma simplemente intercambia dos variables:

/*
Simple función que intercambia dos variables por referencia.
Más información en:
Funciones por referencia y por valor en C

*/
void intercambiar(int *a, int *b) {
  int temporal = *a;
  *a = *b;
  *b = temporal;
}

Ahora que ya la tenemos, veamos el código fuente de la función que ordena un arreglo en C, utilizando el método de la burbuja:

void burbuja(int arreglo[], int longitud) {
  for (int x = 0; x < longitud; x++) {
    // Recuerda que el -1 es porque no queremos llegar al final ya que hacemos
    // un indiceActual + 1 y si fuéramos hasta el final, intentaríamos acceder a un valor fuera de los límites
    // del arreglo
    for (int indiceActual = 0; indiceActual < longitud - 1;
         indiceActual++) {
      int indiceSiguienteElemento = indiceActual + 1;
      // Si el actual es mayor que el que le sigue a la derecha...
      if (arreglo[indiceActual] > arreglo[indiceSiguienteElemento]) {
        // ...intercambiarlos, es decir, mover el actual a la derecha y el de la derecha al actual
        intercambiar(&arreglo[indiceActual], &arreglo[indiceSiguienteElemento]);
      }
    }
  }
}

Como ves, el método recibe el arreglo y la longitud del mismo para funcionar. Eso es lo único que se necesita, a partir de aquí podemos invocar al método y el arreglo estará ordenado después de la invocación.

Ejemplo de uso del algoritmo burbuja en C

Vamos a ver cómo usar la función burbuja que acabamos de crear; lo haré todo en el método main de mi programa. Queda así:

int main(void) {
  // El arreglo
  int arreglo[] = {30, 28, 11, 96, -5, 21, 18, 12, 22, 30, 97, -1, -40, -500};
  /*
  Calcular la longitud, puede ser definida por ti o calculada:
  
Longitud de un arreglo en C

  */
  int longitud = sizeof arreglo / sizeof arreglo[0];
  /*
  Imprimirlo antes de ordenarlo
  */
  printf("Imprimiendo arreglo antes de ordenar...\n");
  for (int x = 0; x < longitud; x++) {
    printf("%d ", arreglo[x]);
  }
  // Un salto de línea
  printf("\n");

  /*
  Invocar al método de la burbuja indicando todo el arreglo, desde 0 hasta el
  índice final
  */
  burbuja(arreglo, longitud);
  /*
  Imprimirlo después de ordenarlo
  */
  printf("Imprimiendo arreglo despues de ordenar...\n");
  for (int x = 0; x < longitud; x++)
    printf("%d ", arreglo[x]);
  return 0;
}

Primero definimos e imprimimos el arreglo sin ser ordenado. Estamos obteniendo la longitud del arreglo con un método que ya vimos anteriormente.

Después simplemente invocamos a burbuja, y como hará todo por referencia, no tenemos que esperar el valor de retorno.

Finalmente imprimimos el arreglo, que ya estará ordenado, como se ve en la imagen que dejé al inicio del post:

Una optimización

Si en el segundo ciclo solo vamos hasta longitud - x - 1 hacemos que se recorran menos elementos, se puede aplicar la “optimización” sin problema, así que el algoritmo puede quedar así:

void burbuja(int arreglo[], int longitud) {
  for (int x = 0; x < longitud; x++) {
    // El for solo va hasta la mitad, por eso longitud - x - 1
    // Recuerda que el -1 es porque no queremos llegar al final ya que hacemos
    // un indiceActual + 1 y si fuéramos hasta el final, intentaríamos acceder a un valor fuera de los límites
    // del arreglo
    for (int indiceActual = 0; indiceActual < longitud - x - 1;
         indiceActual++) {
      int indiceSiguienteElemento = indiceActual + 1;
      // Si el actual es mayor que el que le sigue a la derecha...
      if (arreglo[indiceActual] > arreglo[indiceSiguienteElemento]) {
        // ...intercambiarlos, es decir, mover el actual a la derecha y el de la derecha al actual
        intercambiar(&arreglo[indiceActual], &arreglo[indiceSiguienteElemento]);
      }
    }
  }
}

El resultado sigue siendo el mismo, solo que ahora hemos realizado menos iteraciones. Lo único que tiene este método es que es menos entendible, por eso se recomienda comenzar con el que se vio anteriormente.

Lee más sobre Algoritmos o el lenguaje C en mi blog.