TD 1 Algorithmes de tri

Daprs certaines estimations, environ un quart des ressources des microprocesseurs sont occupes
trier des donnes : tri de fichiers clients, de tickets de transactions financires, tri de facettes
pour laffichage 3D... Si la puissance des ordinateurs augmente rgulirement, les quantits de
donnes traites augmentent beaucoup plus vite, ce qui fait quon a besoin dalgorithmes toujours
plus performants.
Le but de ce TD est de prsenter quelques mthodes simples de tri de tableaux dentiers (le tri de
donnes dautres types suivant en gnral des principes rigoureusement similaires avec une autre
fonction de comparaison), souvent utilises pour trier un petit nombre de donnes, et den analyser le
fonctionnement et les performances.
En ce qui concerne justement lanalyse des performances, on comptera essentiellement le nombre de
comparaisons entre lments, et le nombre de lectures/critures en mmoire. Ces nombres dpendant
souvent de ltat du tableau trier, on essayera de distinguer le meilleur et le pire cas possibles.

1) Tri dun petit nombre dlments

Lorsquon veut trier un trs petit nombre dlments, il est plus simple dcrire directement les
comparaisons effectuer que de se lancer dans la conception dun programme compliqu. On peut
pour cela saider dun arbre de dcision.

a) crire une procdure tri2 qui prend en argument un tableau de type tableau2 = array[1..2]
of integer, et qui trie ce tableau.
b) crire les procdures tri3, tri4 et tri5 triant des tableaux de respectivement 3, 4 et 5
lments.
c) Pourquoi semble-t-il vain daller beaucoup plus loin sur cette voir ?

2) Tri par insertion

Lide de cet algorithme est de trier les lments du tableau un par un, en insrant chaque lment
la bonne place dans la partie du tableau dj trie. Cest ainsi que procdent certains joueurs de
bridge pour ranger leurs cartes dans lordre.
Voici un algorithme mettant en uvre cette ide :
 
procedure i n s e r t i o n ( t : tableau [ 1 . .N] d e n t i e r s ) ;

// Avant l entre dans l e corps de boucle , t [ 1 . . i 1] est t r i .

// Aprs l e corps de boucle , t [ i ] a t insr l a bonne place
// dans l e tableau t [ 1 . . i 1] , e t t [ 1 . . i ] est t r i .
pour i de 2 N f a i r e
j < i 1
// on f a i t remonter t [ i ] sa place
tant_que j >0 et t [ j +1] < t [ j ] f a i r e
echanger t [ j ] et t [ j +1]
fin_tant_que
fin_pour
 

a) Implmenter cet algorithme en Pascal (attention au fait que pour que le tableau soit effectivement
tri, il faut le transmettre par adresse et non par valeur).
b) Le test de la boucle tant_que est dangereux : que se passe-t-il si j=0 ?
Amliorer cet algorithme laide dune sentinelle de manire ce que le bon fonctionnement de
la procdure ne dpende pas du bon vouloir du compilateur !
c) Combien de comparaisons sont ncessaire dans le pire cas ? Combien dchanges ? Et au fait,
quel(s) tableaux correspondent ce pire cas ?
d) Que se passe-t-il dans le meilleur cas ? Quel(s) tableaux correspondent ce meilleur cas ?

1
 e) En fait, on peut singulirement amliorer cet algorithme en analysant ce qui se passe lors de la
phase dinsertion de t[i] : on rpte lopration

temp <- t[j+1]; t[j+1] <- t[j]; t[j] <- temp

jusqu ce que llment insrer soit la bonne position. Or on constate que temp reoit
toujours la mme valeur ! Il suffirait donc de sauvegarder une fois pour toutes cette valeur, et
de neffectuer que des dcalages en profitant de la place libre ainsi libre.
Voici un exemple dexcution montrant comment le petit tableau [55; 41; 59; 26] est tri
(temp montre la valeur de la variable temp, comp compte le nombre de comparaisons entre
lments du tableau, aff le nombre daffectations) :
temp comp aff
55 41 59 26 |
55 ## 59 26 | 41 1
## 55 59 26 | 41 1 2
41 55 59 26 | 3
41 55 ## 26 | 59 4
41 55 59 26 | 2 5
41 55 59 ## | 26 6
41 55 ## 59 | 26 3 7
## 41 55 59 | 26 4 8
26 41 55 59 | 9
Rcrire lalgorithme de tri par insertion, limplmenter et reprendre ltude de lefficacit dans
le meilleur et dans le pire cas.
f) crire un programme illustrant cette mthode de tri, en montrant les volutions successives du
tableau trier comme ci-dessus. On pourra supposer que les valeurs du tableau trier sont
comprises entre 10 et 99.
Observer le travail effectu sur quelques exemples bien choisis : un tableau tri en ordre
croissant, un autre tri en ordre dcroissant, et quelques tableaux obtenus par mlange alatoire.

3) Tri par slection

Une autre mthode simple de tri est le tri par slection : on cherche le plus petit lment du tableau
t[1..N], et on lchange avec t[1]. Puis on recommence en recherchant le plus petit lment
t[2..N], quon change avec t[2], et ainsi de suite.
Voici une version de cet algorithme :
 
procedure s e l e c t i o n ( t : tableau [ 1 . .N] d e n t i e r s ) ;

// Avant l entre dans l e corps de boucle , t [ 1 . . i 1] c o n t i e n t l e s

// i 1 plus p e t i t s lments du tableau t , rangs dans l ordre c r o i s s a n t .
// Aprs l e corps de boucle , l e plus p e t i t lment de t [ i . . N ] a
// t chang avec t [ i ] .
pour i de 1 N f a i r e
// On recherche l e plus p e t i t lment de t [ i . . N ]
min < i ;
pour j de i +1 N f a i r e
s i t [ j ] < t [ min ] a l o r s min < j f i n _ s i
fin_pour
// on l change avec t [ i ]
echanger t [ min ] et t [ i ]
fin_pour
 

a) Implmenter cet algorithme sous forme dune procdure selection.

b) Analyser le meilleur cas, le pire cas, en termes de nombre de comparaisons, et de nombre
dchanges.
c) En quoi cet algorithme peut-il tre prfrable au tri par insertion ?

2
4) Tri bulle
Le tri bulle est plus une curiosit amusante quune mthode de tri effective. En effet, il est peu
efficace, mme pour un algorithme lmentaire.
Voici lalgorithme dfinissant ce tri :
 
procedure bulle ( t : tableau [ 1 . .N] d e n t i e r s ) ;

rpter
temp < t [ 1 ]
pour j de 2 N f a i r e
s i t [ j 1] > t [ j ] a l o r s
temp < a [ j 1]; a [ j 1] < a [ j ] ; q [ j ] < temp
fin_si
fin_pour
jusqu ( t = a [ 1 ] ) ;
 

a) Expliquer le fonctionnement de cet algorithme, en montrant son action sur lentre

[57; 43; 59; 26; 53; 58; 97; 93]
b) Au regard de lanalyse prcdente, voyez-vous un moyen damliorer un peu la boucle interne ?
c) Limplmenter en Pascal, et construire un programme permettant den visualiser le fonctionnement.
d) Compter le nombre de comparaisons et dchanges dans le meilleur et le pire cas.
Cet algorithme vous semble-t-il efficace ?

5) Tri par distribution

Voici un autre algorithme, appel tri par distribution, qui trie une srie de donnes dont les valeurs
sont comprises entre 0 et M-1, en utilisant deux tableaux auxiliaires :
 
procedure d i s t r i b u t i o n ( t : tableau [ 1 . .N] d e n t i e r s ) ;

// variables temporaires :
// compte : tableau [ 0 . .M1] d e n t i e r s
// tabaux : tableau [ 1 . . N ] d e n t i e r s

pour j de 0 M1 f a i r e compte [ j ] < 0 fin_pour

pour i de 1 N f a i r e
compte [ t [ i ] ] < compte [ t [ i ] ] + 1
fin_pour
pour j de 0 M1 f a i r e
compte [ j ] < compte [ j 1] + compte [ j ]
fin_pour
pour i de N 1 f a i r e
tabaux [ compte [ t [ i ] ] ] < t [ i ]
compte [ t [ i ] ] < compte [ t [ i ] ] 1
fin_pour
pour i de 1 N f a i r e t [ i ] < tabaux [ i ] fin_pour
 

Expliquer le fonctionnement de cet algorithme qui a lair bien compliqu ! Quel est son avantage
principal ? Et son plus gros dfaut ?

6) Dautres tris
LInternet regorge de pages recensant dautres mthodes de tri plus ou moins compliques (et plus
ou moins adaptes aux situations particulires). Nhsitez pas en lire la description et essayer
de les implmenter.
Nous en verrons deux plus efficaces aprs le cours sur la rcursivit : le tri rapide et le tri fusion.