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.

Ordenar un arreglo en C utilizando el ordenamiento de burbuja

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:

*/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:
  
  */  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.

Estoy aquí para ayudarte 🤝💻


Estoy aquí para ayudarte en todo lo que necesites. Si requieres alguna modificación en lo presentado en este post, deseas asistencia con tu tarea, proyecto o precisas desarrollar un software a medida, no dudes en contactarme. Estoy comprometido a brindarte el apoyo necesario para que logres tus objetivos. Mi correo es parzibyte(arroba)gmail.com, estoy como@parzibyte en Telegram o en mi página de contacto

No te pierdas ninguno de mis posts 🚀🔔

Suscríbete a mi canal de Telegram para recibir una notificación cuando escriba un nuevo tutorial de programación.
parzibyte

Programador freelancer listo para trabajar contigo. Aplicaciones web, móviles y de escritorio. PHP, Java, Go, Python, JavaScript, Kotlin y más :) https://parzibyte.me/blog/software-creado-por-parzibyte/

Entradas recientes

Servidor HTTP en Android con Flutter

El día de hoy te mostraré cómo crear un servidor HTTP (servidor web) en Android…

4 días hace

Imprimir automáticamente todos los PDF de una carpeta

En este post te voy a enseñar a designar una carpeta para imprimir todos los…

5 días hace

Guía para imprimir en plugin versión 1 desde Android

En este artículo te voy a enseñar la guía para imprimir en una impresora térmica…

1 semana hace

Añadir tasa de cambio en sistema de información

Hoy te voy a mostrar un ejemplo de programación para agregar un módulo de tasa…

2 semanas hace

Comprobar validez de licencia de plugin ESC POS

Los usuarios del plugin para impresoras térmicas pueden contratar licencias, y en ocasiones me han…

2 semanas hace

Imprimir euro € en impresora térmica

Hoy voy a enseñarte cómo imprimir el € en una impresora térmica. Vamos a ver…

4 semanas hace

Esta web usa cookies.