Les Tri

Trier les données

Organiser une collection d'objets selon une relation
d’ordre déterminée.
Exemple:
• Ordre croissant, décroissant des valeurs
numériques,
• Ordre croissant des mots, …
Pourquoi trier?
• Faciliter la recherche (recherche dichotomique)
• Faciliter la gestion en générale
Quelques algorithmes de tri

 Tri par Sélection

 Tri par Insertion
 Tri à Bulles
 Tri Rapide
 Tri Fusion
 Tri par dénombrement
 …
 Tri par sélection
Déterminer la position du plus petit élément p à partir de i
Échanger l’élément p avec i
Continuer à partir de i+1

2, 56, 4, -7, 0, 78, -45, 10

-45, 56, 4, -7, 0, 78, 2, 10
-45, 56, 4, -7, 0, 78, 2, 10
-45, -7, 4, 56, 0, 78, 2, 10
-45, -7, 4, 56, 0, 78, 2, 10
-45, -7, 0, 4, 56, 78, 2, 10
…
Tri par sélection

Algorithme
pour i :=1 à n-1 faire
p=minimum(T, i, n) ;
si (i ≠ p) alors échanger (T[i], T[p])
fsi;
fait ;
Tri par insertion
Prendre l’élément i
Insérer i dans l’ordre entre 1 et i
Continuer à partir de i+1

2, 56, 4, -7, 0, 78, -45, 10

2, 56, 4, -7, 0, 78, -45, 10
2, 56, 4, -7, 0, 78, -45, 10
2, 4, 56, -7, 0, 78, -45, 10
-7, 2, 4, 56, 0, 78, -45, 10
-7, 0, 2, 4, 56, 78, -45, 10
…
Tri par insertion

Algorithme
Pour i2 à n faire
ji;
tantque (j>1) et (T[j]<T[j-1]) faire
échanger(T[j], T[j-1]);
jj-1;
fait;
fait;
Tri à Bulles
 Comparer 2 à 2 les éléments adjacents
 Les échanger s'ils ne sont pas ordonnés
Comme les bulles, les plus grands éléments remontent
en fin de liste.
2, 56, 4, -7, 0, 78, -45, 10
2, 4, -7, 0, 56, -45, 10, 78
2, -7, 0, 4, -45, 10, 56, 78
-7, 0, 2, -45, 4, 10, 56, 78
-7, 0, -45, 2, 4, 10, 56, 78
-7, -45, 0, 2, 4, 10, 56, 78
-45, -7, 0, 2, 4, 10, 56, 78
Tri à Bulles
Algorithme
Pour i :=1 à n-1 faire
Pour j :=1 à n-i faire
Si (A[j]> A[j+1]) alors
échanger(A[j], A[j+1]);
Fsi ;
Fait ;
Fait ;
Tri à Bulles optimisé
 Problème : traitements inutiles
Exemple:
2, 56, 4, 7, 40, 78, 65, 45
2, 4, 7, 40, 56, 65, 45, 78
2, 4, 7, 40, 56, 45, 65, 78
2, 4, 7, 40, 45, 56, 65, 78
2, 4, 7, 40, 45, 56, 65, 78
2, 4, 7, 40, 45, 56, 65, 78
2, 4, 7, 40, 45, 56, 65, 78
Tri à Bulles optimisé
boolvrai; i1;
/* quand il n’y a aucun échange le tableau est trié*/
Tantque (bool=vrai) faire
boolfaux;
Pour j :=1 à n-i faire
Si (A[j]> A[j+1]) alors
échanger(A[j], A[j+1]);
boolvrai;
Fsi ;
Fait ;
ii+1;
Fait ;
Tri : diviser pour régner

Diviser en deux parties l’ensemble

d’éléments

Pour chaque partie divisée:

• Trier séparément (récursion)

Fusionner les résultats

 Tri fusion et tri Rapide

MergeSort QuickSort

5 3 2 9 4 6 5 3 2 9 4 6

5 3 2 9 4 6 3 2 4 5 9 6

2 3 5 4 6 9 2 3 4 5 6 9

2 3 4 5 6 9 2 3 4 5 6 9
 Tri Rapide (QuickSort)

Principe
Déterminer un pivot au hasard (e.g. premier élément)
Séparer les données en 2 parties:
<= pivot
>= pivot
Mettre ensemble: ≤pivot + (pivot) + ≥pivot
 Tri Rapide (QuickSort)
Procédure Tri_Rapide (E/T:tableau[n] entiers, g, d : entier)
p:entier;
Début
si (g < d) alors
p  partition(T, g, d);
Tri_Rapide(T, g, p-1);
Tri_Rapide (T, p+1, d);
fsi;
Fin;
 Tri Rapide (QuickSort)
Fonction partition(E/T:tableau[n] entiers, d, f : entier):entier
i, j, pivot : entier;
Début pivot  T[d]; id; jf;
Tantque (i < j) faire
Tantque (i ≤ f) et (T[i] ≤ pivot) faire ii+1; fait;
Tantque (j>d) et (T[j] > pivot) faire jj-1; fait;
si (i < j) alors permuter(T, i, j); ii+1; jj-1; fsi;
fait;
si (d≠j) alors permute(T, d, j); fsi;
retourner j;
Fin;
 Tri Rapide (QuickSort)

pivot  T[d]; id; jf;

tantque (i < j) faire
tantque (i ≤ f) et (T[i] ≤ pivot) faire
ii+1;
fait;
tantque (j>d) et (T[j] > pivot) faire
jj-1;
fait;
si (i < j) alors
permuter(T, i, j); ii+1; jj-1;
fsi;
fait;
si (d≠j) alors permute(T, d, j); fsi;
retourner j;
Fin;
Complexité des algorithmes de tri
Versions lentes : O(n2)
• Tri par sélection
• Tri à bulles
• Tri par insertion
•…
Versions rapides :O(nlogn)
• Tri rapide (Quick sort)
• Tri fusion (Merge sort)
• Tri par tas (Heap sort)
•…
 Complexité des algorithmes de tri

Arbre binaire de recherche (ABR) le parcours en

infixé permet d’afficher les valeurs dans l’ordre
croissant (ou décroissant) O(nlogn).

- La construction de l’arbre ~ O(nlogn)

- L’affichage des valeurs ~ O(n)

Inconvénient : espace mémoire occupé

Tri Dénombrement (Tri sans comparaison)

Le tri suppose que chacun des n

éléments d’entrée est un entier de
l’intervalle 1 à k, pour un entier k
donné.
Tri Dénombrement

Ce tri repose sur la connaissance préalable de la

plus grande valeur maximale k contenue dans le
tableau.
Notons qu'elle peut être déterminée en temps
linéaire à l'aide de l'algorithme CHERCHER-MAX
pour chercher la valeur maximale.
 Principe
Déterminer pour chaque élément x, le nombre d’éléments
< = à x. Ceci permet de placer l’élément x directement
dans sa position dans le tableau de sortie.
Exemple s’il existe 17 éléments < à x, alors x sera en
position 18.
Plusieurs valeurs peuvent se répéter, évidemment elles
ne seront pas à la même position.
 Principe
Autrement dit :
• on parcourt le tableau A et on compte le nombre de
fois que chaque élément apparaît. Ainsi on
obtiendra un tableau des effectifs C (avec C[i] le
nombre de fois où i apparaît dans le tableau),
• On parcourt ensuite le tableau C dans le sens
croissant (ou décroissant) et placer dans le tableau
A C[i] fois l’élément i (avec i allant de l’élément
minimum du tableau jusqu’à l’élément maximum).
Algorithme
Entrée : A[1..n] d’entier
Sortie: B[1..n]
Tableau intermédiaire C[1..k] initialisé à zéro
C[i] contiendra le nombre d’éléments égaux à i
initialement puis il contiendra le nombre
d’éléments ≤ 𝑖𝑖
Le tri par dénombrement est réalisé en 3 phases

1. Initialisation :

Initialisation de toutes les cases du

tableau C[1..k] à 0.
2. Dénombrement :
Parcours du tableau A et incrémentation de la
cellule C dont l'indice est la valeur contenue dans la
cellule courante du tableau A. C[A[i]]  C[A[i]]+1

A la fin, le tableau contient la distribution des

valeurs de A
3. Tri :
Parcours du tableau C en rangeant
simultanément la valeur de l'indice i de C
dans A autant de fois que C[i].
 Algorithme

Fonction TriDénombrement(E/ A : tableau[1..n] d’entiers;

n, k :entiers ; S/ B: tableau[1..n] d’entiers)
Var: i :entier ; C :tableau[1..k]d’entiers ;
Début
Pour i 1 à k faire C[i] 0 fait ;
Pour i 1 à n faire C[A[i]]  C[A[i]]+1 fait ;
Pour i2 à k faire C[i]C[i]+C[i-1] fait;
// C[i] contient le nombre d’éléments ≤ i
Suite de l’algorithme

Pour in à 1 faire

B[C[A[i]]]A[i];
C[A[i]]C[A[i]]-1;
fait; // B sera trié
FIN;
 Déroulement: A [5|3|4|2|3|9|3|2]

Pour i 1 à k faire C[i] 0 fait ;

C[0|0|0|0|0|0|0|0|0]
Pour i 1 à n faire C[A[i]]  C[A[i]]+1 fait ;
C[0|2|3|1|1|0|0|0|1]
Pour i2 à k faire C[i]C[i]+C[i-1] fait;
// C[i] contient le nombre d’éléments ≤ i
C[0|2|5|6|7|7|7|7|8]
 Déroulement: n=7 A [5|3|2|3|9|3|2]
C[0|0|0|0|0|0|0|0|0] C[0|2|3|0|1|0|0|0|1] C[0|2|5|5|6|6|6|6|7]
i=7 B[C[A[7]]]A[7]=2 ; B[C[2]]=B[2]2 ; C[2]=C[2]-1=1 B[ |2| | | | | ]
C[0|1|5|5|6|6|6|6|7]
i=6 B[C[A[6]]]A[6]=3 ; B[C[3]]=B[5]3 ; C[3]=C[3]-1=4 B[ |2| | |3| | ]
C[0|1|4|5|6|6|6|6|7]
i=5 B[C[A[5]]]A[5]=9 ; B[C[9]]=B[7]9 ; C[9]=C[9]-1=6 B[ |2| | |3| |9]
C[0|1|4|5|6|6|6|6|6]
i=4 B[C[A[4]]]A[4]=3 ; B[C[3]]=B[4]3 ; C[3]=C[3]-1=3 B[ |2| |3|3| |9]
C[0|1|3|5|6|6|6|6|6]
i=3 B[C[A[3]]]A[3]=2 ; B[C[2]]=B[1]2 ; C[2]=C[2]-1=0 B [ 2| 2 | | 3 | 3 | | 9 ]
C[0|0|3|5|6|6|6|6|6]
i=2 B[C[A[2]]]A[2]=3 ; B[C[3]]=B[3]3 ; C[3]=C[3]-1=2 B [ 2| 2 | 3 | 3 | 3 | | 9 ]
C[0|0|2|5|6|6|6|6|6]
i=1 B[C[A[1]]]A[1]=5 ; B[C[5]]=B[6]5 ; C[5]=C[5]-1=5 B [ 2| 2 | 3 | 3 | 3 | 5 | 9 ]
C[0|0|2|5|5|6|6|6|6]
 Complexité
La 1ère boucle s’exécute en O(k)
La 2ème boucle s’exécute en O(n)
La 3ème boucle s’exécute en O(k)
La 4ème boucle s’exécute en O(n)
Donc l’algorithme est en O(2k+2n)
On ignore les constantes donc on a :
O(k+n)=O(max(k,n))=O(n)
Remarque : Ce tri ne fait aucune comparaison entre les
éléments. C’est un tri linéaire.