Ordenamiento de burbuja es el mas simple algoritmo de clasificación eso funciona intercambiando repetidamente los elementos adyacentes si están en el orden incorrecto. Este algoritmo no es adecuado para grandes conjuntos de datos ya que su complejidad temporal promedio y en el peor de los casos es bastante alta.
Algoritmo de clasificación de burbujas
Práctica recomendada Clasificación de burbujas ¡Pruébalo!En el algoritmo de clasificación de burbujas,
- recorra desde la izquierda y compare los elementos adyacentes y el superior se coloca en el lado derecho.
- De esta manera, el elemento más grande se mueve primero hacia el extremo derecho.
- Luego se continúa con este proceso para encontrar el segundo más grande y colocarlo y así sucesivamente hasta que se ordenen los datos.
¿Cómo funciona la clasificación por burbujas?
Entendamos el funcionamiento de la clasificación de burbujas con la ayuda de la siguiente ilustración:
Aporte: arreglo[] = {6, 0, 3, 5}
propiedades ácidas en dbmsPrimer pase:
El elemento más grande se coloca en su posición correcta, es decir, al final de la matriz.
Algoritmo de clasificación de burbujas: colocar el elemento más grande en la posición correcta
Segundo pase:
Coloque el segundo elemento más grande en la posición correcta.
Algoritmo de clasificación de burbujas: colocar el segundo elemento más grande en la posición correcta
Tercer pase:
Coloque los dos elementos restantes en sus posiciones correctas.
Algoritmo de clasificación de burbujas: colocar los elementos restantes en sus posiciones correctas
- Número total de pases: n-1
- Número total de comparaciones: n*(n-1)/2
Implementación de clasificación de burbujas
A continuación se muestra la implementación del tipo de burbuja. Se puede optimizar deteniendo el algoritmo si el bucle interno no provocó ningún intercambio.
C++ // Optimized implementation of Bubble sort #include using namespace std; // An optimized version of Bubble Sort void bubbleSort(int arr[], int n) { int i, j; bool swapped; for (i = 0; i < n - 1; i++) { swapped = false; for (j = 0; j < n - i - 1; j++) { if (arr[j]>arr[j + 1]) { intercambiar(arr[j], arr[j + 1]); intercambiado = verdadero; } } // Si no se intercambiaron dos elementos // mediante el bucle interno, entonces rompa if (swapped == false) break; } } // Función para imprimir una matriz void printArray(int arr[], int size) { int i; para (yo = 0; yo< size; i++) cout << ' ' << arr[i]; } // Driver program to test above functions int main() { int arr[] = { 64, 34, 25, 12, 22, 11, 90 }; int N = sizeof(arr) / sizeof(arr[0]); bubbleSort(arr, N); cout << 'Sorted array:
'; printArray(arr, N); return 0; } // This code is contributed by shivanisinghss2110> C // Optimized implementation of Bubble sort #include #include void swap(int* xp, int* yp) { int temp = *xp; *xp = *yp; *yp = temp; } // An optimized version of Bubble Sort void bubbleSort(int arr[], int n) { int i, j; bool swapped; for (i = 0; i < n - 1; i++) { swapped = false; for (j = 0; j < n - i - 1; j++) { if (arr[j]>arr[j + 1]) { intercambiar(&arr[j], &arr[j + 1]); intercambiado = verdadero; } } // Si no se intercambiaron dos elementos mediante el bucle interno, // entonces break if (swapped == false) break; } } // Función para imprimir una matriz void printArray(int arr[], int size) { int i; para (yo = 0; yo< size; i++) printf('%d ', arr[i]); } // Driver program to test above functions int main() { int arr[] = { 64, 34, 25, 12, 22, 11, 90 }; int n = sizeof(arr) / sizeof(arr[0]); bubbleSort(arr, n); printf('Sorted array:
'); printArray(arr, n); return 0; }> Java // Optimized java implementation of Bubble sort import java.io.*; class GFG { // An optimized version of Bubble Sort static void bubbleSort(int arr[], int n) { int i, j, temp; boolean swapped; for (i = 0; i < n - 1; i++) { swapped = false; for (j = 0; j < n - i - 1; j++) { if (arr[j]>arr[j + 1]) { // Intercambiar arr[j] y arr[j+1] temp = arr[j]; arreglo[j] = arreglo[j + 1]; llegada[j + 1] = temperatura; intercambiado = verdadero; } } // Si no se intercambiaron dos elementos // mediante el bucle interno, entonces break if (swapped == false) break; } } // Función para imprimir una matriz estática void printArray(int arr[], int size) { int i; para (yo = 0; yo< size; i++) System.out.print(arr[i] + ' '); System.out.println(); } // Driver program public static void main(String args[]) { int arr[] = { 64, 34, 25, 12, 22, 11, 90 }; int n = arr.length; bubbleSort(arr, n); System.out.println('Sorted array: '); printArray(arr, n); } } // This code is contributed // by Nikita Tiwari.> Python3 # Optimized Python program for implementation of Bubble Sort def bubbleSort(arr): n = len(arr) # Traverse through all array elements for i in range(n): swapped = False # Last i elements are already in place for j in range(0, n-i-1): # Traverse the array from 0 to n-i-1 # Swap if the element found is greater # than the next element if arr[j]>arr[j+1]: arr[j], arr[j+1] = arr[j+1], arr[j] intercambiado = Verdadero si (intercambiado == Falso): romper # Código del controlador para probar arriba si __nombre__ == '__main__': arr = [64, 34, 25, 12, 22, 11, 90] bubbleSort(arr) print('Matriz ordenada:') para i en el rango(len(arr)): print('%d' % arr[i], end=' ') # Este código es modificado por Suraj krushna Yadav> C# // Optimized C# implementation of Bubble sort using System; class GFG { // An optimized version of Bubble Sort static void bubbleSort(int[] arr, int n) { int i, j, temp; bool swapped; for (i = 0; i < n - 1; i++) { swapped = false; for (j = 0; j < n - i - 1; j++) { if (arr[j]>arr[j + 1]) { // Intercambiar arr[j] y arr[j+1] temp = arr[j]; arreglo[j] = arreglo[j + 1]; llegada[j + 1] = temperatura; intercambiado = verdadero; } } // Si no se intercambiaron dos elementos // mediante el bucle interno, entonces break if (swapped == false) break; } } // Función para imprimir una matriz estática void printArray(int[] arr, int size) { int i; para (yo = 0; yo< size; i++) Console.Write(arr[i] + ' '); Console.WriteLine(); } // Driver method public static void Main() { int[] arr = { 64, 34, 25, 12, 22, 11, 90 }; int n = arr.Length; bubbleSort(arr, n); Console.WriteLine('Sorted array:'); printArray(arr, n); } } // This code is contributed by Sam007> JavaScript // Optimized javaScript implementation // of Bubble sort // An optimized version of Bubble Sort function bubbleSort(arr, n) { var i, j, temp; var swapped; for (i = 0; i < n - 1; i++) { swapped = false; for (j = 0; j < n - i - 1; j++) { if (arr[j]>arr[j + 1]) { // Intercambiar arr[j] y arr[j+1] temp = arr[j]; arreglo[j] = arreglo[j + 1]; llegada[j + 1] = temperatura; intercambiado = verdadero; } } // SI no se intercambiaron dos elementos // mediante el bucle interno, entonces se rompe if (swapped == false) break; } } // Función para imprimir una matriz function printArray(arr, size) { var i; para (yo = 0; yo< size; i++) console.log(arr[i] + ' '); } // Driver program var arr = [ 64, 34, 25, 12, 22, 11, 90 ]; var n = arr.length; bubbleSort(arr, n); console.log('Sorted array: '); printArray(arr, n); // This code is contributed shivanisinghss2110> PHP // PHP Optimized implementation // of Bubble sort // An optimized version of Bubble Sort function bubbleSort(&$arr) { $n = sizeof($arr); // Traverse through all array elements for($i = 0; $i < $n; $i++) { $swapped = False; // Last i elements are already // in place for ($j = 0; $j < $n - $i - 1; $j++) { // Traverse the array from 0 to // n-i-1. Swap if the element // found is greater than the // next element if ($arr[$j]>$arr[$j+1]) { $t = $arr[$j]; $arr[$j] = $arr[$j+1]; $arr[$j+1] = $t; $intercambiado = Verdadero; } } // Si no se intercambiaron dos elementos // mediante el bucle interno, entonces rompa if ($swapped == False) break; } } // Código del controlador $arr = array(64, 34, 25, 12, 22, 11, 90); $len = tamaño de($arr); burbujaOrdenar($arr); echo 'Matriz ordenada:
'; para($i = 0; $i< $len; $i++) echo $arr[$i].' '; // This code is contributed by ChitraNayal. ?>> Producción
Sorted array: 11 12 22 25 34 64 90>
Análisis de complejidad de la clasificación de burbujas :
Complejidad del tiempo: EN2)
Espacio Auxiliar: O(1)
Ventajas de la clasificación por burbujas:
- La clasificación de burbujas es fácil de entender e implementar.
- No requiere ningún espacio de memoria adicional.
- Es un algoritmo de clasificación estable, lo que significa que los elementos con el mismo valor clave mantienen su orden relativo en la salida ordenada.
Desventajas de la clasificación por burbujas:
- La clasificación de burbujas tiene una complejidad temporal de O (N2) lo que lo hace muy lento para grandes conjuntos de datos.
- La clasificación de burbujas es un algoritmo de clasificación basado en comparación, lo que significa que requiere un operador de comparación para determinar el orden relativo de los elementos en el conjunto de datos de entrada. Puede limitar la eficiencia del algoritmo en determinados casos.
Algunas preguntas frecuentes relacionadas con la clasificación por burbujas:
¿Cuál es el caso límite para el tipo burbuja?
La clasificación de burbujas requiere un tiempo mínimo (orden de n) cuando los elementos ya están ordenados. Por lo tanto, es mejor comprobar si la matriz ya está ordenada o no de antemano, para evitar O(N2) complejidad del tiempo.
¿La clasificación se realiza en el modo Bubble sort?
Sí, Bubble sort realiza el intercambio de pares adyacentes sin el uso de ninguna estructura de datos importante. Por tanto, el algoritmo de clasificación de burbujas es un algoritmo in situ.
¿Es estable el algoritmo de clasificación de burbujas?
Sí, el algoritmo de clasificación de burbujas es estable.
¿Dónde se utiliza el algoritmo de clasificación de burbujas?
Debido a su simplicidad, la clasificación por burbujas se utiliza a menudo para introducir el concepto de algoritmo de clasificación. En gráficos por computadora, es popular por su capacidad para detectar un pequeño error (como un intercambio de solo dos elementos) en matrices casi ordenadas y solucionarlo con solo complejidad lineal (2n).
Ejemplo: se utiliza en un algoritmo de relleno de polígonos, donde las líneas delimitadoras se ordenan por su coordenada x en una línea de escaneo específica (una línea paralela al eje x), y al incrementar y su orden cambia (se intercambian dos elementos) únicamente. en las intersecciones de dos líneas.
Artículos relacionados:
- Ordenación de burbujas recursiva
- Práctica de codificación para ordenar
- Prueba sobre clasificación de burbujas
- Análisis de complejidad de la clasificación de burbujas