C Astuces de sorting des tableaux

a=[1,3,6,7,1,2] 

Quelle est la meilleure technique de sorting pour sortinger le tableau suivant et s’il existe des doublons pour les traiter. Aussi, quelle est la meilleure technique de sorting de tous ….

  void BubbleSort(int a[], int array_size) { int i, j, temp; for (i = 0; i < (array_size - 1); ++i) { for (j = 0; j  a[j+1]) { temp = a[j+1]; a[j+1] = a[j]; a[j] = temp; } } } } 

En C, vous pouvez utiliser la commande intégrée dans qsort :

 int compare( const void* a, const void* b) { int int_a = * ( (int*) a ); int int_b = * ( (int*) b ); if ( int_a == int_b ) return 0; else if ( int_a < int_b ) return -1; else return 1; } qsort( a, 6, sizeof(int), compare ) 

voir: http://www.cplusplus.com/reference/clibrary/cstdlib/qsort/


Pour répondre à la deuxième partie de votre question: un algorithme de sorting optimal (basé sur la comparaison) est celui qui fonctionne avec des comparaisons O (n log (n)). Plusieurs propriétés ont cette propriété (y compris le sorting rapide, le sorting par fusion, le sorting par tas, etc.), mais le choix dépend de votre cas d'utilisation.

En passant, vous pouvez parfois faire mieux que O (n log (n)) si vous savez quelque chose sur vos données - voir l'article de Wikipédia sur Radix Sort

Dans votre cas particulier, le sorting le plus rapide est probablement celui décrit dans cette réponse . Il est exactement optimisé pour un tableau de 6 ints et utilise des réseaux de sorting. Il est 20 fois (mesuré sur x86) plus rapide que la bibliothèque qsort. Les réseaux de sorting sont optimaux pour sortinger les tableaux de longueur fixe. S’agissant d’une séquence d’instructions fixe, elles peuvent même être implémentées facilement par le matériel.

De manière générale, il existe de nombreux algorithmes de sorting optimisés pour certains cas spécialisés. Les algorithmes d’usage général tels que le sorting par tas ou le sorting rapide sont optimisés pour le sorting en place d’un tableau d’éléments. Ils produisent une complexité de O (n.log (n)), n étant le nombre d’éléments à sortinger.

La fonction de bibliothèque qsort () est très bien codée et efficace en termes de complexité, mais utilise un appel à une fonction de comparaison fournie par l’utilisateur, et cet appel a un coût assez élevé.

Pour sortinger une très grande quantité de données, les algorithmes doivent également prendre en charge l’échange de données vers et depuis le disque. C’est le type de sorting mis en œuvre dans les bases de données et votre meilleur choix si vous avez de tels besoins est de mettre des données dans une firebase database et d’utiliser le construit en quelque sorte.

Dépend

Cela dépend de différentes choses. Toutefois, en général, les algorithmes utilisant une approche Divide-and-Conquer / dichotomic fonctionneront bien pour résoudre les problèmes, car ils présentent des complexités de cas moyen intéressantes.

Les bases

Pour comprendre quels algorithmes fonctionnent le mieux, vous aurez besoin de connaissances de base de la complexité des algorithmes et de la notation big-O , afin de pouvoir comprendre comment ils se classent en termes de cas moyen, de meilleur cas et de pire scénario . Si nécessaire, vous devrez également faire attention à la stabilité de l’algorithme de sorting .

Par exemple, un algorithme efficace est généralement un sorting rapide. Cependant, si vous donnez au sorting rapide une liste parfaitement inversée, sa performance sera médiocre (un sorting simple sera plus performant dans ce cas!). Shell-sort serait également un bon complément au sorting rapide si vous effectuez une pré-parsing de votre liste.

Jetez un coup d’œil à ce qui suit pour les “recherches avancées” utilisant des approches de type diviser pour régner:

  • sorting rapide
  • shellsort
  • sorting par fusion

Et ces algorithmes plus simples pour les moins complexes:

  • bubbleort
  • type de sélection
  • insérer un sorting

Plus loin

Ce qui précède sont les suspects habituels lors de la mise en route, mais il en existe d’innombrables autres.

Comme l’ont souligné R. dans les commentaires et Krr dans sa réponse, vous souhaiterez peut-être jeter un coup d’œil à HeapSort , qui offre une complexité de sorting théoriquement supérieure à celle d’un sorting rapide (mais ne sera pas souvent plus performant dans des conditions pratiques). Il existe également des variantes et des algorithmes hybrides (par exemple, TimSort ).

La meilleure technique de sorting dépend généralement de la taille d’un tableau. Le sorting par fusion peut être le meilleur, car il gère une meilleure complexité spatio-temporelle selon l’algorithme Big-O (cela convient mieux à un grand tableau).

J’aimerais faire quelques changements: En C, vous pouvez utiliser la commande intégrée dans qsort :

 int compare( const void* a, const void* b) { int int_a = * ( (int*) a ); int int_b = * ( (int*) b ); // an easy expression for comparing return (int_a > int_b) - (int_a < int_b); } qsort( a, 6, sizeof(int), compare )