Algorithmes de tri et complexité

Algorithmes de tri et complexité
Plan
1. RECHERCHE D'UN ELEMENT DANS UN TABLEAU ..................................................................................2
1.1. R ECHERCHE SEQUENTIELLE D ' UN ELEMENT .......................................................................................................2
1.2. R ECHERCHE DICHOTOMIQUE DANS UN TABLEAU TRIE .........................................................................................2
1.3. C OMPLEXITE D ' UN ALGORITHME ........................................................................................................................3
2. TRI PAR SELECTION DIRECTE....................................................................................................................3
3. TRI PAR INSERTION......................................................................................................................................5
4. TRI PAR PERMUTATION (TRI "BULLE") ....................................................................................................6
5. TRI PAR DEPLACEMENTS DECROISANTS (TRI DE SHELL)....................................................................7
6. TRI PAR SEGMENTATION (QUICKSORT DE HOARE) ...............................................................................7
7. TRI PAR COMPTAGE.................................................................................................................................. 11

1. RECHERCHE D'UN ELEMENT DANS UN TABLEAU
La nécessité de trier des données résulte du besoin de les retrouver rapidement. Par
exemple, pour chercher l'adresse et le numéro de téléphone d'une personne, on parcours un
fichier jusqu'à trouver l'enregistrement qui le concerne.
On supposera par la suite que tous les éléments du fichier sont rangés dans un tableau en
mémoire centrale (ce qui n'est pas toujours possible).
1.1. Recherche séquentielle d'un élément
Pour rechercher séquentiellement un élément dans un tableau, on passe en revue tous les
éléments de ce tableau, un à un, jusqu'à trouver la position de l'élément recherché (appelé
encore indice). Un recherche séquentielle est plus ou moins rapide selon que l'élément
recherché est situé au début ou en fin du tableau. En moyenne, on passe en revue la moitié
des éléments. Si N est le nombre d'élément du tableau, le nombre moyen de comparaisons
sera N/2.
Exercice: écrire l'algorithme de recherche
1.2. Recherche dichotomique dans un tableau trié
Lorsque le tableau est trié numériquement ou alphabétiquement, la méthode de recherche
dichotomique permet de diviser le temps de recherche par 2 à chaque étape. L'algorithme est
le suivant:
1) Initialiser la section de recherche à l'ensemble du fichier.
2) Comparer le nom cherché au nom de l'élément situé au milieu de la section de
recherche
- si le nom cherché est plus petit que le nom de l'élément situé au milieu, on
recommence la recherche dans la première moitié
- si le nom cherché est plus grand que le nom de l'élément situé au milieu, la
recherche se poursuit dans la seconde moitié.
- sinon on a trouvé l'élément recherché
3) Recommencer en (2) tant que l'élément cherché n'est pas trouvé ou que la section de
recherche est constitué d'au moins un élément.
Lorsqu'il y a par exemples 1024 éléments, on retrouve l'élément recherché après au plus 10
comparaisons (210 = 1024) alors qu'il en faut en moyenne 512 dans le cas d'une recherche
séquentielle. Comme on le voit, l'algorithmique a une très grande importance dans la
programmation. Notons dès à présent que les algorithmes utilisés dépendent beaucoup de
l'organisation et des structures de données adoptées.

1.3. Complexité d'un algorithme
Pour évaluer l'efficacité d'un algorithme, on introduit la notion du complexité comme étant
l'ordre de grandeur des opérations à effectuer pour N données.
Dans le cas de la recherche séquentielle dans un tableau de N éléments non triés, on a vu
que le nombre moyen d'opérations est N/2. L'ordre de grandeur est donc en O(N) ce qui
signifie que le temps de traitement est proportionnel au nombre d'élément. Dans le cas de la
recherche dichotomique dans un tableau trié, l'ordre de grandeur est en O(Log2 N).
La complexité des algorithmes permet de les comparer entre eux. Un algorithme de
complexité O(N) est réputé meilleur qu'un algorithme en O(N2). Pour de grandes valeurs de
N, cela parait évident et c'est souvent le cas. Pour des petites valeurs de N, ce n'est pas
toujours vrai.
2. Tri par SELECTION DIRECTE
On recherche l'élément le plus petit et on le range dans le second tableau. Cette méthode
utilise 2 tableaux. Le tableau trié résultant n'est pas le tableau de départ qui conserve l'ordre
initial des éléments à trier. Avec cette méthode, il faut se rappeler les éléments déjà pris.
BETA
OMEGA
ALPHA
GAMMA
ALPHA
BETA
OMEGA
------------
GAMMA
ALPHA
BETA
Si N est le nombre d'éléments du tableau, cette méthode effectue N recherches du plus petit
élément suivant dans le tableau à trier. Sachant que la recherche séquentielle d'un élément
demande en moyenne N/2 comparaisons, cette méthode demandera N2/2 comparaisons.
La complexité de cet algorithme est donc en O(N2) ce qui signifie que son temps de
traitement est proportionnel au carré du nombre d'éléments à trier.

Une amélioration consiste à n'utiliser qu'un seul tableau et procéder par permutation. Le
début du tableau est considéré trié. On recherche le plus petit élément dans la section non
triée du tableau. Cet élément est permuté avec le premier élément de la section non triée. La
partie triée du tableau s'enrichit alors d'un élément.
BETA
OMEGA
ALPHA
GAMMA
ALPHA
OMEGA
BETA
GAMMA
ALPHA
BETA
OMEGA
GAMMA
ALPHA
BETA
GAMMA
OMEGA
Exercice: écrire l'algorithme de tri par sélection directe avec un seul tableau.

3. Tri par INSERTION
On n'utilise ici qu'un seul tableau. On considère à un instant donné que les P premiers
éléments du tableau sont déjà triés. On recherche alors la place de l'élément numéro (P+1)
parmi les P éléments déjà triés. L'élément est inséré à la place ainsi trouvée, ce qui a pour
conséquence le déplacement des éléments plus grands que lui.
+--------+ +--------+ +--------+ +--------+
¦ BETA ¦ ¦ BETA _ ¦ <-+ ¦ ALPHA ¦ ¦ ALPHA ¦
+--------¦ Ã--------Â ¦ Ã--------Â Ã--------Â
¦ OMEGA ¦ ? ¦ OMEGA_ ¦ ¦ ¦ BETA ¦ ¦ BETA ¦
+--------¦ +--------¦ ¦ Ã--------Â Ã--------Â
¦ ALPHA ¦ ¦ ALPHA ¦ ?-+ ¦ OMEGA_ ¦<--+ ¦ GAMMA ¦
+--------¦ ¦--------¦ +--------¦ ¦ Ã--------Â
¦ GAMMA ¦ ¦ GAMMA ¦ ¦ GAMMA ¦ ?-+ ¦ OMEGA ¦
+--------+ +--------+ +--------+ +--------+
Notons que le déplacement des éléments, de la partie déjà triée, plus grands que l'élément à
insérer peut s'effectuer au fur et à mesure des comparaisons. Si TAB[ i ] désigne l'élément
numéro i du tableau, l'algorithme d'insertion s'écrit alors :
EL_A_INSERER <- TAB[ P+1 ]
INDICE <- P
Tant que (TAB[ INDICE ] > EL_A_INSERER) ET ( INDICE >= 1) faire
TAB[ INDICE+1 ] <- TAB[ INDICE ]
INDICE <- INDICE-1
Fin (Tant que)
TAB[ INDICE+1 ] <- EL_A_INSERER
Exercice: écrire l'algorithme complet du tri par insertion.