web-dev-qa-db-fra.com

C Astuces de tri des tableaux

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

Quelle est la meilleure technique de tri pour trier le tableau suivant et s'il y a des doublons comment les gérer. Quelle est également la meilleure technique de tri 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 < array_size - 1 - i; ++j )
      {
           if (a[j] > a[j+1])
           {
                temp = a[j+1];
                a[j+1] = a[j];
                a[j] = temp;
           }
      }
 }
 }
calgorithmsorting
28
Rajeev

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

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 tri optimal (basé sur la comparaison) est un algorithme qui s'exécute avec des comparaisons O (n log (n)). Il y en a plusieurs qui ont cette propriété (y compris le tri rapide, le tri par fusion, le tri en tas, etc.), mais lequel utiliser dépend de votre cas d'utilisation.

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

44
Alex Reece

Dans votre cas particulier, le tri le plus rapide est probablement celui décrit dans cette réponse . Il est exactement optimisé pour un tableau de 6 pouces et utilise des réseaux de tri. Il est 20 fois (mesuré sur x86) plus rapide que la bibliothèque qsort. Les réseaux de tri sont optimaux pour le tri de tableaux de longueur fixe. Comme il s'agit 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 tri optimisés pour certains cas spécialisés. Les algorithmes à usage général comme le tri en tas ou le tri rapide sont optimisés pour le tri sur place d'un tableau d'éléments. Ils produisent une complexité de O (n.log (n)), n étant le nombre d'éléments à trier.

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 trier une très grande quantité d'algorithmes de données, il faut également prendre en charge l'échange de données vers et depuis le disque, c'est le genre de tri implémenté dans les bases de données et votre meilleur pari si vous avez de tels besoins est de mettre les données dans une base de données et d'utiliser le construit en quelque sorte.

12
kriss

Dépend

Cela dépend de différentes choses. Mais en général, les algorithmes utilisant une approche Diviser et Conquérir / dichotomique fonctionneront bien pour trier les problèmes car ils présentent des complexités moyennes intéressantes.

Les bases

Pour comprendre quels algorithmes fonctionnent le mieux, vous aurez besoin d'une connaissance de base de complexité des algorithmes et notation big-O , afin que vous puissiez comprendre comment ils se classent en termes de moyenne cas, meilleur et pire cas . Si nécessaire, vous devrez également faire attention à la stabilité de l'algorithme de tri .

Par exemple, un algorithme efficace est généralement le tri rapide. Cependant, si vous donnez au tri rapide une liste parfaitement inversée, il fonctionnera mal (un tri par sélection simple fonctionnera mieux dans ce cas!). Le tri par shell serait également un bon complément au tri rapide si vous effectuez une pré-analyse de votre liste.

Jetez un œil à ce qui suit, pour les "recherches avancées" utilisant des approches de division et de conquête:

Et ces algorithmes plus simples pour les moins complexes:

Plus loin

Ce qui précède sont les suspects habituels au début, mais il existe d'innombrables autres.

Comme indiqué par R. dans les commentaires et par Kriss dans sa réponse, vous voudrez peut-être jeter un œil à HeapSort , qui offre une complexité de tri théoriquement meilleure qu'un tri rapide (mais ne le fera pas souvent mieux dans des conditions pratiques). Il existe également des variantes et algorithmes hybrides (par exemple TimSort ).

5
haylem

J'aimerais apporter quelques modifications: En C, vous pouvez utiliser la commande intégrée 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 )
2
Thomas

La meilleure technique de tri de tous dépend généralement de la taille d'un tableau. Le tri par fusion peut être le meilleur de tous, car il gère une meilleure complexité d'espace et de temps selon l'algorithme Big-O (cela convient mieux pour un grand tableau).

2
Pankti