Vous êtes sur la page 1sur 36

Mthodes de tri

Benot Charroux - Tris - Septembre 98 - 2


Les mthodes de tri
Les mthodes de tri permettent le rarrangement de donnes.
Par exemple, le fichier :
Philippe 21
Jean 33
Lineda 27
peut tre tri par nom :
Jean 33
Lineda 27
Philippe 21
ou tri par ge :
Philippe 21
Lineda 27
Jean 33
Benot Charroux - Tris - Septembre 98 - 3
Les mthodes de tri
Pour pouvoir comparer les mthodes de tris, on les appliquent des tableaux dentiers.
20 6 1 3 1 7
0 1 2 3 4 5 Indices :
1 1 3 6 7 20
0 1 2 3 4 5 Indices :
Tableau non tri :
Tableau tri :
1MLVWMV tri( t: tab en entre sortie )
1MMMV
1VM
...
1M
MMbMV N " ...
1MMMV WV
1MMMV
1VM
_@V tab = VM[ N ]: VMV
V t: tab
tri( t )
1M
Benot Charroux - Tris - Septembre 98 - 4
Tri par slection
Mthode :
on cherche llment de plus petite valeur pour lchanger avec llment en
premire position ;
puis on cherche llment ayant la deuxime plus petite valeur pour lchanger
avec llment en deuxime position ;
et ainsi de suite.
20 6 1 3 1 7
1 6 20 3 1 7
1 1 20 3 6 7
1 1 3 20 6 7
1 1 3 6 20 7
1 1 3 6 7 20
Il faut :
1 boucle pour parcourir le tableau et slectionner tous les lments ;
1 boucle pour rechercher le minimum parmi les lments non tris.
Benot Charroux - Tris - Septembre 98 - 5
Algorithme du tri par slection
1MLVWMV triSlection( t: tab en entre sortie )
1MMMV
1VM
Vb i, j, min, tmp : VMV
1MM i WV 0 N-2 V@VV /* slection dun lment */
min <- i
1MM j WV i+1 N-1 V@VV /* recherche du minimum */
t[ j ] < t[ min ] Mb
min <- j
1M b
1M @MM
tmp <- t[ i ] /* change */
t[ i ] <- t[ min ]
t[ min ] <- tmp
1M @MM
1M
Benot Charroux - Tris - Septembre 98 - 6
Tri par insertion
Mthode :
on considre les lments les uns aprs les autres en insrant chacun sa place
parmi les lments dj tris.
20 6 1 3 1 7
6 20 1 3 1 7
1 6 20 3 1 7
1 3 6 20 1 7
1 1 3 6 20 7
1 1 3 6 7 20
Il faut :
1 boucle pour parcourir le tableau et slectionner llment insrer ;
1 boucle pour dcaler les lments plus grands que llment insrer ;
insrer llment.
Benot Charroux - Tris - Septembre 98 - 7
Algorithme du tri par insertion
1MLVWMV triInsertion( t: tab en entre sortie )
1MMMV
1VM
Vb i, j, mem: VMV
1MM i WV 1 N-1 V@VV /* slection de llment insrer*/
mem <- t[ i ]
j <- i
M @MV j>0 V t[j-1]>mem V@VV /* dcalage des lments plus grands */
t[ j ] <- t[ j-1 ]
j <- j - 1
1M M @MV
t[ j ] <- mem /* insertion */
1M @MM
1M
Benot Charroux - Tris - Septembre 98 - 8
Amlioration du tri par insertion
3URFpGXUHtriInsertion( t: tab en entre sortie )
$OJRULWKPH
'pEXW
...
7DQWTXH j>0 HW ... 5pSpWHU
...
j <- j - 1
)LQWDQWTXH
...
)LQ
Le test j>0 qui vite les dpassements
gauche du tableau est presque toujours vrai !
Placer une sentinelle : lment infrieur ou gale au minimum du tableau
20 6 1 3 1 7 -1
Benot Charroux - Tris - Septembre 98 - 9
Tri bulles
Mthode :
on parcours autant de fois le tableau en permutant 2 lments adjacents mal classs
quil le faut pour que le tableau soit tri.
20 6 6 6 6 6
6 20 1 1 1 1
1 1 20 3 3 3
3 3 3 20 1 1
1 1 1 1 20 7
7 7 7 7 7 20
Il faut :
1 boucle pour parcourir tout le tableau et slectionner les lments un un ;
1 boucle pour permuter les lments adjacents.
Tableau
prit
dans ce
sens
1 1 1 1
6 3 3 3
3 6 1 1
1 1 6 6
7 7 7 7
20 20 20 20
1
1
3
6
7
20
...
5 passes 4 passes
Benot Charroux - Tris - Septembre 98 - 10
Algorithme du tri bulles
3URFpGXUHtriBulles( t: tab en entre sortie )
$OJRULWKPH
'pEXW
9DULDEOHV i, j, temp: HQWLHU
3RXU i GH N-1 j 0 UpSpWHU /* slection de llment insrer*/
3RXUj GH 1 ji UpSpWHU /* dcalage des lments plus grands */
6L t[ j-1 ] > t[ j ] DORUV
tmp <- t[ j-1 ] /* change */
t[ j-1 ] <- t[ j ]
t[j ] <- tmp
)LQVL
)LQSRXU
)LQSRXU
)LQ
Benot Charroux - Tris - Septembre 98 - 11
Comparaison des performances des tris lmentaires
1MLVWMV triSlection( t: tab )
1MMMV
1VM
1MM i WV 0 N-2 V@VV
1MM j WV i+1 N-1 V@VV
1M @MM
1M @MM
1M
1MLVWMV triInsertion( t: tab )
1MMMV
1VM
1MM i WV 1 N-1 V@VV
M @MV j>0 V t[j-1]>mem V@VV
1M M @MV
1M @MM
1M
1MLVWMV triBulles( t: tab )
1MMMV
1VM
1MM i WV N-1 0 V@VV
1MM j WV 1 i V@VV
1M @MM
1M @MM
1M
Ces mthodes prennent de lordre de N
2
tapes
pour trier N lments :
N petit ou lments presque tris ;
N grand et lments dans un ordre
alatoire.
Benot Charroux - Tris - Septembre 98 - 12
Performances du tri par slection
3URFpGXUHtriSlection( t: tab en entre sortie )
$OJRULWKPH
'pEXW
3RXU i GH 0 j N-2 UpSpWHU /* boucle N-1 fois */
3RXU j GH i+1 j N-1 UpSpWHU /* boucle N-i fois */
6L t[ j ] < t[ min ] DORUV /* (N-1)+(N-2)++2+1=N(N-1)/2 comparaisons */
min <- j /* seule partie qui dpend des donnes */
)LQVL
)LQSRXU
... /* N-1 changes */
)LQSRXU
)LQ
Tri par slection :
nombre de comparaison de lordre de N
2
/2 ;
nombre dchanges de lordre de N.
Benot Charroux - Tris - Septembre 98 - 13
Performances du tri par insertion
Tri par insertion :
nombre de comparaison de lordre de N
2
/4 ;
nombre dchanges de lordre de N
2
/8 ;
linaire si les donnes sont dj tries.
1MLVWMV triInsertion( t: tab )
1MMMV
1VM
1MM i WV 1 N-1 V@VV /* boucle N-1 fois */
mem <- t[ i ]
j <- i
M @MV ... t[j-1]>mem V@VV /* boucle i fois 1+2++(N-1)=N(N-1)/2 */
t[ j ] <- t[ j-1 ] /* N(N-1)/2 demi changes */
1M M @MV
1M @MM
1M
Dans le pire des cas :
nombre de comparaisons -> N
2
/2
nombre dchanges -> N
2
/4
Benot Charroux - Tris - Septembre 98 - 14
Performances du tri bulles
Tri bulles :
nombre de comparaison de lordre de N
2
/2 ;
nombre dchanges de lordre de N
2
/2 ;
1 seule passe si le tableau est dj tri.
3URFpGXUHtriBulles( t: tab en entre sortie )
$OJRULWKPH
'pEXW
3RXU i GH N-1 j 0 UpSpWHU /* boucle N fois */
3RXUj GH 1 ji UpSpWHU/* boucle i fois */
6L t[ j-1 ] > t[ j ] DORUV /* 1+2++N N
2
/2 comparaisons au pire des cas */
... /* changes = comparaisons N
2
/2 */
)LQVL
)LQSRXU
)LQSRXU
)LQ
Tableau tri en ordre inverse
Benot Charroux - Tris - Septembre 98 - 15
Comparaison des tris
Tri bulles :
nombre de comparaison de lordre de N
2
/2 ;
nombre dchanges de lordre de N
2
/2 ;
Tri par insertion :
nombre de comparaison de lordre de N
2
/4 ;
nombre dchanges de lordre de N
2
/2 ;
linaire si les donnes sont dj tries.
Tri par slection :
nombre de comparaison de lordre de N
2
/2 ;
nombre dchanges de lordre de N.
Tableaux de petites tailles :
slection ;
insertion ;
bulles.
Tableaux presque tris :
slection ;
insertion ;
bulles.
Tableaux de grandes tailles et alatoires :
slection ;
insertion ;
bulles.
Tableaux avec de grands
enregistrements mais des
clefs petites :
slection ;
insertion ;
bulles.
Benot Charroux - Tris - Septembre 98 - 16
Tri shell : amlioration du tri par insertion
Inconvnient : pour ramener un
lment de la fin vers la tte, il faut
dcaler tous les lments plus
grands.
Le tri par insertion :
on considre les lments les uns aprs
les autres en insrant chacun sa place
parmi les lments dj tris.
1 2 3 6 20 0
1 2 3 6 20 0
23
23
3 2 23 1 20 0 6
...
3 1 20 2 23 0 6
3 2 23 1 20 0 6
...
0 1 3 2 20 23 6
raliser un tri par insertion sur
des lments spars par h cases
=> faire moins de dcalage :
faire dcrotre h jusqu 1
pour finir de trier le tableau.
on obtient un tableau
entrelac partiellement tri ;
Benot Charroux - Tris - Septembre 98 - 17
Tri shell : amlioration du tri par insertion
Mthode :
raliser un tri par insertion sur des lments distant de h cases ;
faire dcrotre h.
20 11 51 54 27 9 65 6 1 3 34 7 43 21 8
20 11 51 54 43 9 65 6 1 3 34 7 27 21 8
20 11 51 54 43 9 65 6 1 3 34 7 27 21 8
20 11 51 54 43 9 65 7 1 3 34 27 6 21 8
21 11 51 54 43 9 65 7 20 3 34 27 6 1 8
21 9 51 54 43 11 65 7 20 8 34 27 6 1 3
37 34 43 51 53 65 7 8 9 11 20 21 1 3 6
h = 13
h = 4
...
Le choix de h est empirique : le suite , 364, 121, 40, 13, 4 et 1 est souvent utilise.
3URFpGXUHtriShell( t: tab )
$OJRULWKPH
'pEXW
9DULDEOHV i, j, h, mem: HQWLHU
h <- 1
7DQWTXH h <= N/9 UpSpWHU /* gnre le premier de la suite */
h <- 3*h+1
)LQWDQWTXH
7DQWTXH h > 0 UpSpWHU /* pour toute la suite 364, 121, 40, 13, 4, 1*/
/* tri par insertion dlments distant de h cases */
h <- h/3
)LQWDQWTXH
)LQ
Benot Charroux - Tris - Septembre 98 - 18
Algorithme du tri shell
3RXU i GH h+1 j N-1 UpSpWHU
mem <- t[ i ]
j <- i
7DQWTXH j>h HW t[j-h]>mem UpSpWHU
t[ j ] <- t[ j-h ]
j <- j - h
)LQWDQWTXH
t[ j ] <- mem
)LQSRXU
Benot Charroux - Tris - Septembre 98 - 19
Performances du tri shell
Tri shell :
N
3/2
comparaisons au maximum pour la suite 1,
4, 13, 40, ;
actuellement, on ne connat pas la complexit
en temps de cet algorithme.
Mthode de choix dans de nombreuses application :
commencer par utiliser cette mthode mme sur des tableaux
relativement gros (- 5000 lments) ;
si les performances sont mauvaises, envisager une autre solution.
Benot Charroux - Tris - Septembre 98 - 20
Tri rapide (quick sort)
Mthode diviser pour rsoudre :
choisir un seuil (pivot) ;
mettre les lments plus petit que le seuil gauche du seuil et les lments
plus grands droite ;
recommencer sparment sur les parties droite et gauche.
Il faut :
partitionner selon un pivot ;
recommencer sur les partitions (rcursion).
20 6 1 3 1 7
1 6 1 3
1 1 3 6
1 6 1 3 7 20

1 6 1 3
Benot Charroux - Tris - Septembre 98 - 21
Algorithme du tri rapide
1MLVWMV triRapide( t: tab en entre sortie, g: VMV, d: VMV )
1MMMV
1VM
V p: VMV
d > g Mb
p <- partitionnement( t, g, d ) /* p = pivot */
triRapide( t, g, p-1 ) /* trier partie gauche */
triRapide( t, p+1, d ) /* trier partie droite */
1M b
1M
Benot Charroux - Tris - Septembre 98 - 22
Algorithme du tri rapide
)RQFWLRQpartitionnement( t: tab, g: HQWLHU, d: HQWLHU ): HQWLHU
$OJRULWKPH
'pEXW
9DULDEOH i, j, p, tmp: HQWLHU
p <- t|d] /* pivot = lment de droite */
i <- g-1 /* i = curseur partant de la gauche */
j <- d /* j = curseur partant de la droite */
5pSpWHU
5pSpWHU /* recherche partir de la gauche ...*/
i <- i+1
7DQWTXHt[ i ] < p /* du premier lment > pivot */
5pSpWHU /* recherche partir de la droite ...*/
j <- j-1
7DQWTXHj>i HWt[ j ] > p /* du premier lment < pivot */
6Li >= j DORUV /* si les curseurs se rejoignent */
EUHDN /* la partition est faite */
)LQVL
tmp <- t[i] t[i] <- t[j] t[j] <- tmp /* change des lments aux curseurs */
6DQVFRQGLWLRQ
tmp <- t[i] t[i] <- t[d] t[d] <- tmp /* dplacement du pivot sa place */
UHWRXUi
)LQ
20 6 1 11 2 7
2 6 1 11 20 7
Benot Charroux - Tris - Septembre 98 - 23
Performance du tri rapide
1 2 6 7 11 20
1 2 6 7 11
1 2 6 7
1 2 6
1 2
1
Tri le plus employ :
relativement simple ;
de lordre de NlogN oprations en moyenne pour trier N lments ;
de lordre de N
2
oprations dans le pire des cas : tableaux simples
(dj tris par exemple) ;
mthodes pour amliorer les performances (partitionnement par la
mdiane).
Benot Charroux - Tris - Septembre 98 - 24
Tri par fusion (merge sort)
20 6 1 3 10 8 15 12
20 6 1 3 10 8 15 12
20 6 1 3 10 8 15 12
6 20
1 3
1 3 6 20
8 10
12 15
8 10 12 15
1 3 6 8 10 12 15 20
20 6 1 3 10 8 15 12
Fusion :
Division :
Benot Charroux - Tris - Septembre 98 - 25
Diviser
1MLVWMV triFusion( t: tab en entre sortie, g: VMV, d: VMV )
1MMMV
1VM
V m: VMV
d > g Mb
m <- (g+d) / 2
triFusion( t, g, m ) /* trier partie gauche */
triFusion( t, m+1, d ) /* trier partie droite */
/* fusionner */
1M b
1M
Benot Charroux - Tris - Septembre 98 - 26
Fusionner laide dun tableau intermdiaire 1/2
...
3RXU i GH m j g UpSpWHU
s[ i ] <- t[ i ]
)LQSRXU
3RXU j GH m+1 j d UpSpWHU
s[ d+m+1-j ] <- t[ j ]
)LQSRXU
...
1 3 6 20 8 10 12 15 tableau t :
1 3 6 20 15 12 10 8 tableau intermdiaire s :
g m d
Partie miroir de t
Remplir le tableau intermdiaire s.
Benot Charroux - Tris - Septembre 98 - 27
Fusionner laide dun tableau intermdiaire

k<-g i<-g j<-d


M @MV k <= d V@VV /* parcours de t */
s[i] < s[j] Mb
t[k] <- s[i]
i <- i+1
MMM
t[k] <- s[j]
j <- j-1
1M b
k <- k+1
1M M @MV
1 3 6 20 15 12 10 8 tableau s :
1 3 8 10 12 15 20

tableau t :
j
i, k
d
g
6
Comparer les lments de s deux deux pour les fusionner dans t.
Tri par fusion :
nombre de comparaison de lordre NlogN pour trier N lments ;
place mmoire supplmentaire proportionnelle N ;
tri idal pour pour les listes chanes (accs squentiel) en changeant
la partie fusion de lalgorithme.
Benot Charroux - Tris - Septembre 98 - 28
Performance du tri par fusion
Benot Charroux - Tris - Septembre 98 - 29
Tri par tas (heap sort)
20 6 1 3 10 8 15
20
10 15
3 6 1 8
15
10 8
3 6 1
Transformer en tas
Trier :
Transformer en tas
tel que pre > fils pre
supprimer le maximum et rtablir la condition pre > fils pre ;
10 15
3 6 1 8
20
20
itrer le processus tant que le tableau nest pas tri.
Benot Charroux - Tris - Septembre 98 - 30
Transformer en tas
20 6 1 3 10 8 15
20
10 15
3 6 1 8
20 10 15 3 6 1 8
0 1 2 3 4 5 6
2*2+1
2*2+2
20 10 8 3 6 1 15
0 1 2 3 4 5 6
6/2-1
20 10 15 3 6 1 8
0 1 2 3 4 5 6

20
10 8
3 6 1 15
20
10 15
3 6 1 8

Insrer 15 ?
chercher le pre :
permuter si ncessaire :
Si pre i :
fils 1 2*i+1
fils 2 2*i+2
1MLVWMV insertionTas( t: tab ..., v: VMV )
1MMMV
1VM
V p: VMV
N <- N + 1
t[ N ] <- v /* ajout nouveau en fin de tableau */
i <- N
M @MV i<=1 et t[ i/2-1 ] <= v V@VV /* tant que pre <= nouveau */
t[ i ] <- t[ i/2-1 ] /* fait descendre le pre */
i <- i/2-1 /* pre suivant */
1M M @MV
t[ i ] <- v /* positionne nouveau */
1M
Benot Charroux - Tris - Septembre 98 - 31
Transformer en tas
20 10 8 3 6 1 15
0 1 2 3 4 5 6
6/2-1
20 10 15 3 6 1 8
0 1 2 3 4 5 6
chercher le pre :
permuter si ncessaire :
3URFpGXUHWriParTas( t: tab en entre sortie )
$OJRULWKPH
'pEXW
9DULDEOH i: HQWLHU
3RXUiGH1jNUpSpWHU
insertionTas( t, t[ i ] ) /* transformer en tas */
)LQSRXU
3RXUiGHNj0UpSpWHU
t[ i ] <- supprimerMax( t ) /* trier */
)LQSRXU
)LQ
Benot Charroux - Tris - Septembre 98 - 32
Trier
15
10 8
3 6 1
10 15
3 6 1 8
20
20
1MMLMM supprimerMax( t: tab en entre sortie ) : VMV
1MMMV
1VM
V i, j, v, max: VMV
max <- t[ 1 ]
t[ 1 ] <- t| N ] /* place le dernier lment en tte */
N <- N-1 /* supprime la dernire case (le max) */
/* reconstruire le tas */
VMM max
1M
Benot Charroux - Tris - Septembre 98 - 33
Supprimer le maximum 1/2
10 15
3 6 1 8
20
20
20 10 15 3 6 1 8
0 1 2 3 4 5 6
Benot Charroux - Tris - Septembre 98 - 34
Supprimer le maximum 2/2
/* reconstruire le tas */
v <- t[ 1 ]
7DQWTXH i <= N/2 UpSpWHU
j <- i+i /* j est le premier fils de i */
6L j<N et t[j]<t[j+1] DORUV /* si le deuxime fils est plus grand */
j <- j+1 /* on le garde */
)LQVL
6L v >= t[ j ] DORUV
EUHDN
)LQVL
t[ i ] <- t[ j ] /* change avec le plus grand des fils */
i <- j /* y a-til dautres fils ? */
)LQWDQWTXH
t[ i ] <- v
8 10 15 3 6 1
0 1 2 3 4 5 6
15 10 8 3 6 1
0 1 2 3 4 5 6
15
10 8
3 6 1
Tri par tas :
ncessite de l ordre de NlogN tapes pour trier N lments ;
pas de place mmoire supplmentaire ;
en moyenne deux fois plus lent que le tri rapide.
Benot Charroux - Tris - Septembre 98 - 35
Performance du tri par tas
Benot Charroux - Tris - Septembre 98 - 36
Comparaison des tris
Tri shell :
de lordre de N
3/2
comparaisons.
Tri rapide :
de lordre de NlogN oprations ;
de lordre de N
2
oprations dans le pire des cas.
Tri par fusion :
nombre de comparaison de lordre NlogN ;
place mmoire supplmentaire proportionnelle N.
Tri par tas :
ncessite de lordre de NlogN tapes ;
en moyenne deux fois plus lent que le tri rapide.
Le plus employ :
tri rapide
Le plus simple sur des
fichiers relativement gros
(-5000 lments) :
tri shell
Tri de listes chanes :
tri par fusion
Tri de fichiers
partiellement tris :
tri par tas