Mejor respuesta
Clasificación de burbujas
Bubble Sort es el algoritmo de clasificación más simple que funciona intercambiando repetidamente los elementos adyacentes si están en el orden incorrecto.
Ejemplo: Primer pase: ( 5 1 4 2 8) -> ( 1 5 4 2 8), Aquí, el algoritmo compara los dos primeros elementos e intercambia desde 5> 1. (1 5 4 2 8) -> (1 4 5 2 8), intercambio desde 5 > 4 (1 4 5 2 8) -> (1 4 2 5 8), intercambio desde 5> 2 (1 4 2 5 8 ) -> (1 4 2 5 8 ), ahora, dado que estos elementos ya están en orden (8> 5), el algoritmo no los intercambia.
Segunda pasada: ( 1 4 2 5 8) -> ( 1 4 2 5 8) (1 4 2 5 8) -> (1 2 4 5 8), Intercambiar desde 4> 2 (1 2 4 5 8) -> (1 2 4 5 8) (1 2 4 5 8 ) -> (1 2 4 5 8 ) Ahora, la matriz ya está ordenada, segundo Pero nuestro algoritmo no sabe si está completo. El algoritmo necesita un completo pase sin ningún intercambio para saber que está ordenado.
Tercer pase: ( 1 2 4 5 8) -> ( 1 2 4 5 8) (1 2 4 5 8) -> (1 2 4 5 8) (1 2 4 5 8) -> (1 2 4 5 8) (1 2 4 5 8 ) -> (1 2 4 5 8 )
Ejemplo
// C program for implementation of Bubble sort
#include
void *xp, int *yp)
{
int temp = *xp;
*xp = *yp;
*yp = temp;
}
// A function to implement bubble sort
void bubbleSort(int arr[], int n)
{
int i, j;
for (i = 0; i < n-1; i++)
// Last i elements are already in place
for (j = 0; j < n-i-1; j++)
if (arr[j] > arr[j+1])
swap(&arr[j], &arr[j+1]);
}
/* Function to print an array */
void printArray(int arr[], int size)
{
int i;
for (i=0; i < size; i++)
printf("\%d ", arr[i]);
printf("n");
}
// Driver program to test above functions
int main()
{
int arr[] = {66, 4, 25, 1, 22, 81, 90};
int n = sizeof(arr)/sizeof(arr[0]);
bubbleSort(arr, n);
printf("Sorted array: \n");
printArray(arr, n);
return 0;
}
Gracias.
Respuesta
Para mí, el algoritmo de ordenación más sencillo es el ordenamiento por selección, muy básico y comprensible.Cuando ejecute el algoritmo de clasificación de selección, comparará todos los valores con el primer elemento, cuando el valor que encuentre sea menor que el primer elemento, cambiará el elemento con el valor más bajo y continuará así.
Déjame darte un ejemplo.
Array => [15,3,22,1,4,14]
min = 15.
- comparar con 15, min = 15
- comparar con 3, min = 3
- comparar con 22, min = 3
- comparar con 1, min = 1
- comparar con 4, min = 1
- comparar con 14, min = 1
Ahora ha encontrado el elemento min (first\_index). Tienes que reemplazar el primer elemento y los lugares del elemento mínimo, luego continuar hasta llegar al último elemento.
Ejemplo de código C:
#include
void printArray(int arr[], int n) {
//use this function to print array
for (int i = 0; i < n; i++)
printf("\%d, ", arr[i]);
}
void sortArray(int arr[], int n) {
int min\_index = 0;
int temp = 0;
for (int i = 0; i < n; i++) {
min\_index = i;
for (int j = i; j < n; j++) {
//compare min index"s element with new j"s element
//if you want descending sort you can change the binary
//operator > to < .
if (arr[min\_index] > arr[j]) min\_index = j;
}
//change min index"s element and i. element
temp = arr[min\_index];
arr[min\_index] = arr[i];
arr[i] = temp;
}
printArray(arr,n);
}
int arr[] = { 100,5,11,1,22,31,4,2,3 }; //initialize array
printArray(arr,9); //print unsorted array
sortArray(arr,9); //sort array then print it
return 0;
}