4

VARI
LES TRIS

PLAN
Le problme du tri
Le tri par insertion
Le tri fusion
Le tri par tas
Le tri rapide
Comparaison des tris
Le tri par dnombrement
1

4.1

LE PROBLEME DU TRI

4-1-1

DFINITION

entre:

suite de n lments

sortie:

permutation de la suite
e'1, e'2, .., e'n
e'1 e'2 .. e'n

e1, e2, .., en

condition: ensemble totalement ordonn

EXEMPLE:

cls, , alphabet,..
2

- problme simple, connu et courant

- nombreuses solutions avec structures
de donnes varies
- sous-problme de problmes complexes

4-1-2

IMPLMENTATION

rappel: tri par slection (cours 1) en O(n2)

tri bulle: (variante)

en O(n2)

faire

parcours partir de la fin de l

comparaison de ei avec ei-1
change si ei-1 ei
jusqu' aucun change possible
Etude dans la suite d'algorithmes plus efficaces
4

Si on veut trier des lments (classe Elt), le tri doit se faire sur les cls des
lments. Pour simplifier la prsentation, dans ce chapitre, on trie des entiers et
on utilise donc des tableaux d'entiers. On pourrait aussi utiliser des tableaux de
cls (CCl) ou des tableaux d'lments (Elt).

classe CTab{
entier taille;
entier [ ] tab;
entier long=0;

//taille du tableau
//ce tableau contient des entiers
//nombre d'lments dans le tableau

CTab( entier t){

this.taille=t;
this.tab=new entier[t];
}
}

Dans tout ce chapitre nous supposerons que les tableaux

sont indics de 1 n (et non de 0 n-1) Classe CIndice

4-2

LE TRI PAR INSERTION

principe:

lments placs un un directement

leur place

4-2-1

INSERTION SQUENTIELLE

EXEMPLE

7 15 8 10 5 17
7 15 8 10 5 17
7 8 15 10 5 17
7 8 10 15 5 17

//dcalage droite de 15
//dcalage droite de 15

//dcalage droite de 7, 8, 10 et 15

5 7 8 10 15 17
5 7 8 10 15 17
7

implmentation
void

tri_inser_seq ( )

//tri d'un tableau d'entiers ou de cls

CIndice i,j; entier cl;

dbut
pour

j = 2 long faire
cl = tab[j] ; //cl placer
i = j-1 ;
tant que i > 0 et tab[i] > cl faire
//dcalage vers la droite

tab[i+1] = tab[i] ;
i = i-1 ;
fait;

tab[i+1] = cl ; //mise de cl dfinitivement sa place

fait;
fin

complexit
pire des cas
-boucle pour : j de 2 n (=long)
-itration j,
boucle tant que : j fois
O(2 + 3 +..+ n) oprations
insertion squentielle en O(n2)
9

complexit
en moyenne
-boucle pour : j de 2 n
-itration j,
boucle tant que : j/2 fois
O(2 + 3 +..+ n)/2 oprations
en moyenne en O(n2)
10

4-2-2 INSERTION DICHOTOMIQUE

recherche dichotomique de la place o insrer
l'lment j (dans la premire partie trie de la
liste)
(cf cours 1)

chaque itration:
recherche de la place en O(log n)
mais dplacements en O(n)
complexit en O(n2)
11

4-2-3COMPLEXIT EN MMOIRE

tris par insertion et slection:

tris "sur place"

complexit mmoire en O(1)

12

4-3
4-3-1

LE TRI FUSION

LA FUSION
fusion de 2 listes ordonnes

slection et retrait du plus petit des 2 premiers

lments jusqu' avoir parcouru les 2 listes

13

T1 1 4 5 6 9
T2 2 3 4
T

T1 1 4 5 6 9
T2 2 3 4
T 1 2 3 4
T1

T2 2

T1 1 4 5 6 9
T2 2 3 4
T 1

T1 1 4 5 6 9
T1 1 4 5 6 9
T2 2 3 4
T2 2 3 4
T 1 2 3
T 1 2 3 4

5 6 9

3 4

1 2 3 4 4

UN EXEMPLE

T1 1 4 5 6 9
T2 2 3 4
T 1 2

T1 1 4 5 6 9
T2 2

3 4

1 2 3 4 4 5 6 9
14

T1 1 4 5 6 9
T2 2 3 4

n1 termes
n2 termes
Tant quil reste des lments dans les deux tableaux
on slectionne le plus petit

T1

T2 2

5 6 9

Quand on est au bout de lun des tableaux

on recopie le reste de lautre.

3 4

1 2 3 4 4

UN EXEMPLE suite

i
j

T1

4 5 6

T2

3 4

1 2 3 4 4 5 6 9
15

void fusion (CTab t1; CTab t2; CTab t)

//fusionne les deux tableaux ordonns t1 et t2 en un seul tableau ordonn t

CIndice

i, j, k = 1;

dbut
n1=t1.long; n2=t2.long;
tant que i n1 et j n2 faire //jusqu' "avoir vid" l'un des 2 tableaux
si

t1.tab[i] t2.tab[j] alors //slection dans tab du plus petit des 2

tableaux

t.tab[k] = t1.tab[i] ;
i = i+1 ;
sinon

t.tab[k] = t2.tab[j] ;
j = j+1 ;

finsi;

k := k+1 ;
fait;

16

si i n1 alors //ajouter les lments restants de t1.tab

tant que i n1 faire
t.tab[k]=t1.tab[i]; i=i+1; k = k+1;
fait;
sinon
//ajouter les lments restants de t2.tab
tant que j n2 faire
t.tab[k]=t2.tab[j]; j=j+1;
k = k+1;
fait;
finsi;
fin
complexit: O(n1+n2)
17

4-2-2 TRI FUSION

procdure rcursive:
diviser la squence de n lments en 2 soussquences de n/2 lments (ou n/2 et n/2+1)
trier chaque sous-squence avec tri-fusion
fusionner les 2 sous-squences tries
18

5 2 4 6 1 3 2 6
5 2 4 6
5 2
5

1 3 2 6

4 6
4

1 3
6

2 6
3

Division
19

1 2 2 3 4 5 6 6
2 4 5 6
2 5
5

1 2 3 6

4 6
4

1 3
6

2 6
3

Fusion
20

"descente" division
"remonte" fusion

EXEMPLE
1 2 2 3 4 5 6 6
5 2 4 6 1 3 2 6
fusion

fusion

division

2 4 5 6
5 2 4 6
fusion

division

fusion

fusion

4 6
4 6

2 5
5 2
f

1 2 3 6
1 3 2 6

division

1 3
1 3
f

fusion

2 6
2 6
f

6
21

a h n o p r v

b f s w c k t
b c f k s t w

tri "sur place"

un seul tableau

void fusionner (CTab t, Indice g, Indice d)

partir de fusion(t1 ,t2 ,t)
m=(g+d)/2
t.tab: de g d t1.tab : de g m t2.tab : de m+1 d
suppose que les lments de g m (et de m+1 d) sont
ordonns
(on suppose que cette procdure est fournie: implmentation non donne ici)
22

void tri-fusion

(CTab t , Indice i, Indice j)

//tri-fusion du sous-tableau de t.tab allant de i j

CIndice

d, m, g ;

dbut

i > j alors "erreur";

si i < j alors
//il y a plus d'un lment dans le sous-tableau
g=i;d=j;
m = i+j / 2 ;
//sparation en 2 "sous-sous-tableaux"
tri-fusion (t.tab,g,m) ;
tri-fusion (t.tab,m+1,d);
fusionner (t.tab,g,d);
si

//si i = j il n'y a qu'un lment: fin ;

finsi ;
fin ;

appel:
tri "sur place":

tri-fusion(t.tab,1,n);
complexit mmoire en O(1)

23

4-2-3

COMPLEXIT ET RCURRENCE

a) complexit du tri-fusion
nombre d'lments
par sous-tableau
( 1 prs)
N
niveau 1
N/2
N/2
.
.
.
k = 2I
N/k... ... ... ... ...N/k
niveau I
noeuds
.
.
.
.
k=N
niveau log2N 1 1 ... ... ... ... ... ... 1 1 noeuds

niveau I:

O(k . N/k) = O(N) oprations

24

complexit du tri-fusion
O(n log n)
tri-fusion = trs bon tri
b)complexit des algorithmes rcursifs (facultatif)

"diviser pour rgner "

taille du problme: n
25


relation de rcurrence
(n): O(temps d'excution pour n)
- "diviser"
O(1)
- "rgner"
2 (n/2)
- fusionner
O(n)
(n) =
O(1)
2 (n/2)+O(n)

si n = 1
si n > 1

par substitutions on obtient:

(n) = O(n logn)
26

autres rsultats

- : fonction croissante et (1)=1

- n>1, n = 2I , c = constante
(n) = (n/2)+c

(n) = O(logn)

(n) = 2(n/2)+cn

(n)=O(nlogn)

(n) = 2(n/2)+cn2

(n) = O(n2)

(n) = 4(n/2)+cn2

(n) = O(n2logn)
27

4-4 LE TRI PAR TAS

4-4-1

L'ALGORITHME

tas: (cf cours 3) arbre parfait tel que tout

noeud a une valeur celle de tous ses
descendants
mthodes:

estvide, min_tas,
insrer, supprimer_min
28

principe du tri par tas:

transformer la squence initiale en tas

extraire un un les lments min

(racines) en conservant la structure de tas

l: liste trier de n lments (classe CTab)

letas: tas utilis pour le tri (classe C_Tas)
Dans ces deux classes on utilise une reprsentation par un tableau dont les
indices sont de la classe CIndice (entiers allant de 1 la taille du tableau)
29

tri_par_tas (CTab l)
entier val; C_Tas letas= new C_Tas (l.long) ; entier n=l.long;

void

dbut
pour

k=1 n faire //construction du tas associ l

val = l.tab[k];
letas.insrer (val) ;

fait ;
pour k=1 n faire
//slection successive des min du tas qui sont reports leur place dans l

val = letas.min_tas;
l.tab[k]= val ;
//suppression du min en gardant la structure de tas

letas.supprimer_min;
fait ;
fin ;

30

tri_par_tas (CTab l)
entier val; C_Tas letas= new C_Tas (l.long) ; entier n=l.long;

void

dbut
pour

k=1 n faire
val = l.tab[k];
letas.insrer (val) ; O(log n)

n fois

fait ;

k=1 n faire
val = letas.min_tas; O(1)
l.tab[k]= val ;
letas.supprimer_min; O(log n)

pour

n fois

fait ;
fin ;

31

4-4-2 COMPLEXIT
-n itrations pour chaque boucle
-insrer et supprimer en O(log n)
complexit du tri par tas
O(n log n)
espace mmoire: ici O(n)
mais, tri "sur place" possible avec programmation
de mme principe un peu plus complexe

complexit en mmoire O(1)

tri par tas: trs bon tri
32

4-5

LE TRI RAPIDE
(implmentation non tudie ici)

principe

pivot

>

> >

change

pivot

> > >

change

pivot > > >

pivot > > >

tri-rapide

place
dfinitive

tri-rapide
33

LE TRI RAPIDE

10

12

18

15

12

10

18

15

12

10

18

15

12

10

18

15
34

LE TRI RAPIDE

12

10

10

18

15

12

10

18

15

10

12

15

18

12

15

18
35

procdure rcursive :

slectionner un lment pivot p

partitionner la liste trier en 2 souslistes:

gauche du pivot, lments p
droite du pivot, lments > p

- tri-rapide des 2 sous-listes

- concatnation des listes tries
36

tri "sur place" (+ pile)

complexit du tri rapide
au pire: O(n2)
en moyenne: O(nlogn)
tri rapide: trs bon tri en gnral

37

4-6 COMPARAISON DES TRIS PAR

COMPARAISON
de 4.1 4.5:

tris avec tests comparatifs

4-6-1 TRIS ET ORDINATEURS

tri de n nombres

tri par insertion

sur super-ordinateur 100 mips
langage machine
programmeur champion
2n2 instructions

38

 tri fusion
sur micro

1 mips

compilateur peu efficace

programmeur moyen
50nlogn instructions
39

si n = 106
tri du super-ordinateur (insertion):
2.(106)2/108 = 20 000 sec = 5,56h

tri du micro (fusion):

50.106.log 106 / 106 = 1 000 sec
= 16,67 mn
(cf cours 2: complexit)

40

4-6-2 CHOIX D'UN TRI

peu important si petite liste
sur une mme machine:
tri rapide

tri par insertion sq

0,2s
0,9s
4,4s

1,6s
24s
6,6mn

pour 250 lments

pour 1000 lments
pour 4000 lments
41

types de
tris
slection
insertion
fusion
par tas
rapide

complexit
au pire
moyenne
n2
n2
n2
n2
nlogn
nlogn
nlogn
nlogn
nlogn
n2

nlogn = borne non amliorable

pour tris par comparaisons
42

Conclusion
tri par tas: meilleure complexit
tri rapide et tri fusion: efficaces
tri par insertion excellent si liste initiale
presque trie
et
tri par slection donne le dbut de liste tri
avant la fin du tri
tri par insertion peut dbuter sans liste initiale
complte
43

4-7 TRI PAR DNOMBREMENT

4-7-1

PRINCIPE

tri trs efficace si les n nombres

trier son petits
(au moins tous n)
aucune comparaison
44

pour chaque lment e:

p= nombre d'lments < e
q= nombre d'lments = e
places des lments gaux e:
p+1,p+2,..,p+q-1, p+q
valable pour tout ensemble E t.q.
bijection entre E et {1,..,n}
EXEMPLE

alphabet {1,..,26}
45

4-7-2 PROCDURE
A: tableau de n entier; trier
B: tableau de n entier; rsultat
k=

- nombre d'lments diffrents contenus

dans A si ce nombre est connu
- plus grand lment de A sinon
46

CTab tri-dnombrement (CTab A, entier k)

CTab B (A.long); CTab C (k); entier n=A.long;
dbut
//pour simplifier on note A[i] au lieu de A.tab[i], idem pour B et C
pour i =1 k faire
C[i] = 0;
fait;
pour j =1 n faire
C[A[j]] = C[A[j]]+1;
fait;
//C[i] contient le nombre d'lments de A gaux i
pour i =2 k faire
C[i] = C[i] + C[i-1];
fait;
...

47


//C[i] contient le nombre d'lments gaux ou < i
//il reste placer les lments dans B
pour j :=n 1 pas -1 faire
B[C[A[j]]] := A[j];
//l'lment A[j] doit tre mis dans B la place C[A[j]]
C[A[j]] := C[A[j]]-1;
//cas d'galit de 2 lments: le deuxime est en C[A[j]]-1
fait;
retourner B;
fin
48

EXEMPLE
i= 1 2 3 4

5 6 7

A 3 6 4 1 3 4 1 4

k=6

C 2 0 2 3 0 1

nombre d'lments = i

C 2 2 4 7 7 8

nombre d'lments i

1 2 3 4

5 6 7

B 1 1 3 3 4 4 4 6
5 2 8 4 6

3 1

ordre de remplissage

49

complexit du tri par

dnombrement
si k = O(n), tri en O(n)
meilleure complexit possible pour un tri
de n nombres

50

4-7-3

REMARQUES DIVERSES

autres tris efficaces: tris par base, par

paquets,
tous les tris tudis supposent que tous les
nombres trier sont prsents en mmoire
centrale
si le nombre d'objets trier est trop
grand: tris externes avec minimisation des
entres-sorties
51