Quel est le moyen le plus élégant de trier des bulles dans C#?

Ce que vous avez collé il n'y a pas
http://en.wikipedia.org/wiki/Bubble_sort
. C'est quelque chose comme "brute force", Mais ce n'est pas une note de bulle. Voici un exemple de tri des bulles courantes. Il utilise un comparateur arbitraire, mais vous permet de la baisser et, dans ce cas, le comparateur par défaut est utilisé pour le type approprié. Il triera /non seulement la lecture/ Mise en œuvre

IList<t>

, qui comprend des tableaux. Lire le lien ci-dessus /sur Wikipedia/, Pour obtenir une image plus complète de la manière dont le tri des bulles devrait fonctionner. Veuillez noter comment chaque cycle nous allons du début à la fin, mais comparez uniquement chaque élément avec son voisin. C'est toujours un algorithme de tri. O /n

2

/, Mais dans de nombreux cas, ce sera plus rapide que la version que vous avez donnée.

public void BubbleSort<t>/IList<t> list/

{

 BubbleSort<t>/list, Comparer<t>.Default/;

}



public void BubbleSort<t>/IList<t> list, IComparer<t> comparer/

{

 bool stillGoing = true;

 while /stillGoing/

 {

 stillGoing = false;

 for /int i = 0; i &lt; list.Count-1; i++/

 {

 T x = list[i];

 T y = list[i + 1];

 if /comparer.Compare/x, y/ &gt; 0/

 {

 list[i] = y;

 list[i + 1] = x;

 stillGoing = true;

 }

 }

 }

}

</t></t></t></t></t></t></t></t>

Le moyen le plus élégant de tri en C # est

Array.Sort/ object[] /

Cela fonctionnera partout, à l'exception des devoirs, où l'enseignant vous a demandé de mettre en œuvre un algorithme deluteurs pour trier des bulles.
;-/

En général, rien ne va pas avec votre réalisation de tri de bulles. Si je faisais des codes réels, j'aurais apporté les modifications suivantes:

Choisissez plus de noms variables descriptifs.

Pourquoi votre tableau est appelé juste

c

?

Minimiser la portée de la visibilité variable

Toutes vos variables sont déclarées en haut de la fonction. Si ce n'est pas une norme de devoirs ou de codage, il est plus important de déclarer des variables. "close" À l'endroit où ils sont utilisés, de préférence pour avoir le plus petit domaine d'action possible.

Donc, éliminez la première chaîne qui se lit

int i = 0,j = 0,t = 0;

. Déclarez des compteurs de cycle intégrés:

for/int i = 0; i < 20; i++/

Et déclarez votre variable temporaire à l'endroit où elle est utilisée:

Console.WriteLine/"c[{0}]={1}, c[{2}]={3}", i, c[i], j, c[j]/;

 int t=c[i];

 c[i]=c[j];

 c[j]=t;

Éliminez les limites de la matrice codées rigoureusement.

Ce:

for/i=0;i<20;i++/

Ce sera:

for/i = 0; i < c.Length; i++/

La plupart des gens ne se dérangeraient pas à faire

bulle

élégant. DANS

Général

, Cependant, je trouve ce que je fais:

for /int i = 0; i < items.Length; i++/ {

 Item item = items[i];

 // do something with item

}

Il est simultanément plus élégant et plus maintenu que de le faire:

Item item;

int i;

for /i = 0; i < items.Length; i++/ {

 item = items[i];

 // do something with item

}

En d'autres termes,

Déclaration de variables dans la plus petite zone applicable

. Sinon, vous pouvez trouver ce que vous faites quelque chose avec

i

ou

item

À un autre point du code, puis à nouveau, utilisez-les là où vous ne devriez pas.

j'utiliserais swap methed, Échanger deux éléments de tableau dans des endroits.
/Détails sur la façon d'écrire une méthode swap, Laissé comme devoir!/

Vous devez penser à l'affaire lorsque les sujets sont déjà en ordre

Vous devez lire sur le tri des inserts pour plus d'étiquettes :-/

Au lieu de lire des données de test du clavier, voir si vous pouvez apprendre à utiliser nUnit

Personnellement, je préfère cela:

string foo [] = new string[] {"abc", "def", "aaa", "feaf", "afea" };

Array.Sort/foo/;

Mais c'est juste moi. Trier est un problème résolu, pourquoi réinventer le vélo?

Je crois qu'il y a une amélioration de

, Proposé

. Après chaque cycle, le nombre d'itérations doit exclure le dernier élément traité dans l'itération précédente. Donc, voici le code:

public void BubbleSortImproved<t>/IList<t> list/

{

 BubbleSortImproved<t>/list, Comparer<t>.Default/;

}



public void BubbleSortImproved<t>/IList<t> list, IComparer<t> comparer/

{

 bool stillGoing = true;

 int k = 0;

 while /stillGoing/

 {

 stillGoing = false;

 //reduce the iterations number after each loop

 for /int i = 0; i &lt; list.Count - 1 - k; i++/

 {

 T x = list[i];

 T y = list[i + 1];

 if /comparer.Compare/x, y/ &gt; 0/

 {

 list[i] = y;

 list[i + 1] = x;

 stillGoing = true;

 }

 }

 k++;

 }

}

</t></t></t></t></t></t></t>

int[] array = {4,5,7,1,8}; 



int n1, n2;

bool stillgoing = true;



while /stillgoing/

{

 stillgoing = false;

 for /int i = 0; i < /array.Length-1/; i++/

 { 

 if /array[i] > array[i + 1]/

 {

 n1 = array[i + 1];

 n2 = array[i];



 array[i] = n1;

 array[i + 1] = n2;

 stillgoing = true; 

 }

 }

}

for /int i = 0; i < array.Length; i++/

{

 Console.WriteLine/array[i]/;

}

Emprunté des idées de John Skeit ...

public int[] BubbleSortInAesc/int[] input/

 {

 for /int i = input.Length; i > 0; i--/

 {

 for /int j = 0; j < i-1; j++/

 {

 if /input[j] > input[j + 1]/

 {

 //Swap the numbers

 input[j] = input[j + 1]+input[j];

 input[j + 1] = input[j] - input[j + 1];

 input[j] = input[j] - input[j + 1];

 }

 }

 }

 return input;

 }

Je pense que votre algorithme est en ordre, mais je placerais la fonctionnalité du tri dans une classe et une méthode distinctes.