Tri à bulles est un algorithme de tri simple et intuitif. Il échange à plusieurs reprises les éléments adjacents s'ils sont dans le mauvais ordre jusqu'à ce que le tableau soit trié. Dans cet algorithme, le plus grand élément « bouillonne » jusqu'à la fin du tableau à chaque itération. Le tri à bulles est inefficace pour les grands ensembles de données, mais il est utile à des fins pédagogiques et pour les petits ensembles de données. Dans cet article, nous allons implémenter l'algorithme de tri à bulles en langage de programmation C.

La première étape consiste à définir la fonction de tri à bulles. Cette fonction prend un tableau d’entiers et la taille du tableau comme paramètres. La fonction ne renvoie rien car elle modifie le tableau d'origine. Voici la définition de la fonction :

gratuit contre gratuit

 void bubble_sort(int arr[], int n) { int i, j; for (i = 0; i <n - 1; i++) { for (j="0;" j <n i j++) if (arr[j]> arr[j + 1]) { int temp = arr[j]; arr[j] = arr[j + 1]; arr[j + 1] = temp; } } } } </n>

La fonction a deux boucles. La boucle externe s'étend du premier élément à l'avant-dernier élément du tableau. La boucle interne s'étend du premier élément à l'avant-dernier élément de la partie non triée du tableau. La condition de la boucle interne est n - i - 1 car les i derniers éléments du tableau sont déjà triés.

À chaque itération de la boucle interne, nous comparons les éléments adjacents. Si l'élément de gauche est supérieur à l'élément de droite, nous les échangeons. Une fois la boucle interne terminée, il est garanti que l'élément le plus grand se trouve à la fin de la partie non triée du tableau.

Maintenant, nous pouvons écrire la fonction main pour tester notre implémentation de tri à bulles. Voici la fonction principale ainsi que la partie précédente :

Programme C :

 #include void bubble_sort(int arr[], int n) { int i, j; for (i = 0; i <n - 1; i++) { for (j="0;" j <n i j++) if (arr[j]> arr[j + 1]) { int temp = arr[j]; arr[j] = arr[j + 1]; arr[j + 1] = temp; } } } } int main() { int arr[] = {64, 34, 25, 12, 22, 11, 90}; int n = sizeof(arr) / sizeof(arr[0]); bubble_sort(arr, n); printf(&apos;Sorted array: &apos;); for (int i = 0; i <n; i++) { printf('%d ', arr[i]); } return 0; < pre> <p>The main function creates an integer array arr of size 7 and initializes it with random numbers. We then calculate the size of the array by dividing the size of the array by the size of an integer element. Next, we call the bubble_sort function to sort the array. Finally, we print the sorted array using a for loop.</p> <p> <strong>When we run the program, we should see the following output:</strong> </p> <pre> Sorted array: 11 12 22 25 34 64 90 </pre> <p>This output shows that our bubble sort implementation correctly sorted the array in ascending order.</p> <p>To run the program, we need to compile it using a C compiler. Here is an example <strong>compilation command for GCC:</strong> </p> <pre> gcc -o bubble_sort bubble_sort.c </pre> <p>This command compiles the bubble_sort.c file and produces an executable file named bubble_sort.</p> <p>In summary, the bubble sort algorithm repeatedly swaps adjacent elements until the array is sorted. The algorithm has a time complexity of O(n<sup>2</sup>), which makes it inefficient for large data sets. However, it is useful for educational purposes and small data sets. We implemented the bubble sort algorithm in C programming language and tested it using a simple example.</p> <h3>Characteristics:</h3> <ul> <li>Bubble sort is a simple sorting algorithm.</li> <li>It works by repeatedly swapping adjacent elements if they are in the wrong order.</li> <li>The algorithm sorts the array in ascending or descending order.</li> <li>It has a time complexity of O(n<sup>2</sup>) in the worst case, where n is the size of the array.</li> </ul> <h3>Usage:</h3> <ul> <li>Bubble sort is useful for educational purposes and small data sets.</li> <li>It is not suitable for large data sets because of its time complexity.</li> </ul> <h3>Advantages:</h3> <ul> <li>Bubble sort is easy to understand and implement.</li> <li>It requires minimal additional memory space to perform the sorting.</li> </ul> <h3>Disadvantages:</h3> <ul> <li>It is not efficient for large data sets because of its time complexity.</li> <li>It has poor performance compared to other sorting algorithms, such as quicksort and mergesort.</li> </ul> <h2>Conclusion:</h2> <p>Bubble sort is a simple and intuitive sorting algorithm that is useful for educational purposes and small data sets. However, its time complexity makes it inefficient for large data sets. Therefore, it is not commonly used in real-world applications. Other sorting algorithms, such as quicksort and mergesort, are more efficient for large data sets.</p> <hr></n;></n>

Cette sortie montre que notre implémentation de tri à bulles a correctement trié le tableau par ordre croissant.

Pour exécuter le programme, nous devons le compiler à l'aide d'un compilateur C. Voici un exemple commande de compilation pour GCC :

 gcc -o bubble_sort bubble_sort.c 

Cette commande compile le fichier bubble_sort.c et produit un fichier exécutable nommé bubble_sort.

En résumé, l'algorithme de tri à bulles échange à plusieurs reprises les éléments adjacents jusqu'à ce que le tableau soit trié. L'algorithme a une complexité temporelle de O(n²), ce qui le rend inefficace pour les grands ensembles de données. Cependant, il est utile à des fins éducatives et pour de petits ensembles de données. Nous avons implémenté l'algorithme de tri à bulles dans le langage de programmation C et l'avons testé à l'aide d'un exemple simple.

Caractéristiques:

• Le tri à bulles est un algorithme de tri simple.
• Cela fonctionne en échangeant à plusieurs reprises les éléments adjacents s'ils sont dans le mauvais ordre.
• L'algorithme trie le tableau par ordre croissant ou décroissant.
• Il a une complexité temporelle de O(n²) dans le pire des cas, où n est la taille du tableau.

Usage:

• Le tri à bulles est utile à des fins éducatives et pour les petits ensembles de données.
• Il ne convient pas aux grands ensembles de données en raison de sa complexité temporelle.

Avantages :

• Le tri à bulles est facile à comprendre et à mettre en œuvre.
• Il nécessite un minimum d'espace mémoire supplémentaire pour effectuer le tri.

Désavantages:

• Il n’est pas efficace pour les grands ensembles de données en raison de sa complexité temporelle.
• Ses performances sont médiocres par rapport à d’autres algorithmes de tri, tels que le tri rapide et le tri par fusion.

Conclusion:

Le tri à bulles est un algorithme de tri simple et intuitif utile à des fins éducatives et pour les petits ensembles de données. Cependant, sa complexité temporelle le rend inefficace pour les grands ensembles de données. Par conséquent, il n’est pas couramment utilisé dans les applications réelles. D'autres algorithmes de tri, tels que le tri rapide et le tri par fusion, sont plus efficaces pour les grands ensembles de données.