L’objectif de ce cours est d’étudier et de comparer plusieurs algorithmes de tri d’une liste.

On rappelle que l’accès à des données triées est plus rapide (par exemple par utilisation d’un algorithme
dichotomique) que des données non triées (penser par exemple à un dictionnaire dont les mots ne seraient
pas triés par ordre alphabétique).

Tous les algorithmes de tri reposent sur la comparaison de deux éléments entre eux (donc des paires
particulières de la liste à trier). Une telle comparaison sera appelée comparaison binaire. L’objectif étant de trier
la liste en effectuant le moins de comparaisons binaires possible et en déplaçant le moins de données possible
en mémoire.

Chaque algorithme de tri sera évalué suivant plusieurs critères :

• Le nombre de comparaisons binaires à effectuer dans le meilleur et le pire des cas ;
• Le nombre d’affectations (autrement dit le nombre de fois où on déplace un objet de la liste).
On propose de tester manuellement chacun des algorithmes de tri sur une liste de cartes à ordonner.
Enfin, chaque algorithme propose de ranger les éléments dans l’ordre croissant. Il est possible de les adapter
pour ranger dans l’ordre décroissant.

1 Présentation de différents tris

1.1 Tri par sélection
Il s’agit de chercher le plus petit élément et de le placer devant puis de poursuivre avec le sous-tableau à
partir du second élément etc... jusqu’à la fin.

1.1.1 Algorithme
L Début

n=0

non
L[s]=tmp n=n+1 n<len(L) ? Fin

L[n]=L[s] oui
s=n
non

k=s+1
L

tmp=L[n] s ‰ n? k<len(L) ?
oui non

oui

non
L[k]<L[s] ? k=k+1

oui
s=k
1.1.2 Simulation sur un exemple
Appliquer l’algorithme de tri précédent à la liste de cartes suivante :

En pratique :
• On considère que la position tout à gauche est la position 0 ;
• Les variables s et n sont des entiers représentant des positions dans la liste. Vous les repèrerez en utilisant
deux morceaux de papier marqués l’un d’un s et l’autre d’un n. Ils seront placés au dessus de la carte
de la liste occupant la position correspondant à la valeur de la variable. Vous déplacerez les marques en
papier au fur et à mesure de l’exécution de l’algorithme.
• L’entier k sera représenté par votre index ;
• La variable tmp sera représentée par une zone géographique de votre table de travail ;
• tmp=L[p] sera interprété comme le déplacement de la carte occupant la position p de la liste vers la zone
tmp ;
• L[p]=L[q] sera interprété comme le déplacement de la carte se trouvant en position q vers la position p ;
• L[p]=tmp sera interprété comme le déplacement de la carte occupant la zone tmp vers la position p de
la liste ;
• A chaque déplacement de carte, le lieu d’arrivée doit être vide (sinon c’est qu’il y a un problème dans
l’algorithme...).
Lors de l’exécution de l’algorithme vous observerez :
• L’ordre des cartes se trouvant avant la position marquée par n ;
• Le nombre de déplacements effectués par chaque carte ;
• Le nombre de comparaisons binaires effectuées.
Vous répondrez également aux questions :
1. Le test s ‰ n est-il utile ? Si oui à quoi ?
2. Lors de l’exécution de l’algorithme, sur l’exemple proposé, combien effectue-t-on de comparaisons de
cartes ? Combien de déplacements de cartes ?

1.1.3 Remarque
La liste est donc parcourue de nombreuses fois : autant de fois que d’éléments même si les parcours deviennent
de plus en plus courts (vu qu’on ne démarre pas du début à chaque fois). Le nombre de comparaisons binaires
à effectuer est donc important.

1.2 Tri naturel par insertion (ou en place)

1.2.1 Algorithme
On considère l’algorithme suivant (on suppose que la liste L contient au moins deux éléments) :
 L Début

n=1

non
n=n+1 n<len(L) ? Fin

oui
tmp=L[n]

s=n-1
L

s • 0 et
L[s+1]=tmp
non L[s]>tmp ?

oui
L[s+1]=L[s] s=s-1

1.2.2 Simulation sur un exemple

Appliquer l’algorithme de tri précédent à la liste de cartes suivante :

En pratique :
• On considère que la position tout à gauche est la position 0 ;
• Les variables s et n sont des entiers représentant des positions dans la liste. Vous les repérerez en utilisant
deux morceaux de papier marqués l’un d’un s et l’autre d’un n. Ils seront placés au dessus de la carte
de la liste occupant la position correspondant à la valeur de la variable. Vous déplacerez les marques en
papier au fur et à mesure de l’exécution de l’algorithme.
• La variable tmp sera représentée par une zone géographique de votre table de travail ;
• tmp=L[p] sera interprété comme le déplacement de la carte occupant la position p de la liste vers la zone
tmp ;
• L[p]=L[q] sera interprété comme le déplacement de la carte se trouvant en position q vers la position p ;
• L[p]=tmp sera interprété comme le déplacement de la carte occupant la zone tmp vers la position p de
la liste ;
• A chaque déplacement de carte, le lieu d’arrivée doit être vide (sinon c’est qu’il y a un problème dans
l’algorithme...).
 Lors de l’exécution de l’algorithme vous observerez :
• L’ordre des cartes se trouvant avant la position marquée par n ;
• Le nombre de déplacements effectués par chaque carte ;
• Le nombre de comparaisons binaires effectuées.
Vous répondrez également aux questions :
1. Lors de l’exécution de l’algorithme, sur l’exemple proposé, combien effectue-t-on de comparaisons de
cartes ? Combien de déplacements de cartes ?

1.3 Tri rapide

Le principe du tri rapide est d’utiliser l’un des éléments de la liste comme « pivot » et de réorganiser la liste
de telle sorte que les éléments à gauche du pivot soit plus petits que le pivot et ceux à droite soient plus grands.
Le pivot est un élément pris au hasard dans la liste. La réorganisation de la liste doit s’effectuer en place et en
déplaçant le moins possible les éléments. Une fois cette étape réalisée, les deux parties de la liste peuvent être
traitées séparément par la même méthode jusqu’à obtenir des listes vides ou d’un seul élément qui sont donc
triées.

Par exemple, pour la liste :

Si on considère le 8 de pique comme pivot on devra réorganiser pour obtenir :

On remarque :
• le pivot se trouve placé directement à la bonne place après la réorganisation ;
• Le paquet de droite et de gauche ne sont pas nécessairement ordonnés et sont à priori de cardinal différent.
On peut donc par récursivité appliquer la méthode sur ces deux paquets.

1.3.1 Algorithme de réorganisation

Dans l’algorithme suivant, les données en entrée sont :
• L la liste à trier ;
• p le rang du pivot à utiliser (entre 0 et len(L)-1).
 L et p Début

échanger L[0] et L[p]

s=0

n=1

non
n=n+1 n<len(L) ? échanger L[0] et L[s]

Fin
oui

L[n] <
non
L[0] ?
L

oui
s=s+1

échanger L[s] et L[n]

1.3.2 Simulation de l’algorithme de réorganisation sur un exemple

Appliquer l’algorithme de tri précédent à la liste de cartes suivante en prenant le neuf comme pivot :

En pratique :
• On considère que la position tout à gauche est la position 0 ;
• Les variables s et n sont des entiers représentant des positions dans la liste. Vous les repérerez en utilisant
deux morceaux de papier marqués l’un d’un s et l’autre d’un n. Ils seront placés au dessus de la carte
 de la liste occupant la position correspondant à la valeur de la variable. Vous déplacerez les marques en
papier au fur et à mesure de l’exécution de l’algorithme.
Lors de l’exécution de l’algorithme vous observerez :
• L’ordre des cartes se trouvant avant la position marquée par s ;
• Le nombre de déplacements effectués par chaque carte ;
• Le nombre de comparaisons binaires effectuées.
Vous répondrez également aux questions :
1. Lors de l’exécution de l’algorithme, sur l’exemple proposé, combien effectue-t-on de comparaisons de
cartes ? Combien de déplacements de cartes ?

1.3.3 Algorithme complet de tri rapide

L’algorithme repose sur l’utilisation de l’algorithme de réorganisation précédent ainsi que sur la récursivité
(pour relancer le processus sur les deux sous-listes).

Dans l’exemple précédent, après la première étape de réorganisation avec 9 comme pivot, on obtient la liste :

Il reste donc à relancer le processus avec les deux listes :

et

et ainsi de suite jusqu’à tomber sur des listes vides ou ne contenant qu’un seul élément (qui sont donc déjà
triées). On remarque que le pivot est directement placé au bon endroit après la réorganisation.

Pour éviter de dupliquer des parties de la liste, on utilise un système d’index qui indique sur quelle partie
de la liste on applique l’algorithme de réorganisation. Les détails seront donnés en travaux pratiques lors de
l’implémentation en Python du programme.
1.4 Tri fusion
L’idée du tri fusion est de couper la liste à trier en deux parties (en général on coupe en deux parties de même
cardinal), de trier chacune d’entre elles puis de les fusionner. Evidemment, chaque sous-partie sera elle-même
triée par la même méthode en utilisant la récursivité. Le point clé de la méthode est la fusion d’une liste en
deux parties dont chacune d’entre elles est déjà triée. Autrement dit, le passage de :

1.4.1 Algorithme de fusion de deux sous-listes triées

On considère une liste L et un entier p tels que :
• L contient au moins deux éléments ;
• La sous-liste Lr0 : p ` 1s (des éléments de rang 0 au rang p) est triée ;
• La sous-liste Lrp ` 1 : lenpLqs (des éléments de rang p ` 1 à la fin de la liste) est triée .
L et p Début

tmp=L[0 :p+1]

n=0 ; k=0

s=p+1

non
n § p? Fin

oui

L
s • lenpLq
ou
oui non
tmprns §
Lrss ?

L[k]=tmp[n] L[k]=L[s]

n=n+1 s=s+1

k=k+1
1.4.2 Simulation de l’algorithme de fusion de deux sous-listes triées
Appliquer l’algorithme de tri précédent à la liste de cartes suivante avec p “ 2 :

En pratique :
• On considère que la position tout à gauche est la position 0 ;
• Les variables s, n, k sont des entiers représentant des positions dans une liste. Vous les repérerez en
utilisant des morceaux de papier marqués d’un s d’un n ou d’un k au dessus de la carte dont ils désignent
la position. Vous déplacerez les marques en papier au fur et à mesure de l’exécution de l’algorithme.
• Xrxs “ Y rys sera interprété par le déplacement de la carte en position y de la liste Y vers la position x
de la liste X.
• La liste tmp sera représentée en dessous de la liste L en gardant les alignements.
Autrement dit, avant la première exécution de l’instruction n § p, vous devez avoir sur votre table :

indicateurs k,n s

Liste L

Liste tmp

Il est extrêmement important de respecter les alignements.

Lors de l’exécution de l’algorithme vous observerez :
• L’ordre des cartes se trouvant avant la position marquée par k ;
• Le nombre de déplacements effectués par chaque carte ;
• Le nombre de comparaisons binaires effectuées.
Vous répondrez également aux questions :
1. Pourquoi l’algorithme se termine lorsque n ° p ?
2. Combien de déplacements ont été effectués au total ?
3. Combien de comparaisons binaires ?

1.4.3 Simulation de l’algorithme de fusion complet

Exécuter l’algorithme de tri par fusion dans le cas de la liste ci-dessous :
2 Comparaison de complexité
L’étude du nombre de comparaisons binaires et de déplacements sur un exemple ne peut servir d’évaluation
fiable sur la performance d’un algorithme. En général, on se livre au calcul formel dans le meilleur des cas, le
pire cas et en moyenne. Ces calculs sont plutôt compliqués et seuls les résultats sont reportés dans le tableau
ci-dessous pour une liste de taille n.

Méthode de tri Sélection Insertion Rapide Fusion

n2 n2
Complexité 2 4 2n logpnq n logpnq