Classificació de bombolles és el més senzill algorisme d'ordenació que funciona intercanviant repetidament els elements adjacents si estan en l'ordre incorrecte. Aquest algorisme no és adequat per a grans conjunts de dades, ja que la seva complexitat temporal mitjana i en el pitjor dels casos és força alta.
Algorisme d'ordenació de bombolles
Pràctica recomanada Bubble Sort Prova-ho!A l'algorisme d'ordenació de bombolles,
- travessa des de l'esquerra i compara els elements adjacents i el més alt es col·loca al costat dret.
- D'aquesta manera, l'element més gran es mou al principi a l'extrem més dret.
- A continuació, es continua amb aquest procés per trobar el segon més gran i col·locar-lo i així successivament fins que s'ordenen les dades.
Com funciona la classificació de bombolles?
Entenem el funcionament de la classificació de bombolles amb l'ajuda de la il·lustració següent:
Entrada: arr[] = {6, 0, 3, 5}
Primera passada:
L'element més gran es col·loca en la seva posició correcta, és a dir, l'extrem de la matriu.
Algoritme d'ordenació de bombolles: col·loca l'element més gran a la posició correcta
Segona passada:
Col·loqueu el segon element més gran a la posició correcta
Algoritme d'ordenació de bombolles: col·loca el segon element més gran a la posició correcta
Tercera passada:
constructor en javaCol·loqueu els dos elements restants a les seves posicions correctes.
Algoritme d'ordenació de bombolles: col·loca els elements restants a les seves posicions correctes
- Núm total. de passades: n-1
- Núm total. de comparacions: n*(n-1)/2
Implementació de Bubble Sort
A continuació es mostra la implementació de l'ordenació de bombolles. Es pot optimitzar aturant l'algorisme si el bucle interior no ha provocat cap intercanvi.
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]) { intercanvi (arr[j], arr[j + 1]); intercanviat = cert; } } // Si no s'han intercanviat dos elements // pel bucle intern, aleshores trenca si (intercanviat == fals) trenca; } } // Funció per imprimir una matriu void printArray(int arr[], int size) { int i; per (i = 0; i< 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]) { swap(&arr[j], &arr[j + 1]); intercanviat = cert; } } // Si no s'han intercanviat dos elements pel bucle intern, // llavors trenca si (intercanviat == fals) trenca; } } // Funció per imprimir una matriu void printArray(int arr[], int size) { int i; per (i = 0; i< 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]) { // Canvia arr[j] i arr[j+1] temp = arr[j]; arr[j] = arr[j + 1]; arr[j + 1] = temp; intercanviat = cert; } } // Si no s'han canviat // dos elements pel bucle intern, aleshores trenca si (intercanviat == fals) trenca; } } // Funció per imprimir una matriu static void printArray(int arr[], int size) { int i; per (i = 0; i< 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.> Python 3 # 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] swapped = True if (swapped == False): trenca # Codi del controlador per provar més amunt si __name__ == '__main__': arr = [64, 34, 25, 12, 22, 11, 90] bubbleSort(arr) print('Matriu ordenada:') per a i en rang(len(arr)): print('%d' % arr[i], final=' ') # Aquest codi ha estat modificat per 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]) { // Canvia arr[j] i arr[j+1] temp = arr[j]; arr[j] = arr[j + 1]; arr[j + 1] = temp; intercanviat = cert; } } // Si no s'han canviat // dos elements pel bucle intern, aleshores trenca si (intercanviat == fals) trenca; } } // Funció per imprimir una matriu static void printArray(int[] arr, int size) { int i; per (i = 0; i< 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]) { // Canvia arr[j] i arr[j+1] temp = arr[j]; arr[j] = arr[j + 1]; arr[j + 1] = temp; intercanviat = cert; } } // SI no s'han canviat dos elements per // el bucle intern, aleshores trenca si (intercanviat == fals) trenca; } } // Funció per imprimir una funció matriu printArray(arr, size) { var i; per (i = 0; i< 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; $swapped = True; } } // Si no s'han intercanviat dos elements // pel bucle intern, aleshores trenca si ($swapped == Fals) trenca; } } // Codi del controlador $arr = array(64, 34, 25, 12, 22, 11, 90); $len = sizeof($arr); bubbleSort($arr); echo 'Matriu ordenat:
'; for($i = 0; $i< $len; $i++) echo $arr[$i].' '; // This code is contributed by ChitraNayal. ?>> Sortida
Sorted array: 11 12 22 25 34 64 90>
Anàlisi de complexitat de l'ordenació de bombolles :
Complexitat temporal: O(N2)
Espai auxiliar: O(1)
Avantatges de Bubble Sort:
- L'ordenació de bombolles és fàcil d'entendre i implementar.
- No requereix cap espai de memòria addicional.
- És un algorisme d'ordenació estable, el que significa que els elements amb el mateix valor de clau mantenen el seu ordre relatiu a la sortida ordenada.
Desavantatges de l'ordenació de bombolles:
- L'ordenació de bombolles té una complexitat temporal de O(N2), cosa que fa que sigui molt lent per a grans conjunts de dades.
- L'ordenació de bombolles és un algorisme d'ordenació basat en comparacions, la qual cosa significa que requereix un operador de comparació per determinar l'ordre relatiu dels elements en el conjunt de dades d'entrada. Pot limitar l'eficiència de l'algorisme en determinats casos.
Algunes preguntes freqüents relacionades amb l'ordenació de bombolles:
Què és el cas límit per a l'ordenació de bombolles?
L'ordenació de bombolles triga un temps mínim (Ordre de n) quan els elements ja estan ordenats. Per tant, el millor és comprovar si la matriu ja està ordenada o no abans, per evitar O(N2) complexitat temporal.
L'ordenació es fa a l'ordenació de bombolles?
Sí, Bubble sort realitza l'intercanvi de parells adjacents sense utilitzar cap estructura de dades important. Per tant, l'algorisme d'ordenació de bombolles és un algorisme in situ.
És estable l'algorisme d'ordenació de bombolles?
Sí, l'algorisme d'ordenació de bombolles és estable.
On s'utilitza l'algorisme d'ordenació de bombolles?
A causa de la seva senzillesa, l'ordenació de bombolles s'utilitza sovint per introduir el concepte d'algorisme d'ordenació. En gràfics per ordinador, és popular per la seva capacitat per detectar un petit error (com un intercanvi de només dos elements) en matrius gairebé ordenades i arreglar-lo només amb una complexitat lineal (2n).
Exemple: s'utilitza en un algorisme d'ompliment de polígons, on les línies de delimitació s'ordenen per la seva coordenada x en una línia d'escaneig específica (una línia paral·lela a l'eix x) i, amb l'increment de y, el seu ordre canvia (s'intercanvien dos elements) només en les interseccions de dues línies.
Articles relacionats:
- Classificació de bombolles recursives
- Pràctica de codificació per classificar
- Test sobre l'ordenació de bombolles
- Anàlisi de complexitat de l'ordenació de bombolles