Algunos conocen métodos de ordenamiento en programación, les voy a explicar el primero, y uno de los mas usados, el conocido como “Método Burbuja”, a muchos se los enseñaron en la carrera de Ingeniería en Sistemas (incluso en otras Ingenierías en las que se lleva programación), este método es de los primeros que se ve, y es el mas sencillo de implementar, para el ordenamiento de datos.

Su eficiencia es proporcional a la implementación en la que se haga, por lo general no es el método mas eficiente para el ordenamiento de datos, pero en ciertos casos, se puede aplicar si ningún problema de eficiencia.

Vamos a pasar a su implementación, tenemos una lista de elementos que van de a—>b  valores, el principio basico del “Bubble Sort”. Se tiene un arreglo del cual se va a ir comparando el valor del elemento actual con el elemento seleccionado, y se va a tomar el que tenga el valor mayor, este elemento del arreglo se toma y se coloca al final, después se toma el siguiente elemento del arreglo y se pone en penúltimo lugar, y así una y otra vez hasta finalizar el ciclo.

La idea de este algoritmo es ir seleccionando el mayor valor del arreglo y colocarlo al final, después seleccionar el segundo mayor y colocarlo en penúltimo lugar y así sucesivamente.

Vamos a poner un ejemplo, con una lista de tamaño Z. Los tenemos que ordenar, colocando el entero de valor mas alto al final del arreglo, y el mas bajo al principio, lo que se podría hacer, es recorrer el arreglo con un indice j, hasta Z-2.

Por cada uno de los bucles, verificamos que el entero en la posición  j+1 tiene un valor menor que el de la posición j, si esta comparativa, resulta verdadera, entonces se hace un intercambio de los valores de las posiciones j+1 y j. Con este proceso se ha colado el entero de mayor valor a la posición N – 1.

Un ejemplo sencillo de 6 números es el arreglo {5,7,11,3,2,4} si aplicamos el método de arriba mencionado entonces tenemos:

valor de la j Comparación Operación Estado del arreglo
j = 0 A[0] < A[1] {5,7,11,3,2,4}
j = 1 A[1] < A[2] {5,7,11,3,2,4}
j = 2 A[2] > A[3] Intercambiamos {5,7,3,11,2,4}
j = 3 A[3] > A[4] Intercambiamos {5,7,3,2,11,4}
j = 4 A[4] > A[5] Intercambiamos {5,7,3,2,4,11}

El 11 se coloca al final, si se repitiera el ciclo, el siguiente elemento seria el 7 y se colocaría en el penúltimo lugar. Este ciclo se podría pretiriere Z veces, hasta completar el ciclo.

El Codigo en C++ quedaria de la siguiente manera.

void Intercambia(int *A,int Pos1,int Pos2)
{
int Temp = A[Pos2];
A[Pos2] = A[Pos1];
A[Pos1] = Temp;
}

///********************************

void Burbuja(int *A,int N)
{
int i,j,Temp;

// Repetimos el procesos N - 1 veces para un arreglo de tamaño N.
for(i = 0; i < (N-1); i++)
  {
  // En cada iteración llegamos hasta N - 1 - i pues hemos ordenado
  // a i enteros en los i iteraciones pasadas.
  for(j = 0; j < (N - 1 - i); j++)
    {
    // Comparamos e intercambiamos de ser el caso.
    if( A[j + 1] < A[j] )
      { Intercambia(A,j,j+1); }
    }
  }
}

Obviamente, el ejemplo es para fines de aprendizaje, por que a la hora de implementaciones es mucho mejor usar QuickSort

Fuente:
OIEG

  • JaCkEr60

    No ma, esta muy interesante, se ahorra uno unos cuantos pasos con cosas sencillas, aunque yo no termino de agarrarle la onda chido, a ver si con tu explicacion le entiendo más XD