Tri à bulles est le plus simple algorithme de tri cela fonctionne en échangeant à plusieurs reprises les éléments adjacents s'ils sont dans le mauvais ordre. Cet algorithme ne convient pas aux grands ensembles de données car sa complexité temporelle moyenne et dans le pire des cas est assez élevée.
Algorithme de tri à bulles
Pratique recommandée Tri à bulles Essayez-le !Dans l'algorithme Bubble Sort,
actrice de cinéma Kajal
- traversez depuis la gauche et comparez les éléments adjacents et celui du haut est placé sur le côté droit.
- De cette façon, le plus grand élément est d’abord déplacé vers l’extrémité droite.
- Ce processus se poursuit ensuite pour trouver le deuxième plus grand et le placer et ainsi de suite jusqu'à ce que les données soient triées.
Comment fonctionne le tri à bulles ?
Comprenons le fonctionnement du tri à bulles à l'aide de l'illustration suivante :
Saisir: arr[] = {6, 0, 3, 5}
Premier passage:
Le plus grand élément est placé à sa position correcte, c'est-à-dire à la fin du tableau.
Algorithme de tri à bulles : placer le plus grand élément à la bonne position
Deuxième passage :
Placez le deuxième plus grand élément à la bonne position
Algorithme de tri à bulles : placer le deuxième plus grand élément à la bonne position
Troisième passage :
Placez les deux éléments restants à leur position correcte.
Algorithme de tri à bulles : placer les éléments restants à leurs positions correctes
cartographie en dactylographié
- Nombre total. de passes : n-1
- Nombre total. de comparaisons : n*(n-1)/2
Implémentation du tri à bulles
Vous trouverez ci-dessous l'implémentation du tri à bulles. Il peut être optimisé en arrêtant l'algorithme si la boucle interne n'a provoqué aucun échange.
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]) { swap(arr[j], arr[j + 1]); échangé = vrai ; } } // Si aucun élément n'a été échangé // par la boucle interne, alors break if (swapped == false) break; } } // Fonction pour imprimer un tableau void printArray(int arr[], int size) { int i; pour (je = 0; je< 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]); échangé = vrai ; } } // Si aucun élément n'a été échangé par la boucle interne, // alors break if (swapped == false) break; } } // Fonction pour imprimer un tableau void printArray(int arr[], int size) { int i; pour (je = 0; je< 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]) { // Échanger arr[j] et arr[j+1] temp = arr[j]; arr[j] = arr[j + 1]; arr[j + 1] = temp; échangé = vrai ; } } // Si aucun élément n'a été // échangé par la boucle interne, alors break if (swapped == false) break; } } // Fonction pour imprimer un tableau static void printArray(int arr[], int size) { int i; pour (je = 0; je< 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] swapped = True if (swapped == False) : break # Code du pilote à tester ci-dessus si __name__ == '__main__' : arr = [64, 34, 25, 12, 22, 11, 90] bubbleSort(arr) print('Tableau trié :') pour i dans la plage(len(arr)) : print('%d' % arr[i], end=' ') # Ce code est modifié par 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]) { // Échanger arr[j] et arr[j+1] temp = arr[j]; arr[j] = arr[j + 1]; arr[j + 1] = temp; échangé = vrai ; } } // Si aucun élément n'a été // échangé par la boucle interne, alors break if (swapped == false) break; } } // Fonction pour imprimer un tableau static void printArray(int[] arr, int size) { int i; pour (je = 0; je< 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]) { // Échanger arr[j] et arr[j+1] temp = arr[j]; arr[j] = arr[j + 1]; arr[j + 1] = temp; échangé = vrai ; } } // SI aucun élément n'a été // échangé par la boucle interne, alors break if (swapped == false) break; } } // Fonction pour imprimer un tableau function printArray(arr, size) { var i; pour (je = 0; je< 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; $ échangé = Vrai ; } } // Si aucun élément n'a été échangé // par la boucle interne, alors break if ($swapped == False) break; } } // Code du pilote $arr = array(64, 34, 25, 12, 22, 11, 90); $len = taillede($arr); bubbleSort($arr); echo 'Tableau trié :
'; pour($i = 0; $i< $len; $i++) echo $arr[$i].' '; // This code is contributed by ChitraNayal. ?>> Sortir
Sorted array: 11 12 22 25 34 64 90>
Analyse de complexité du tri à bulles :
Complexité temporelle : SUR2)
Espace auxiliaire : O(1)
Avantages du tri à bulles :
- Le tri à bulles est facile à comprendre et à mettre en œuvre.
- Il ne nécessite aucun espace mémoire supplémentaire.
- Il s'agit d'un algorithme de tri stable, ce qui signifie que les éléments ayant la même valeur clé conservent leur ordre relatif dans la sortie triée.
Inconvénients du tri à bulles :
- Le tri à bulles a une complexité temporelle de O(N2), ce qui le rend très lent pour les grands ensembles de données.
- Le tri à bulles est un algorithme de tri basé sur la comparaison, ce qui signifie qu'il nécessite un opérateur de comparaison pour déterminer l'ordre relatif des éléments dans l'ensemble de données d'entrée. Cela peut limiter l’efficacité de l’algorithme dans certains cas.
Quelques FAQ liées au tri à bulles :
Qu'est-ce que le cas limite pour le tri à bulles ?
Le tri à bulles prend un minimum de temps (ordre de n) lorsque les éléments sont déjà triés. Il est donc préférable de vérifier au préalable si le tableau est déjà trié ou non, pour éviter O(N2) complexité temporelle.
Le tri s'effectue-t-il en place dans le tri à bulles ?
Oui, le tri à bulles effectue l'échange de paires adjacentes sans utiliser de structure de données majeure. L’algorithme de tri à bulles est donc un algorithme sur place.
L’algorithme de tri à bulles est-il stable ?
Oui, l'algorithme de tri à bulles est stable.
Où l’algorithme de tri à bulles est-il utilisé ?
En raison de sa simplicité, le tri à bulles est souvent utilisé pour introduire le concept d’algorithme de tri. En infographie, il est populaire pour sa capacité à détecter une petite erreur (comme un échange de seulement deux éléments) dans des tableaux presque triés et à la corriger avec une complexité linéaire (2n).
Exemple : il est utilisé dans un algorithme de remplissage de polygones, où les lignes de délimitation sont triées par leur coordonnée x sur une ligne de balayage spécifique (une ligne parallèle à l'axe x), et avec l'incrémentation de y, leur ordre change (deux éléments sont échangés) uniquement. aux intersections de deux lignes.
Articles Liés:
- Tri à bulles récursif
- Pratique de codage pour le tri
- Quiz sur le tri à bulles
- Analyse de complexité du tri à bulles