Tri à bulles en C#

L'article suivant fournit un aperçu du tri à bulles en C#. Le tri à bulles est un algorithme de tri considéré comme l'algorithme le plus simple, qui place les éléments ou les nombres dans un ordre particulier et ces éléments sont finalement placés à leur emplacement approprié trié dans le tableau.

Algorithme de tri à bulles

Le concept de base sur lequel fonctionne le tri à bulles est qu'un tableau est pris en compte. Ce tableau est itéré du premier index au dernier index. Lors du parcours, le tableau est comparé aux éléments adjacents et échangés s'ils sont présents dans le mauvais ordre. Cela signifie que si les nombres sont plus petits que l'élément actuel à un index particulier, ils seront échangés. Ce processus est répété jusqu'à ce que le tableau soit complètement trié. Elle se déroule sous forme de pass.

Prenons en considération un tableau de sept nombres aléatoires et trions-les :

Le tri à bulles fonctionne sous forme de passes. Ces passes prennent deux nombres adjacents en même temps, puis comparent ces deux nombres. Si les nombres présents sont dits N. Alors le nombre de passes nécessaires pour trier un ensemble de données est N – 1. Chaque passe trie les données en tenant compte de ces deux nombres et réitère la séquence jusqu'à ce que tous les nombres ne soient pas triés de la manière attendue.

Passe 1 :

90   76   45   93   68   13   98

Lors du premier passage, les deux premiers nombres sont comparés. Ici, il comparera 90 à 76. 90 est supérieur à 76, il sera donc échangé.

76   90   45   93   68   13   98

Maintenant, 90 sera comparé à 45. (0 est également supérieur à 45. Par conséquent, cela sera échangé avec 45.

76   45   90   93   68   13   98

Maintenant, les nombres 90 et 93 sont déjà en ordre. Ils ne seront pas échangés et resteront tels quels. Ce passage sera donc arrêté selon l'algorithme.

Pass 2 :

76   45   90   93   68   13   98

Cette passe recommencera avec le premier numéro du tableau. Cela signifie que le tri commencera désormais à partir de 76. 76 sera comparé à 45. 45 étant inférieur à 76 sera échangé avec 76.

45   76   90   93   68   13   98

Maintenant, 76 et 90 seront vérifiés. Ils sont déjà dans le bon ordre donc il n'y aura aucun changement dans le tableau.

De cette façon, le parcours se fera jusqu'à la fin du tableau.

Algorithme de tri à bulles

• BubbleSort(Array : liste des éléments triables)
• N= Array.Length
• Définir le drapeau := Vrai
• Répétez les étapes de 3 à 5 pour I = 1 à N-1 tandis que Flag == true
• Définir le drapeau := Faux
• Définissez i:=0
• Répétez pendant que i
• (a) Si Tableau[i+1]>Array[i], alors :
  Échanger le tableau[i] et le tableau[i+1] Définir le drapeau := Vrai
• (b) Définir i :=i+1
• Sortie

Exemples de tri à bulles en C#

Vous trouverez ci-dessous les exemples :

Exemple n°1

Programme C# pour implémenter le tri à bulles.

Code :

using System;
class Bubble
{
static void bubbleSrt(int []arr)
{
int num = arr.Length;
for (int i = 0; i < num - 1; i++)
for (int j = 0; j < num - i - 1; j++)
if (arr[j] > arr[j + 1])
{
// swap tmp and arr[i]
int tmp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = tmp;
}
}
/* Printing the array */
static void printIt(int []arr)
{
int n = arr.Length;
for (int i = 0; i < n; ++i)
Console.Write(arr[i] + " ");
Console.WriteLine();
}
// Main method
public static void Main()
{
int []arr = {90, 76, 45, 93, 68, 13, 98};
bubbleSrt(arr);
Console.WriteLine("Sorted array");
printIt(arr);
}
}

Sortie :

Le programme ci-dessus a une méthode définie pour trier les nombres à l'aide du tri à bulles. Bubblesort a deux boucles for qui parcourent le tableau et stockent le numéro à échanger dans une variable temporaire tmp. Cette valeur tmp est ensuite échangée avec la position où elle devrait se trouver à l'aide de l'index j. Une autre méthode est utilisée pour imprimer le tableau trié. Le tri à bulles utilise n – 1 passes pour trier le tableau.

Le tri à bulles peut également être implémenté par ordre décroissant.

Exemple n°2

Le programme C# pour implémenter le tri à bulles par ordre décroissant peut être le suivant :

Code :

using System;
public class BubbleSrt
{
public static void Main(string[] args)
{
int[]arr=new int[10]{23,98,45,12,9,16,65,74,34,29};//Array created with 10 unsorted numbers
bubblesort(arr,10);
int a;
for(a = 0; a < 10; a++)
Console.Write(arr[a]+"\t");//Printing the array after sorting in descending order
Console.ReadLine();
}
//bubble sort
static void bubblesort(int[] data, int n)
{
int a;
int b;
for(a = 0; a < n; a++)
for (b = n-1; b > a; b--)
if (data[b] > data[b-1])//Condition to arrange array in descending order
{
int temp = data[b];
data[b]=data[b-1];
data[b-1]=temp;
}
}
}

Sortie :

Ici, nous trions le tableau par ordre décroissant. Nous avons déclaré un tableau comportant dix nombres. Après cela, nous appelons la fonction bubblesort dans le programme principal, puis nous l'imprimons par ordre décroissant. La fonction bubblesort ici a pris deux variables pour parcourir le tableau. Ici, il faut prendre deux boucles for, parcourir le tableau et comparer les valeurs présentes dans le tableau. La condition étant que les données soient présentes à l’index b et à l’index b – 1 seront comparées. Si le nombre présent en b est supérieur, il sera échangé. Cela se fait dans la boucle for interne. Une fois échangé, il continuera jusqu'à la fin du tableau.

Conclusion

Le tri à bulles est la méthode de tri la plus simple. Il traverse l'ensemble du tableau et fait apparaître les nombres en bulles, ce qui facilite l'échange et le placement du tableau dans le bon ordre. Il compare deux nombres adjacents et les affiche au fur et à mesure qu'ils ne sont pas dans l'ordre attendu. Ce tri en utilisant C# est très simple et peut être effectué en utilisant les variables de base présentes dans le tableau.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!